[WIP] Ember cli classic

package.json

@@ -36,7 +36,6 @@
     "mock-require": "^2.0.2",
     "outdent": "^0.4.1",
     "perfectionist": "^2.4.0",
-    "postcss": "^6.0.21",
     "prettier": "^1.8.2",
     "remap-istanbul": "^0.9.5",
     "source-map-support": "^0.4.15",

packages/@css-blocks/broccoli/package.json

@@ -45,7 +45,6 @@
     "debug": "^3.1.0",
     "fs-extra": "^5.0.0",
     "opticss": "^0.3.0",
-    "postcss": "^6.0.21",
     "recursive-readdir": "^2.2.2",
     "walk-sync": "^0.3.2"
   }

packages/@css-blocks/broccoli/src/index.ts

@@ -1,22 +1,30 @@
 import * as fs from "fs-extra";
 import * as path from "path";
 
-import { Analyzer, BlockCompiler, StyleMapping } from "@css-blocks/core";
+import { Analyzer, Block, BlockCompiler, StyleMapping } from "@css-blocks/core";
 import { TemplateTypes } from "@opticss/template-api";
 import * as debugGenerator from "debug";
 import { OptiCSSOptions, Optimizer } from "opticss";
-import * as postcss from "postcss";
+import { postcss } from "opticss";
 import * as readdir from "recursive-readdir";
 
 import { BroccoliPlugin } from "./utils";
 
 const debug = debugGenerator("css-blocks:broccoli");
 
+export interface Transport {
+  id: string;
+  mapping: StyleMapping<keyof TemplateTypes>;
+  blocks: Set<Block>;
+  analyzer: Analyzer<keyof TemplateTypes>;
+  css: string;
+}
+
 export interface BroccoliOptions {
   entry: string[];
   output: string;
   analyzer: Analyzer<keyof TemplateTypes>;
-  transport: {[key: string]: object};
+  transport: Transport;
   optimization?: Partial<OptiCSSOptions>;
 }
 
