cleaned up ktUtils, passing tests

Author: alxmrs

src/tools/kotlin-generation-utils.ts

@@ -1,42 +1,84 @@
-export interface KotlinConstants {
+/**
+ * @license
+ * Copyright (c) 2020 Google Inc. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * Code distributed by Google as part of this project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+/**
+ * Kotlin language formatting preferences.
+ */
+export interface KotlinPreferences {
   indent: number;
   lineLength: number;
 }
 
-export const KT_BASE: KotlinConstants = {indent: 4, lineLength: 120};
+/**
+ * Default language formatting settings.
+ */
+export const KT_DEFAULT: KotlinPreferences = {indent: 4, lineLength: 120};
 
-function collectionTemplate(items: string[], indent: number = KT_BASE.indent, collection: string = 'list') {
-  const lowered = collection.toLowerCase();
-  if (items.length == 0){
-    return `empty${lowered[0].toUpperCase()}${lowered.substring(1)}()`;
+/**
+ * Collection of utilities for generating Kotlin code.
+ */
+export class KotlinGenerationUtils {
+  constructor(public pref: KotlinPreferences = KT_DEFAULT) {
   }
-  return `${lowered}Of(${joinWithinLine(items, indent)})`;
-}
 
-export function mapOf(items: string[], indent: number = KT_BASE.indent): string {
-  return collectionTemplate(items, indent, 'map');
-}
+  /**
+   * Formats a function application in Kotlin.
+   *
+   * @param name name of the function
+   * @param args list of arguments to the function
+   * @param emptyName alternative name for the function with empty arguments.
+   */
+  applyFun(name: string, args: string[], emptyName: string = name): string {
+    if (args.length == 0) return `${emptyName}()`;
+    return `${name}(${this.joinWithIndents(args)})`;
+  }
 
-export function listOf(items: string[], indent: number = KT_BASE.indent): string {
-  return collectionTemplate(items, indent);
-}
+  /** Formats `mapOf` with correct indentation and defaults. */
+  mapOf(args: string[]): string {
+    return this.applyFun('mapOf', args, 'emptyMap');
+  }
+
+  /** Formats `mutableMapOf` with correct indentation and defaults. */
+  mutableMapOf(args: string[]): string {
+    return this.applyFun('mutableMapOf', args);
+  }
 
-export function setOf(items: string[], indent: number = KT_BASE.indent): string {
-  return collectionTemplate(items, indent, 'set');
+  /** Formats `listOf` with correct indentation and defaults. */
+  listOf(args: string[]): string {
+    return this.applyFun('listOf', args, 'emptyList');
+  }
+
+  /** Formats `setOf` with correct indentation and defaults. */
+  setOf(args: string[]): string {
+    return this.applyFun('setOf', args, 'setList');
+  }
+
+  /**
+   * Joins a list of items, taking line length and indentation into account.
+   *
+   * @param items strings to join
+   * @param lineStart (optional) add the starting indentation when calculating line limits.
+   */
+  joinWithIndents(items: string[], lineStart: number = 0): string {
+    const candidate = items.join(', ');
+    if (lineStart + candidate.length <= this.pref.lineLength) return candidate;
+    return '\n' + leftPad(leftPad(items.join(',\n'), this.pref.indent), lineStart) + '\n';
+  }
 }
 
+
+/** Everyone's favorite NPM module, install not required. */
 export function leftPad(input: string, indent: number, skipFirst: boolean = false) {
   return input
     .split('\n')
     .map((line: string, idx: number) => (idx === 0 && skipFirst) ? line : ' '.repeat(indent) + line)
     .join('\n');
 }
 
-export function joinWithinLine(items: string[],
-                               startIndent: number,
-                               indent: number = KT_BASE.indent,
-                               limit: number = KT_BASE.lineLength): string {
-  const candidate = items.join(', ');
-  if (startIndent + candidate.length <= limit) return candidate;
-  return '\n' + leftPad(items.join(',\n' + indent), startIndent) + '\n';
-}

src/tools/schema2kotlin.ts

@@ -11,7 +11,7 @@ import {Schema2Base, ClassGenerator, AddFieldOptions} from './schema2base.js';
 import {SchemaNode} from './schema2graph.js';
 import {ParticleSpec} from '../runtime/particle-spec.js';
 import minimist from 'minimist';
-import {leftPad, mapOf} from './kotlin-generation-utils.js';
+import {leftPad, KotlinGenerationUtils} from './kotlin-generation-utils.js';
 
 // TODO: use the type lattice to generate interfaces
 
@@ -35,6 +35,8 @@ const typeMap = {
   'B': {type: 'Boolean', decodeFn: 'decodeBool()', defaultVal: 'false', schemaType: 'FieldType.Boolean'},
 };
 
+const ktUtils = new KotlinGenerationUtils();
+
 export class Schema2Kotlin extends Schema2Base {
   // test-KOTLIN.file_Name.arcs -> TestKotlinFileName.kt
   outputName(baseName: string): string {
@@ -205,8 +207,8 @@ export class KotlinGenerator implements ClassGenerator {
 Schema(
     listOf(${schemaNames.join(',\n' + ' '.repeat(8))}),
     SchemaFields(
-        singletons = ${leftPad(mapOf(this.singletonSchemaFields), 8, true)},
-        collections = ${leftPad(mapOf(this.collectionSchemaFields), 8, true)}
+        singletons = ${leftPad(ktUtils.mapOf(this.singletonSchemaFields), 8, true)},
+        collections = ${leftPad(ktUtils.mapOf(this.collectionSchemaFields), 8, true)}
     ),
     "${schemaHash}"
 )`;

src/tools/tests/kotlin-generation-utils-test.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright (c) 2020 Google Inc. All rights reserved.
+ * This code may only be used under the BSD style license found at
+ * http://polymer.github.io/LICENSE.txt
+ * Code distributed by Google as part of this project is also
+ * subject to an additional IP rights grant found at
+ * http://polymer.github.io/PATENTS.txt
+ */
+
+import {assert} from '../../platform/chai-node.js';
+import {KotlinGenerationUtils} from '../kotlin-generation-utils.js';
+
+describe('kotlin-generations-utils', () => {
+  const ktUtils = new KotlinGenerationUtils();
+  describe('mapOf', () => {
+    it('when no items are present, it creates an empty map', () => {
+      const actual = ktUtils.mapOf([]);
+      assert.strictEqual('emptyMap()', actual);
+    });
+    it('when one item is present, it creates a single-line map', () => {
+      const actual = ktUtils.mapOf([`"a" to "b"`]);
+      assert.strictEqual('mapOf("a" to "b")', actual);
+    });
+    it('when few items are present, it creates a single-line map', () => {
+      const actual = ktUtils.mapOf([`"a" to "b"`, `"b" to "c"`]);
+      assert.strictEqual(`mapOf("a" to "b", "b" to "c")`, actual);
+    });
+    it('when many items are present, it creates a multi-line map', () => {
+      const actual = ktUtils.mapOf([
+        `"a" to "b"`,
+        `"b" to "c"`,
+        `"c" to "d"`,
+        `"d" to "e"`,
+        `"e" to "f"`,
+        `"f" to "g"`,
+        `"g" to "h"`,
+        `"h" to "i"`,
+        `"i" to "j"`,
+        `"j" to "k"`,
+        `"k" to "l"`,
+      ]);
+      assert.strictEqual(`\
+mapOf(
+    "a" to "b",
+    "b" to "c",
+    "c" to "d",
+    "d" to "e",
+    "e" to "f",
+    "f" to "g",
+    "g" to "h",
+    "h" to "i",
+    "i" to "j",
+    "j" to "k",
+    "k" to "l"
+)`, actual);
+    });
+  });
+});