Merge pull request #1677 from friederbluemle/update-prettier

Author: friederbluemle

.prettierrc.json

@@ -1,5 +1,4 @@
 {
   "singleQuote": true,
-  "semi": false,
-  "trailingComma": "es5"
+  "trailingComma": "all"
 }

ern-api-gen/src/AbstractGenerator.ts

@@ -1,39 +1,39 @@
-import { log } from 'ern-core'
-import _F from './java/File'
-import fs from 'fs'
-import path from 'path'
+import { log } from 'ern-core';
+import _F from './java/File';
+import fs from 'fs';
+import path from 'path';
 
-const File = _F
+const File = _F;
 
-const ABSTRACT_SEARCH_PATHS = [path.join(__dirname, '..', 'resources')]
+const ABSTRACT_SEARCH_PATHS = [path.join(__dirname, '..', 'resources')];
 
 export default class AbstractGenerator {
-  public static SEARCH_PATHS = ABSTRACT_SEARCH_PATHS
+  public static SEARCH_PATHS = ABSTRACT_SEARCH_PATHS;
 
   public writeToFile(filename, contents) {
-    log.info('writing file ' + filename)
-    const f = new File(filename)
-    f.getParentFile().mkdirs()
-    return fs.writeFileSync(f.getPath(), contents, 'utf8')
+    log.info('writing file ' + filename);
+    const f = new File(filename);
+    f.getParentFile().mkdirs();
+    return fs.writeFileSync(f.getPath(), contents, 'utf8');
   }
 
   public readTemplate(name) {
-    const reader = this.getTemplateReader(name)
+    const reader = this.getTemplateReader(name);
     if (reader == null) {
-      throw new Error(`no file found for "${name}"`)
+      throw new Error(`no file found for "${name}"`);
     }
-    return reader
+    return reader;
   }
 
   public getTemplateReader(name) {
-    const f = this._resolveFilePath(name)
+    const f = this._resolveFilePath(name);
     if (f == null) {
-      throw new Error("can't load template " + name)
+      throw new Error("can't load template " + name);
     }
     try {
-      return fs.readFileSync(f, 'utf-8')
+      return fs.readFileSync(f, 'utf-8');
     } catch (e) {
-      log.trace(e)
+      log.trace(e);
     }
   }
 
@@ -48,73 +48,73 @@ export default class AbstractGenerator {
    * @return String Full template file path
    */
   public getFullTemplateFile(config, templateFile) {
-    const library = config.getLibrary()
+    const library = config.getLibrary();
     if (library) {
       const libTemplateFile = this._resolveFilePath(
         config.embeddedTemplateDir(),
         'libraries',
         library,
-        templateFile
-      )
+        templateFile,
+      );
       if (libTemplateFile != null) {
-        return libTemplateFile
+        return libTemplateFile;
       }
     }
 
     const embeddedTemplate = this._resolveFilePath(
       config.embeddedTemplateDir(),
-      templateFile
-    )
+      templateFile,
+    );
     if (embeddedTemplate != null) {
-      return embeddedTemplate
+      return embeddedTemplate;
     }
 
-    const template = this._resolveFilePath(config.templateDir(), templateFile)
+    const template = this._resolveFilePath(config.templateDir(), templateFile);
     if (template != null) {
-      return template
+      return template;
     }
   }
 
   public readResourceContents(resourceFilePath) {
-    const file = this._resolveFilePath(resourceFilePath)
+    const file = this._resolveFilePath(resourceFilePath);
     if (file == null) {
-      log.warn(`Could not resolve ${resourceFilePath}`)
-      return
+      log.warn(`Could not resolve ${resourceFilePath}`);
+      return;
     }
 
-    return fs.readFileSync(file, 'utf8')
+    return fs.readFileSync(file, 'utf8');
   }
 
   public embeddedTemplateExists(name) {
-    const f = this._resolveFile(name)
-    return f != null
+    const f = this._resolveFile(name);
+    return f != null;
   }
 
   public getCPResourcePath(name) {
     if (!('/' === File.separator)) {
-      return name.replace(new RegExp(File.separator, 'g'), '/')
+      return name.replace(new RegExp(File.separator, 'g'), '/');
     }
-    return name
+    return name;
   }
 
   protected _resolveFilePath(...paths) {
-    const f = this._resolveFile(...paths)
+    const f = this._resolveFile(...paths);
     if (f == null) {
-      return
+      return;
     }
-    return f.getAbsolutePath()
+    return f.getAbsolutePath();
   }
 
   protected _resolveFile(...paths) {
     for (const p of AbstractGenerator.SEARCH_PATHS) {
-      const file = new File(p, ...paths)
+      const file = new File(p, ...paths);
       if (file.exists()) {
-        return file
+        return file;
       }
     }
-    const last = new File(paths.shift(), ...paths)
+    const last = new File(paths.shift(), ...paths);
     if (last.exists()) {
-      return last
+      return last;
     }
   }
 }

ern-api-gen/src/ApiGenUtils.ts

