@caleuche/cli 0.3.0 → 0.4.1

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @caleuche/cli
 
+## 0.4.1
+
+### Patch Changes
+
+- Updated dependencies [1dd1a48]
+- Updated dependencies [6254997]
+  - @caleuche/core@0.3.0
+
+## 0.4.0
+
+### Minor Changes
+
+- 566dad9: Updated command help strings.
+- 6215af4: Adding option directory to batch command.
+
 ## 0.3.0
 
 ### Minor Changes

package/dist/batch.js

@@ -34,7 +34,7 @@ function loadVariantDefinitions(variants, workingDirectory) {
     for (const { name, input } of variants) {
         const v = loadVariantInputDefinition(input, workingDirectory);
         if (!v) {
-            console.error(`Failed to load variant definition for key "${name}": ${input}`);
+            console.error(`Failed to load variant definition for key "${name}"`);
             return null;
         }
         definitions[name] = v;
@@ -66,7 +66,7 @@ function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
         return null;
     }
 }
-function batchCompile(batchFile) {
+function batchCompile(batchFile, options) {
     if (!(0, utils_1.isFile)(batchFile)) {
         console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
         process.exit(1);
@@ -97,8 +97,8 @@ function batchCompile(batchFile) {
             if (!resolvedVariant) {
                 process.exit(1);
             }
-            const effectiveOutputPath = path_1.default.join(workingDirectory, variant.output);
-            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant, effectiveOutputPath, {
+            const effectiveOutputPath = path_1.default.join(options?.outputDir || workingDirectory, variant.output);
+            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant.properties, effectiveOutputPath, {
                 project: true,
             })) {
                 console.error(`Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`);

package/dist/index.js

@@ -10,8 +10,15 @@ commander_1.program
     .description("Caleuche CLI for compiling samples")
     .version(package_json_1.version);
 commander_1.program
-    .command("compile <sample-directory> <data-file> <output-directory>")
-    .option("-p, --project", "Generate project file")
+    .command("compile")
+    .argument("<sample-path>", "Path to the sample file or the directory that containes it.")
+    .argument("<data-file>", "Path to the input to be used to compile the template.")
+    .argument("<output-directory>", "Directory where the compiled output will be written.")
+    .option("-p, --project", "Flag to indicate whether to generate the appropriate project file along with the compiled template.")
     .action(compile_1.compile);
-commander_1.program.command("batch <batch-file>").action(batch_1.batchCompile);
+commander_1.program
+    .command("batch")
+    .argument("<batch-file>", "Path to the batch file")
+    .option("-d, --output-dir <outputDir>", "Output directory for compiled samples")
+    .action(batch_1.batchCompile);
 commander_1.program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"
@@ -19,7 +19,7 @@
   "license": "MIT",
   "description": "Caleuche CLI",
   "dependencies": {
-    "@caleuche/core": "^0.2.0",
+    "@caleuche/core": "^0.3.0",
     "commander": "^14.0.0",
     "yaml": "^2.8.0"
   },

package/src/batch.ts

@@ -42,9 +42,7 @@ function loadVariantDefinitions(
   for (const { name, input } of variants) {
     const v = loadVariantInputDefinition(input, workingDirectory);
     if (!v) {
-      console.error(
-        `Failed to load variant definition for key "${name}": ${input}`,
-      );
+      console.error(`Failed to load variant definition for key "${name}"`);
       return null;
     }
     definitions[name] = v;
@@ -82,7 +80,10 @@ function resolveVariantDefinition(
   }
 }
 
-export function batchCompile(batchFile: string) {
+export function batchCompile(
+  batchFile: string,
+  options: { outputDir?: string },
+) {
   if (!isFile(batchFile)) {
     console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
     process.exit(1);
@@ -127,12 +128,20 @@ export function batchCompile(batchFile: string) {
         process.exit(1);
       }
 
-      const effectiveOutputPath = path.join(workingDirectory, variant.output);
+      const effectiveOutputPath = path.join(
+        options?.outputDir || workingDirectory,
+        variant.output,
+      );
 
       if (
-        !compileAndWriteOutput(sample, resolvedVariant, effectiveOutputPath, {
-          project: true,
-        })
+        !compileAndWriteOutput(
+          sample,
+          resolvedVariant.properties,
+          effectiveOutputPath,
+          {
+            project: true,
+          },
+        )
       ) {
         console.error(
           `Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`,

package/src/index.ts

@@ -11,10 +11,32 @@ program
   .version(version);
 
 program
-  .command("compile <sample-directory> <data-file> <output-directory>")
-  .option("-p, --project", "Generate project file")
+  .command("compile")
+  .argument(
+    "<sample-path>",
+    "Path to the sample file or the directory that containes it.",
+  )
+  .argument(
+    "<data-file>",
+    "Path to the input to be used to compile the template.",
+  )
+  .argument(
+    "<output-directory>",
+    "Directory where the compiled output will be written.",
+  )
+  .option(
+    "-p, --project",
+    "Flag to indicate whether to generate the appropriate project file along with the compiled template.",
+  )
   .action(compile);
 
-program.command("batch <batch-file>").action(batchCompile);
+program
+  .command("batch")
+  .argument("<batch-file>", "Path to the batch file")
+  .option(
+    "-d, --output-dir <outputDir>",
+    "Output directory for compiled samples",
+  )
+  .action(batchCompile);
 
 program.parse();

package/src/utils.ts

@@ -3,6 +3,8 @@ import fs from "fs";
 import path from "path";
 import { Sample } from "@caleuche/core";
 
+export type Optional<T> = T | undefined;
+
 export function parse<T>(filePath: string): T | null {
   try {
     const fileContent = fs.readFileSync(filePath, "utf-8");

package/test/bach.test.ts

@@ -1,46 +1,23 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import path from "path";
-
-vi.mock("fs");
 import fs from "fs";
-const mockFs = vi.mocked(fs);
+import path from "path";
+import os from "os";
 
 vi.mock("@caleuche/core");
-import { compileSample, Sample } from "@caleuche/core";
+import { compileSample } from "@caleuche/core";
 const mockCompileSample = vi.mocked(compileSample);
 
-vi.mock("../src/utils");
-import {
-  parse,
-  resolveSampleFile,
-  createOutputDirectory,
-  resolveTemplate,
-  isVariantInputDefinition,
-  getAbsoluteDirectoryPath,
-  isFile,
-  isVariantInputReference,
-  getVariantInputReferenceValue,
-} from "../src/utils";
-const mockParse = vi.mocked(parse);
-const mockResolveSampleFile = vi.mocked(resolveSampleFile);
-const mockCreateOutputDirectory = vi.mocked(createOutputDirectory);
-const mockResolveTemplate = vi.mocked(resolveTemplate);
-const mockIsVariantInputReference = vi.mocked(isVariantInputReference);
-const mockGetVariantInputReferenceValue = vi.mocked(
-  getVariantInputReferenceValue,
-);
-const mockIsVariantInputDefinition = vi.mocked(isVariantInputDefinition);
-const mockGetAbsoluteDirectoryPath = vi.mocked(getAbsoluteDirectoryPath);
-const mockIsFile = vi.mocked(isFile);
-
 import { batchCompile } from "../src/batch";
+import { Optional } from "../src/utils";
+import { multiline } from "./utils.test";
 
 describe("batchCompile", () => {
+  let tempDir: Optional<string>;
   let mockExit: any;
   let mockConsoleError: any;
 
   beforeEach(() => {
-    vi.clearAllMocks();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "caleuche-cli-test-"));
     mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
       throw new Error("process.exit");
     });
@@ -48,25 +25,30 @@ describe("batchCompile", () => {
   });
 
   afterEach(() => {
+    if (tempDir) {
+      fs.rmSync(tempDir, { recursive: true });
+    }
     vi.restoreAllMocks();
   });
 
+  function getPath(relative: string): string {
+    return path.join(tempDir!, relative);
+  }
+
   it("should exit if batch file does not exist", () => {
-    mockFs.existsSync.mockReturnValue(false);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(getPath("batch.yaml"), {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      'Batch file "batch.yaml" does not exist or is not a file.',
+      `Batch file "${getPath("batch.yaml")}" does not exist or is not a file.`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if batch file is not a file", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => false } as any);
+    fs.mkdirSync(getPath("batch.yaml"));
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile("batch.yaml", {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
       'Batch file "batch.yaml" does not exist or is not a file.',
@@ -75,134 +57,161 @@ describe("batchCompile", () => {
   });
 
   it("should exit if batch file cannot be parsed", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
-    mockParse.mockReturnValueOnce(null);
+    const batchFilePath = getPath("batch.yaml");
+    const invalidYaml = multiline`
+      invalid: yaml: structure:
+        broken
+    `;
+    fs.writeFileSync(batchFilePath, invalidYaml);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      'Batch file "batch.yaml" does not exist or is not a file.',
+      `Failed to parse batch file: ${batchFilePath}`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if variant definitions cannot be loaded", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
-    mockParse
-      .mockImplementationOnce(() => ({
-        variants: [
-          { name: "foo", input: { type: "path", value: "badvariant.yaml" } },
-        ],
-        samples: [],
-      }))
-      .mockImplementationOnce(() => null);
+    const batchFilePath = getPath("batch.yaml");
+    const content = multiline`
+      variants:
+        - name: foo
+          input:
+            type: path
+            value: badvariant.yaml
+    `;
+    fs.writeFileSync(batchFilePath, content);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      `Batch file \"batch.yaml\" does not exist or is not a file.`,
+      `Failed to load variant definition for key "foo"`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if sample file not found", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
-    });
-    mockResolveSampleFile.mockReturnValue("sample.yaml");
-    mockFs.existsSync.mockReturnValueOnce(false);
+    const batchFilePath = getPath("batch.yaml");
+    const content = multiline`
+      samples:
+        - templatePath: sample.yaml
+          variants: []
+          output: out
+    `;
+    fs.writeFileSync(batchFilePath, content);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Failed to parse sample file: sample.yaml",
+      `Sample file not found: ${getPath("sample.yaml")}`,
     );
+
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if sample file cannot be parsed", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce(null);
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const invalidSampleContent = multiline`
+      some: invalid: yaml
+    `;
+    fs.writeFileSync(sampleFilePath, invalidSampleContent);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      'Batch file "batch.yaml" does not exist or is not a file.',
+      `Failed to parse sample file: ${sampleFilePath}`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if variant cannot be resolved", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [{ output: "out", input: "v1" }],
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantInputReference.mockReturnValue(true);
-    mockGetVariantInputReferenceValue.mockReturnValue("v1");
-    mockIsVariantInputDefinition.mockReturnValue(false);
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: bar
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      `Variant "v1" could not be resolved.`,
+      `Variant "bar" could not be resolved.`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws error", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [{ output: "out", input: "v1" }],
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw new Error("Compilation error");
     });
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       1,
@@ -210,37 +219,43 @@ describe("batchCompile", () => {
     );
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       2,
-      'Sample: sample.yaml, Variant: {"output":"out","input":"v1"}',
+      'Sample: sample.yaml, Variant: {"output":"out","input":"foo"}',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws unknown error", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [{ output: "out", input: "v1" }],
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw "Unknown error";
     });
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(getPath("batch.yaml"), {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
       "An unknown error occurred during compilation.",
@@ -249,51 +264,91 @@ describe("batchCompile", () => {
   });
 
   it("should compile and write output files for each variant", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: [],
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [
-            { output: "v1.output", input: {} },
-            { output: "v2.output", input: {} },
-          ],
-          output: "out",
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockReturnValue({
       items: [
         { fileName: "file1.js", content: "console.log('1');" },
         { fileName: "file2.js", content: "console.log('2');" },
       ],
     });
-    mockCreateOutputDirectory.mockImplementation(() => {});
-    mockFs.writeFileSync.mockImplementation(() => {});
-    batchCompile("batch.yaml");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
-      "/working/directory/v1.output",
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
+    batchCompile(batchFilePath, {});
+
+    expect(fs.existsSync(getPath("out/file1.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("out/file1.js"), "utf-8")).toBe(
+      "console.log('1');",
     );
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
-      "/working/directory/v2.output",
+    expect(fs.existsSync(getPath("out/file2.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("out/file2.js"), "utf-8")).toBe(
+      "console.log('2');",
     );
-    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("/working/directory", "v1.output", "file1.js"),
+  });
+
+  it("should compile and write output files for each variant", () => {
+    mockCompileSample.mockReturnValue({
+      items: [
+        { fileName: "file1.js", content: "console.log('1');" },
+        { fileName: "file2.js", content: "console.log('2');" },
+      ],
+    });
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
+    batchCompile(batchFilePath, { outputDir: getPath("other") });
+
+    expect(fs.existsSync(getPath("other/out/file1.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("other/out/file1.js"), "utf-8")).toBe(
       "console.log('1');",
     );
-    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("/working/directory", "v1.output", "file2.js"),
+    expect(fs.existsSync(getPath("other/out/file2.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("other/out/file2.js"), "utf-8")).toBe(
       "console.log('2');",
     );
   });

package/test/utils.test.ts

@@ -12,7 +12,7 @@ import {
 } from "../src/utils";
 import { Sample } from "@caleuche/core";
 
-function multiline(strings: TemplateStringsArray, ...values: any[]) {
+export function multiline(strings: TemplateStringsArray, ...values: any[]) {
   let result = strings[0];
   for (let i = 0; i < values.length; i++) {
     result += values[i] + strings[i + 1];