milkee 3.0.1-dev.0 → 3.1.0

package/.prettierrc.json

@@ -0,0 +1,3 @@
+{
+  "tabWidth": 2
+}

package/README-ja.md

@@ -1,7 +1,12 @@
-[English](./README.md) | **日本語**
-
 # Milkee
 
+[![Vitest](https://github.com/otoneko1102/coffeescript-milkee/actions/workflows/test.yml/badge.svg)](https://github.com/otoneko1102/coffeescript-milkee/actions)
+[![npm version](https://img.shields.io/npm/v/milkee.svg)](https://www.npmjs.com/package/milkee)
+[![Downloads](https://img.shields.io/npm/dw/milkee.svg)](https://www.npmjs.com/package/milkee)
+[![License](https://img.shields.io/npm/l/milkee.svg)](./LICENSE)
+
+[English](./README.md) | **日本語**  
+
 ![Milkee logo](./img/Milkee-logo.png)  
 
 `coffee.config.cjs` を使ったシンプルな CoffeeScript ビルドツール

package/README.md

@@ -1,7 +1,12 @@
-**English** | [日本語](./README-ja.md)
-
 # Milkee
 
+[![Vitest](https://github.com/otoneko1102/coffeescript-milkee/actions/workflows/test.yml/badge.svg)](https://github.com/otoneko1102/coffeescript-milkee/actions)
+[![npm version](https://img.shields.io/npm/v/milkee.svg)](https://www.npmjs.com/package/milkee)
+[![Downloads](https://img.shields.io/npm/dw/milkee.svg)](https://www.npmjs.com/package/milkee)
+[![License](https://img.shields.io/npm/l/milkee.svg)](./LICENSE)
+
+**English** | [日本語](./README-ja.md)  
+
 ![Milkee logo](./img/Milkee-logo.png)  
 
 A simple CoffeeScript build tool with [coffee.config.cjs](./temp/coffee.config.cjs)  

package/dist/lib/utils.js

@@ -31,11 +31,11 @@ getCompiledFiles = function(targetPath) {
         filesList = filesList.concat(getCompiledFiles(itemPath));
       }
     } else if (stat.isFile()) {
-      if (targetPath.endsWith('.js' || targetPath.endsWith('.js.map'))) {
+      if (targetPath.match(/\.js(?:\.map)?$/i)) {
         if (fs.existsSync(targetPath)) {
           consola.info(`Found file: \`${targetPath}\``);
+          filesList.push(targetPath);
         }
-        filesList.push(targetPath);
       }
     }
   } catch (error1) {

package/dist/options/copy.js

@@ -11,8 +11,8 @@ consola = require('consola');
 
 executeCopy = function(config) {
   var copyNonCoffeeFiles, entryPath, error, outputPath, ref, stat;
-  entryPath = path.join(CWD, config.entry);
-  outputPath = path.join(CWD, config.output);
+  entryPath = path.isAbsolute(config.entry) ? config.entry : path.join(CWD, config.entry);
+  outputPath = path.isAbsolute(config.output) ? config.output : path.join(CWD, config.output);
   if (!fs.existsSync(entryPath)) {
     consola.warn(`Entry path does not exist: ${config.entry}`);
     return;

package/dist/options/refresh.js

@@ -14,7 +14,7 @@ consola = require('consola');
 // Execute refresh processing
 executeRefresh = function(config, backupFiles) {
   var backupName, backupPath, dirName, error, fileName, hash, i, item, items, len, originalPath, stat, targetDir;
-  targetDir = path.join(CWD, config.output);
+  targetDir = path.isAbsolute(config.output) ? config.output : path.join(CWD, config.output);
   if (fs.existsSync(targetDir)) {
     stat = fs.statSync(targetDir);
     hash = crypto.randomBytes(4).toString('hex');

package/docs/PLUGIN-ja.md

@@ -1,5 +1,7 @@
 # Milkee プラグインの作成
 
+[English](./PLUGIN.md) | **日本語**  
+
 カスタムプラグインで Milkee の機能を拡張できます。  
 
 ## クイックスタート

package/docs/PLUGIN.md

@@ -1,5 +1,7 @@
 # Creating a Milkee Plugin
 
+**English** | [日本語](./PLUGIN-ja.md)  
+
 Extend Milkee's functionality with custom plugins.  
 
 ## Quick Start

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "milkee",
-  "version": "3.0.1-dev.0",
+  "version": "3.1.0",
   "description": "A simple CoffeeScript build tool with coffee.config.cjs",
   "main": "dist/main.js",
   "bin": {
     "milkee": "bin/milkee.js"
   },
   "scripts": {
-    "test": "echo \"No test specified\" && exit 0",
+    "test": "prettier --write ./test && vitest",
+    "test:ci": "vitest --run",
+    "coverage": "vitest --run --coverage",
     "build": "coffee --output dist/ --compile --bare src/",
+    "format": "node ./scripts/format.js",
     "deprecate:dev": "node ./scripts/deprecate-dev-versions.js"
   },
   "repository": {
@@ -31,7 +34,7 @@
   "bugs": {
     "url": "https://github.com/otoneko1102/coffeescript-milkee/issues"
   },
-  "homepage": "https://github.com/otoneko1102/coffeescript-milkee#readme",
+  "homepage": "https://milkee.oto.im",
   "dependencies": {
     "@milkee/d": "^0.2.1",
     "consola": "^3.4.2",
@@ -41,7 +44,12 @@
   "devDependencies": {
     "@babel/core": "^7.28.5",
     "@types/coffeescript": "^2.5.7",
+    "@vitest/coverage-v8": "^4.0.17",
+    "coffee-fmt": "^0.12.0",
     "coffeescript": "^2.7.0",
-    "dotenv": "^17.2.3"
+    "dotenv": "^17.2.3",
+    "execa": "^9.6.1",
+    "prettier": "^3.8.0",
+    "vitest": "^4.0.17"
   }
 }

package/test/integration/setup.cli.test.js

@@ -0,0 +1,36 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const { execFile } = require("child_process");
+
+describe("cli setup integration", () => {
+  it("runs `--setup` and creates coffee.config.cjs", async () => {
+    const dir = createTestDir("cli");
+
+    // run the setup command directly via CoffeeScript so we don't require the ESM-only `yargs` in `main`
+    const scriptPath = require("path").join(
+      process.cwd(),
+      "src",
+      "commands",
+      "setup.coffee",
+    );
+    const csRegister = require.resolve("coffeescript/register");
+    await new Promise((resolve, reject) => {
+      // -r <abs> -> preload CoffeeScript via absolute path so child process can find it
+      execFile(
+        "node",
+        ["-r", csRegister, "-e", `require(${JSON.stringify(scriptPath)})()`],
+        { cwd: dir },
+        (err) => {
+          if (err) return reject(err);
+          resolve();
+        },
+      );
+    });
+
+    const cfgPath = path.join(dir, "coffee.config.cjs");
+    expect(fs.existsSync(cfgPath)).toBe(true);
+
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});

package/test/setup.js

@@ -0,0 +1,113 @@
+// Register CoffeeScript so tests can require .coffee files
+require("coffeescript/register");
+
+// Test sandbox guard: prevent accidental writes outside a temporary sandbox
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const SANDBOX = fs.mkdtempSync(path.join(os.tmpdir(), "milkee-test-sandbox-"));
+process.env.TEST_SANDBOX = SANDBOX;
+globalThis.TEST_SANDBOX = SANDBOX;
+
+function stripExtendedPrefix(s) {
+  if (typeof s !== "string") return s;
+  // Remove Windows extended path prefix like '\\?\\' or '\?\\'
+  let out = s.replace(/^\\+\?\\/, "");
+  // If we still have a leading backslash before a drive letter (e.g. '\C:\...'), remove it
+  out = out.replace(/^\\+([A-Za-z]:)/, "$1");
+  return out;
+}
+
+// Allowlist: sandbox + system temp + node_modules + any additional paths via TEST_WRITE_ALLOW
+const allowed = [
+  path.resolve(stripExtendedPrefix(SANDBOX)),
+  path.resolve(stripExtendedPrefix(os.tmpdir())),
+  path.resolve(stripExtendedPrefix(process.cwd()), "node_modules"),
+];
+if (process.env.TEST_WRITE_ALLOW) {
+  process.env.TEST_WRITE_ALLOW.split(",").forEach((p) => {
+    if (p) allowed.push(path.resolve(stripExtendedPrefix(p)));
+  });
+}
+
+function resolveSafe(p) {
+  if (!p) return p;
+  // accept Buffers as well
+  if (Buffer.isBuffer(p)) p = p.toString();
+  // strip Windows extended path prefix if present
+  if (typeof p === "string") {
+    p = stripExtendedPrefix(p);
+  }
+  if (!path.isAbsolute(p)) p = path.join(process.cwd(), String(p));
+  return path.resolve(p);
+}
+
+function isAllowed(p) {
+  const rp = resolveSafe(p);
+  return allowed.some(
+    (prefix) => rp === prefix || rp.startsWith(prefix + path.sep),
+  );
+}
+
+function makeGuard(orig, checkIndex = 0) {
+  return function (...args) {
+    const target = args[checkIndex];
+    if (!isAllowed(target)) {
+      throw new Error(
+        `Test attempted to modify outside sandbox: ${target} (sandbox=${SANDBOX})`,
+      );
+    }
+    return orig.apply(this, args);
+  };
+}
+
+// Patch common fs methods that write or modify the FS
+const writeSyncMethods = [
+  "writeFileSync",
+  "appendFileSync",
+  "copyFileSync",
+  "mkdirSync",
+  "rmSync",
+  "rmdirSync",
+  "renameSync",
+  "unlinkSync",
+];
+for (const m of writeSyncMethods) {
+  if (typeof fs[m] === "function") fs[m] = makeGuard(fs[m], 0);
+}
+
+// Async versions
+if (typeof fs.writeFile === "function") {
+  const orig = fs.writeFile;
+  fs.writeFile = function (file, ...rest) {
+    if (!isAllowed(file)) {
+      const cb = rest.find((r) => typeof r === "function");
+      const err = new Error(
+        `Test attempted to modify outside sandbox: ${file} (sandbox=${SANDBOX})`,
+      );
+      if (cb) return process.nextTick(() => cb(err));
+      throw err;
+    }
+    return orig.apply(this, [file, ...rest]);
+  };
+}
+if (fs.promises && typeof fs.promises.writeFile === "function") {
+  const orig = fs.promises.writeFile;
+  fs.promises.writeFile = function (file, ...rest) {
+    if (!isAllowed(file))
+      throw new Error(
+        `Test attempted to modify outside sandbox: ${file} (sandbox=${SANDBOX})`,
+      );
+    return orig.apply(this, [file, ...rest]);
+  };
+}
+
+// Helper for tests to create safe temp dirs
+globalThis.createTestDir = function (name = "") {
+  const dir = path.join(SANDBOX, name || String(Date.now()));
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+};
+
+console.info(`[test setup] test sandbox: ${SANDBOX}`);

package/test/unit/checks.test.js

@@ -0,0 +1,38 @@
+const fs = require("fs");
+const path = require("path");
+const consola = require("consola");
+
+// We re-require the checks module inside tests to allow us to mock dependencies
+// that it captures at require-time.
+
+describe("checks", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.resetModules();
+  });
+
+  it("checkLatest returns true and shows box when not latest", async () => {
+    vi.mock("is-package-latest", () => ({
+      isPackageLatest: async () => ({
+        success: true,
+        isLatest: false,
+        currentVersion: "1.0.0",
+        latestVersion: "1.2.0",
+      }),
+    }));
+    const { checkLatest } = require("../../src/lib/checks.coffee");
+
+    vi.spyOn(consola, "box").mockImplementation(() => {});
+
+    const res = await checkLatest();
+    expect(res).toBe(true);
+    expect(consola.box).toHaveBeenCalled();
+  });
+
+  it("checkCoffee reads package.json and does not warn when coffeescript present", async () => {
+    const { checkCoffee } = require("../../src/lib/checks.coffee");
+    vi.spyOn(consola, "warn").mockImplementation(() => {});
+    await checkCoffee();
+    expect(consola.warn).not.toHaveBeenCalled();
+  });
+});

package/test/unit/copy.test.js

@@ -0,0 +1,50 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const executeCopy = require("../../src/options/copy.coffee");
+
+function createTree(base) {
+  fs.mkdirSync(base, { recursive: true });
+  fs.writeFileSync(path.join(base, "a.coffee"), "c");
+  fs.writeFileSync(path.join(base, "b.txt"), "b");
+  fs.mkdirSync(path.join(base, "sub"), { recursive: true });
+  fs.writeFileSync(path.join(base, "sub", "c.md"), "c");
+}
+
+describe("copy", () => {
+  it("copies non-coffee files recursively", () => {
+    const base = createTestDir("copy");
+    const entry = path.join(base, "entry");
+    const out = path.join(base, "out");
+    createTree(entry);
+    fs.mkdirSync(out, { recursive: true });
+
+    // preconditions
+    expect(fs.existsSync(entry)).toBe(true);
+    expect(fs.existsSync(path.join(entry, "b.txt"))).toBe(true);
+
+    // use absolute paths (sandboxed)
+    executeCopy({ entry, output: out });
+
+    expect(fs.existsSync(path.join(out, "b.txt"))).toBe(true);
+    expect(fs.existsSync(path.join(out, "sub", "c.md"))).toBe(true);
+    expect(fs.existsSync(path.join(out, "a.coffee"))).toBe(false);
+
+    fs.rmSync(base, { recursive: true, force: true });
+  });
+
+  it("skips when join option is enabled", () => {
+    const base = createTestDir("copy");
+    const entry = path.join(base, "entry");
+    const out = path.join(base, "out");
+    createTree(entry);
+    fs.mkdirSync(out, { recursive: true });
+
+    executeCopy({ entry, output: out, options: { join: true } });
+
+    expect(fs.existsSync(path.join(out, "b.txt"))).toBe(false);
+
+    fs.rmSync(base, { recursive: true, force: true });
+  });
+});

package/test/unit/plugins.test.js

@@ -0,0 +1,50 @@
+const fs = require("fs");
+
+const path = require("path");
+
+const plugins = require("../../src/lib/plugins.coffee");
+
+describe("plugins", () => {
+  it("runPlugins executes provided plugin functions", async () => {
+    let called = false;
+    const tempDir = createTestDir("plugins");
+    // create a dummy compiled file
+    const compiled = path.join(tempDir, "out.js");
+    fs.writeFileSync(compiled, "x");
+
+    const config = {
+      output: tempDir,
+      milkee: {
+        plugins: [
+          (res) => {
+            called = true;
+            return Promise.resolve();
+          },
+        ],
+      },
+    };
+    plugins.runPlugins(config, {});
+
+    // wait a tick for async IIFE to run
+    await new Promise((r) => setTimeout(r, 10));
+    expect(called).toBe(true);
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("warns on invalid plugin entries", async () => {
+    const tempDir = fs.mkdtempSync(
+      path.join(require("os").tmpdir(), "milkee-plugins-"),
+    );
+    const consola = require("consola");
+    vi.spyOn(consola, "warn").mockImplementation(() => {});
+
+    const config = { output: tempDir, milkee: { plugins: ["not-fn"] } };
+    plugins.runPlugins(config, {});
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(consola.warn).toHaveBeenCalled();
+
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+});

package/test/unit/refresh.test.js

@@ -0,0 +1,63 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const {
+  executeRefresh,
+  restoreBackups,
+  clearBackups,
+} = require("../../src/options/refresh.coffee");
+
+describe("refresh", () => {
+  it("backs up directory files and restores them", () => {
+    const base = createTestDir("refresh");
+    const dir = path.join(base, "out");
+    fs.mkdirSync(dir, { recursive: true });
+    const a = path.join(dir, "a.txt");
+    const b = path.join(dir, "b.txt");
+    fs.writeFileSync(a, "1");
+    fs.writeFileSync(b, "2");
+
+    const backupFiles = [];
+    // preconditions
+    expect(fs.existsSync(dir)).toBe(true);
+    expect(fs.existsSync(a)).toBe(true);
+
+    executeRefresh({ output: dir }, backupFiles);
+
+    expect(backupFiles.length).toBe(2);
+    for (const binfo of backupFiles) {
+      expect(fs.existsSync(binfo.backup)).toBe(true);
+      expect(fs.existsSync(binfo.original)).toBe(false);
+    }
+
+    // restore
+    restoreBackups(backupFiles);
+    for (const binfo of backupFiles) {
+      expect(fs.existsSync(binfo.original)).toBe(true);
+      expect(fs.existsSync(binfo.backup)).toBe(false);
+    }
+
+    // cleanup
+    fs.rmSync(base, { recursive: true, force: true });
+  });
+
+  it("clearBackups removes backup files", () => {
+    const base = createTestDir("refresh");
+    const dir = path.join(base, "out");
+    fs.mkdirSync(dir, { recursive: true });
+    const a = path.join(dir, "a.txt");
+    fs.writeFileSync(a, "1");
+
+    const backupFiles = [];
+    executeRefresh({ output: dir }, backupFiles);
+    expect(backupFiles.length).toBeGreaterThan(0);
+
+    clearBackups(backupFiles);
+    for (const binfo of backupFiles) {
+      expect(fs.existsSync(binfo.backup)).toBe(false);
+    }
+
+    fs.rmSync(base, { recursive: true, force: true });
+  });
+});

package/test/unit/sandbox-windows.test.js

@@ -0,0 +1,14 @@
+const fs = require("fs");
+const path = require("path");
+
+describe("sandbox Windows extended path handling", () => {
+  it("allows writes when path uses \\?\\ prefix (Windows only)", () => {
+    if (process.platform !== "win32") return;
+    const dir = createTestDir("win-prefix");
+    // simulate Windows extended path prefix
+    // use Windows extended path prefix with doubled backslashes
+    const prefixed = "\\\\?\\\\" + path.join(dir, "file.txt");
+    expect(() => fs.writeFileSync(prefixed, "ok")).not.toThrow();
+    expect(fs.existsSync(path.join(dir, "file.txt"))).toBe(true);
+  });
+});

package/test/unit/setup.test.js

@@ -0,0 +1,70 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const setup = require("../../src/commands/setup.coffee");
+const checks = require("../../src/lib/checks.coffee");
+const { CONFIG_FILE } = require("../../src/lib/constants.coffee");
+
+describe("setup", () => {
+  let cwd;
+  beforeEach(() => {
+    cwd = process.cwd();
+    vi.spyOn(checks, "checkCoffee").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    process.chdir(cwd);
+    vi.restoreAllMocks();
+  });
+
+  it("creates config file when not present", async () => {
+    const dir = fs.mkdtempSync(
+      path.join(require("os").tmpdir(), "milkee-setup-"),
+    );
+    process.chdir(dir);
+
+    // re-require to ensure constants.CWD is captured from the new cwd
+    delete require.cache[require.resolve("../../src/lib/constants.coffee")];
+    delete require.cache[require.resolve("../../src/commands/setup.coffee")];
+    const setupLocal = require("../../src/commands/setup.coffee");
+
+    // run setup
+    await setupLocal();
+
+    const cfgPath = path.join(dir, CONFIG_FILE);
+    expect(fs.existsSync(cfgPath)).toBe(true);
+
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch (e) {
+      /* ignore */
+    }
+  });
+
+  it("does not overwrite when prompt says no", async () => {
+    const dir = fs.mkdtempSync(
+      path.join(require("os").tmpdir(), "milkee-setup-"),
+    );
+    process.chdir(dir);
+
+    const cfgPath = path.join(dir, CONFIG_FILE);
+    fs.writeFileSync(cfgPath, "original");
+
+    const consola = require("consola");
+    vi.spyOn(consola, "prompt").mockResolvedValue(false);
+
+    delete require.cache[require.resolve("../../src/lib/constants.coffee")];
+    delete require.cache[require.resolve("../../src/commands/setup.coffee")];
+    const setupLocal = require("../../src/commands/setup.coffee");
+
+    await setupLocal();
+
+    expect(fs.readFileSync(cfgPath, "utf-8")).toBe("original");
+
+    // try cleanup; ignore errors
+    try {
+      fs.rmSync(dir, { recursive: true, force: true });
+    } catch (e) {}
+  });
+});

package/test/unit/src.smoke.test.js

@@ -0,0 +1,56 @@
+const fs = require("fs");
+const path = require("path");
+
+function collectCoffeeFiles(dir) {
+  let out = [];
+  const items = fs.readdirSync(dir);
+  for (const item of items) {
+    const itemPath = path.join(dir, item);
+    const stat = fs.statSync(itemPath);
+    if (stat.isDirectory()) {
+      out = out.concat(collectCoffeeFiles(itemPath));
+    } else if (stat.isFile() && itemPath.endsWith(".coffee")) {
+      out.push(itemPath);
+    }
+  }
+  return out;
+}
+
+const SRC_DIR = path.join(__dirname, "../../src");
+let files = [];
+try {
+  files = collectCoffeeFiles(SRC_DIR);
+} catch (e) {
+  // If src missing for some reason, test will fail explicitly below
+}
+
+// Exclude main.coffee and compile.coffee to avoid executing CLI/long-running flows on require
+files = files.filter((f) => {
+  const excluded = [
+    path.join("src", "main.coffee"),
+    path.join("src", "commands", "compile.coffee"),
+  ];
+  return !excluded.some((e) => f.endsWith(e));
+});
+
+if (files.length === 0) {
+  it("has .coffee files under src", () => {
+    throw new Error("No .coffee files found under src");
+  });
+} else {
+  describe("smoke: require all src .coffee files", () => {
+    for (const file of files) {
+      const rel = path.relative(process.cwd(), file);
+      it(`require ${rel}`, () => {
+        // clear cache to make require deterministic
+        try {
+          delete require.cache[require.resolve(file)];
+        } catch (e) {}
+        expect(() => {
+          const mod = require(file);
+          expect(mod).not.toBeUndefined();
+        }).not.toThrow();
+      });
+    }
+  });
+}

package/test/unit/utils.test.js

@@ -0,0 +1,41 @@
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const utils = require("../../src/lib/utils.coffee");
+
+describe("utils", () => {
+  it("sleep resolves after given time", async () => {
+    vi.useFakeTimers();
+    const p = utils.sleep(100);
+    vi.advanceTimersByTime(100);
+    await vi.runAllTimersAsync();
+    await expect(p).resolves.toBeUndefined();
+    vi.useRealTimers();
+  });
+
+  it("getCompiledFiles finds .js and .js.map files recursively", () => {
+    // create directory inside test sandbox
+    const dir = createTestDir("utils");
+    const fileA = path.join(dir, "a.js");
+    const fileB = path.join(dir, "b.js.map");
+    const fileC = path.join(dir, "c.txt");
+    const subdir = path.join(dir, "sub");
+    fs.mkdirSync(subdir);
+    const fileD = path.join(subdir, "d.js");
+    fs.writeFileSync(fileA, "console.log(1)");
+    fs.writeFileSync(fileB, "map");
+    fs.writeFileSync(fileC, "no");
+    fs.writeFileSync(fileD, "console.log(2)");
+    const res = utils.getCompiledFiles(dir);
+    expect(res).toEqual(expect.arrayContaining([fileA, fileB, fileD]));
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("returns empty if path does not exist", () => {
+    const res = utils.getCompiledFiles(
+      path.join(os.tmpdir(), "nonexistent-" + Date.now()),
+    );
+    expect(res).toEqual([]);
+  });
+});

package/vitest.config.mjs

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    globals: true,
+    setupFiles: './test/setup.js',
+  },
+  coverage: {
+    provider: 'v8',
+    reporter: ['text', 'lcov'],
+    exclude: ['**/*.coffee']
+  }
+})