@@ -1,5 +1,5 @@
-import CodegenConfigurator from './config/CodegenConfigurator'
-import DefaultGenerator from './DefaultGenerator'
+import CodegenConfigurator from './config/CodegenConfigurator';
+import DefaultGenerator from './DefaultGenerator';
 
 export default class ApiGenUtils {
   /**
@@ -11,44 +11,44 @@ export default class ApiGenUtils {
         inputSpec: swaggerSchemaFile,
         lang: 'ERNAndroid', // Using android as a reference language, apiName, requests and responses will be same for all the langs.
         outputDir: 'fake',
-      }
-      const cc = new CodegenConfigurator(config)
-      const opts = await cc.toClientOptInput()
-      const generator = new DefaultGenerator().opts(opts)
-      const apis = generator.processPaths(generator.swagger.getPaths()).value
+      };
+      const cc = new CodegenConfigurator(config);
+      const opts = await cc.toClientOptInput();
+      const generator = new DefaultGenerator().opts(opts);
+      const apis = generator.processPaths(generator.swagger.getPaths()).value;
 
       const result: Array<{
-        apiName: string
-        requests: string[]
-        events: string[]
-      }> = []
+        apiName: string;
+        requests: string[];
+        events: string[];
+      }> = [];
       for (const apiKey in apis) {
         if (apis.hasOwnProperty(apiKey)) {
           const {
             requests,
             events,
-          } = ApiGenUtils.generateApiEventsAndRequestNames(apis[apiKey])
-          result.push({ apiName: apiKey, requests, events })
+          } = ApiGenUtils.generateApiEventsAndRequestNames(apis[apiKey]);
+          result.push({ apiName: apiKey, requests, events });
         }
       }
-      return result
+      return result;
     } catch (e) {
-      throw new Error(`Unable to extract the apis: ${e}`)
+      throw new Error(`Unable to extract the apis: ${e}`);
     }
   }
 
   public static generateApiEventsAndRequestNames(
-    api: any
+    api: any,
   ): { requests: string[]; events: string[] } {
-    const requests: string[] = []
-    const events: string[] = []
+    const requests: string[] = [];
+    const events: string[] = [];
     for (const key in api) {
       if (api.hasOwnProperty(key) && api[key].httpMethod === `EVENT`) {
-        events.push(api[key].camelizedNickName)
+        events.push(api[key].camelizedNickName);
       } else {
-        requests.push(api[key].camelizedNickName)
+        requests.push(api[key].camelizedNickName);
       }
     }
-    return { requests, events }
+    return { requests, events };
   }
 }

ern-api-gen/src/CliOption.ts

@@ -1,104 +1,99 @@
 /* tslint:disable:variable-name */
-import { BooleanProperty, StringProperty } from './models/properties'
-import { newHashMap } from './java/javaUtil'
-import StringBuilder from './java/StringBuilder'
+import { BooleanProperty, StringProperty } from './models/properties';
+import { newHashMap } from './java/javaUtil';
+import StringBuilder from './java/StringBuilder';
 
 export default class CliOption {
   public static newBoolean(opt, description) {
     return new CliOption(opt, description, BooleanProperty.TYPE).defaultValue(
-      'false'
-    )
+      'false',
+    );
   }
 
   public static newString(opt, description) {
-    return new CliOption(opt, description, StringProperty.TYPE)
+    return new CliOption(opt, description, StringProperty.TYPE);
   }
 
-  private opt
-  private description
-  private enumValues
-  private type
-  private __defaultValue
+  private opt;
+  private description;
+  private enumValues;
+  private type;
+  private __defaultValue;
 
   public constructor(
     opt,
     description,
     type = StringProperty.TYPE,
     short?: any,
     enumValues?: any,
-    required?: any
+    required?: any,
   ) {
-    this.opt = opt
-    this.description = description
-    this.type = type
+    this.opt = opt;
+    this.description = description;
+    this.type = type;
   }
 
   public getOpt() {
-    return this.opt
+    return this.opt;
   }
 
   public getDescription() {
-    return this.description
+    return this.description;
   }
 
   public setDescription(description) {
-    this.description = description
+    this.description = description;
   }
 
   public getType() {
-    return this.type
+    return this.type;
   }
 
   public setType(type) {
-    this.type = type
+    this.type = type;
   }
 
   public getDefault() {
-    return this.__defaultValue
+    return this.__defaultValue;
   }
 
   public setDefault(defaultValue) {
-    this.__defaultValue = defaultValue
+    this.__defaultValue = defaultValue;
   }
 
   public defaultValue(defaultValue) {
-    this.__defaultValue = defaultValue
-    return this
+    this.__defaultValue = defaultValue;
+    return this;
   }
 
   public addEnum(value, description) {
     if (this.enumValues == null) {
-      this.enumValues = newHashMap()
+      this.enumValues = newHashMap();
     }
     if (!this.enumValues.containsKey(value)) {
-      this.enumValues.put(value, description)
+      this.enumValues.put(value, description);
     }
-    return this
+    return this;
   }
 
   public getEnum() {
-    return this.enumValues
+    return this.enumValues;
   }
 
   public setEnum(enumValues) {
-    this.enumValues = enumValues
+    this.enumValues = enumValues;
   }
 
   public getOptionHelp() {
-    const sb = StringBuilder(this.description)
+    const sb = StringBuilder(this.description);
     if (this.__defaultValue != null) {
-      sb.append(' (Default: ')
-        .append(this.__defaultValue)
-        .append(')')
+      sb.append(' (Default: ').append(this.__defaultValue).append(')');
     }
     if (this.enumValues != null) {
       for (const [key, value] of this.enumValues) {
-        sb.append('\n    ')
-          .append(key)
-          .append(' - ')
-          .append(value)
+        sb.append('\n    ').append(key).append(' - ').append(value);
       }
     }
-    return sb.toString()
+    return sb.toString();
   }
 }