@@ -25,19 +33,21 @@ class BroccoliCSSBlocks extends BroccoliPlugin {
   private analyzer: Analyzer<keyof TemplateTypes>;
   private entry: string[];
   private output: string;
-  private transport: { [key: string]: object };
+  private transport: Transport;
   private optimizationOptions: Partial<OptiCSSOptions>;
 
   // tslint:disable-next-line:prefer-whatever-to-any
   constructor(inputNode: any, options: BroccoliOptions) {
     super([inputNode], { name: "broccoli-css-blocks" });
 
-    this.entry = options.entry;
+    this.entry = options.entry.slice(0);
     this.output = options.output;
     this.analyzer = options.analyzer;
     this.transport = options.transport;
     this.optimizationOptions = options.optimization || {};
 
+    this.transport.css = this.transport.css ? this.transport.css : "";
+
     if (!this.output) {
       throw new Error("CSS Blocks Broccoli Plugin requires an output file name.");
     }
@@ -48,11 +58,18 @@ class BroccoliCSSBlocks extends BroccoliPlugin {
     let blockCompiler = new BlockCompiler(postcss, options);
     let optimizer = new Optimizer(this.optimizationOptions, this.analyzer.optimizationOptions);
 
+    // When no entry points are passed, we treat *every* template as an entry point.
+    let discover = !this.entry.length;
+
     // This build step is *mostly* just a pass-through of all files!
     // QUESTION: Tom, is there a better way to do this in Broccoli?
     let files = await readdir(this.inputPaths[0]);
     for (let file of files) {
       file = path.relative(this.inputPaths[0], file);
+
+      // If we're in Classic or Pods mode, every hbs file is an entry point.
+      if (discover && path.extname(file) === ".hbs") { this.entry.push(file); }
+
       await fs.ensureDir(path.join(this.outputPath, path.dirname(file)));
       try {
         await fs.symlink(
@@ -80,7 +97,6 @@ class BroccoliCSSBlocks extends BroccoliPlugin {
         let filename = filesystemPath || options.importer.debugIdentifier(block.identifier, options);
 
         // If this Block has a representation on disk, remove it from our output tree.
-        // TODO: This isn't working right now because `importer.filesystemPath` doesn't return the expected path...
         if (filesystemPath) {
           debug(`Removing block file ${path.relative(options.rootDir, filesystemPath)} from output.`);
           await fs.unlink(path.join(this.outputPath, path.relative(options.rootDir, filesystemPath)));
@@ -106,13 +122,9 @@ class BroccoliCSSBlocks extends BroccoliPlugin {
     this.transport.mapping = styleMapping;
     this.transport.blocks = blocks;
     this.transport.analyzer = this.analyzer;
-    this.transport.css = optimized.output;
+    this.transport.css += optimized.output.content.toString();
 
-    // Write our compiled CSS to the output tree.
-    await fs.writeFile(
-      path.join(this.outputPath, this.output),
-      optimized.output.content.toString(),
-    );
+    debug(`Compilation Finished: ${this.transport.id}`);
 
   }
 

packages/@css-blocks/broccoli/test/plugin-test.ts

@@ -51,7 +51,7 @@ describe("Broccoli Plugin Test", function () {
       });
 
       let transport = {};
-      let analyzer = new GlimmerAnalyzer(input.path(), {
+      let analyzer = new GlimmerAnalyzer(input.path(), ".", {
         app: { name: "test" },
         types: {
           stylesheet: { definitiveCollection: "components" },

packages/@css-blocks/ember-cli/addon/helpers/classnames.js

@@ -0,0 +1,10 @@
+import { helper } from "@ember/component/helper";
+
+// For some reason Ember doesn't include the helper runtime from `@css-blocks/glimmer`
+// in the build and throws a "missing module" error at runtime. The contents have been
+// temporarily copied to `./tmp` as a workaround instead... this will block release.
+// import { classnames } from "@css-blocks/glimmer/dist/src/helpers/classnames";
+import { classnames } from "./tmp";
+
+export default helper(classnames);
+export { classnames };

packages/@css-blocks/ember-cli/addon/helpers/concat.js

@@ -0,0 +1,5 @@
+import { concat } from "@css-blocks/glimmer/dist/src/helpers/concat";
+import { helper } from "@ember/component/helper";
+
+export default helper(concat);
+export { concat };

packages/@css-blocks/ember-cli/addon/helpers/tmp.js

@@ -0,0 +1,124 @@
+
+const e = (m) => { throw new Error(m); };
+const toStr = (s) => typeof s === "symbol" ? s.toString() : "" + s;
+const num = (v) => typeof v[0] === "number" ? v.shift() : e("not a number: " + toStr(v[0]));
+const str = (s) => toStr(s.shift());
+const truthyString = (v) => {
+    let s = v.shift();
+    if (!s && s !== 0)
+        return;
+    return s.toString();
+};
+const bool = (v) => !!v.shift();
+function classnames(stack) {
+    stack = stack.slice(0);
+    let sources = [];
+    let classes = [];
+    let nSources = num(stack);
+    let nOutputs = num(stack);
+    let canSetSource = true;
+    let abort = () => canSetSource = false;
+    let isSourceSet = (n) => sources[n];
+    let setSource = (n) => { if (canSetSource)
+        sources[n] = true; };
+    while (nSources-- > 0) {
+        sourceExpr(stack, isSourceSet, setSource, abort);
+        canSetSource = true;
+    }
+    while (nOutputs-- > 0) {
+        let c = str(stack);
+        if (boolExpr(stack, isSourceSet))
+            classes.push(c);
+    }
+    return classes.join(" ");
+}
+
+function sourceExpr(stack, isSourceSet, setSource, abort) {
+    let enforceSwitch = true;
+    let type = num(stack);
+    if (type & 1 /* dependency */) {
+        let numDeps = num(stack);
+        while (numDeps-- > 0) {
+            let depIndex = num(stack);
+            if (!isSourceSet(depIndex))
+                enforceSwitch = abort();
+        }
+    }
+    if (type & 2 /* boolean */) {
+        if (!bool(stack))
+            abort();
+    }
+    if (type & 4 /* switch */) {
+        let nValues = num(stack);
+        let ifFalsy = num(stack);
+        let value = truthyString(stack);
+        if (value === undefined) {
+            switch (ifFalsy) {
+                case 2 /* default */:
+                    value = str(stack);
+                    break;
+                case 0 /* error */:
+                    if (enforceSwitch)
+                        e("string expected"); // TODO: error message
+                    break;
+                case 1 /* unset */:
+                    abort();
+                    break;
+                default:
+                    e("wtf");
+            }
+        }
+        while (nValues-- > 0) {
+            let matchValue = str(stack);
+            let nSources = num(stack);
+            while (nSources-- > 0) {
+                value === matchValue ? setSource(num(stack)) : num(stack);
+            }
+        }
+    }
+    else if (type === 0 /* ternary */) {
+        let condition = bool(stack);
+        let nTrue = num(stack);
+        while (nTrue-- > 0) {
+            condition ? setSource(num(stack)) : num(stack);
+        }
+        let nFalse = num(stack);
+        while (nFalse-- > 0) {
+            condition ? num(stack) : setSource(num(stack));
+        }
+    }
+    else {
+        let nSources = num(stack);
+        while (nSources-- > 0) {
+            setSource(num(stack));
+        }
+    }
+}
+function boolExpr(stack, isSourceSet) {
+    let result;
+    let type = num(stack);
+    switch (type) {
+        case -1 /* not */:
+            return !boolExpr(stack, isSourceSet);
+        case -3 /* and */:
+            let nAnds = num(stack);
+            result = true;
+            while (nAnds-- > 0) {
+                let nextResult = boolExpr(stack, isSourceSet);
+                result = result && nextResult;
+            }
+            return result;
+        case -2 /* or */:
+            let nOrs = num(stack);
+            result = false;
+            while (nOrs-- > 0) {
+                let nextResult = boolExpr(stack, isSourceSet);
+                result = result || nextResult;
+            }
+            return result;
+        default:
+            return isSourceSet(type);
+    }
+}
+
+export { classnames };

packages/@css-blocks/ember-cli/app/helpers/classnames.js

@@ -0,0 +1 @@
+export { default, classnames } from '@css-blocks/ember-cli/helpers/classnames';

packages/@css-blocks/ember-cli/app/helpers/concat.js

@@ -0,0 +1 @@
+export { default, concat } from '@css-blocks/ember-cli/helpers/concat';