base .for-each implementation

Author: seven-phases-max

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Max Mikhailov
+Copyright (c) 2017 Max Mikhailov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -42,4 +42,5 @@ See [Using a plugin in code](http://lesscss.org/usage/#plugins-using-a-plugin-in
 
 ## Additional features
 
-* [Vector Arithmetic](docs/va.md) - perform arithmetic operations on lists
+* **[.for](docs/for.md) and [.for-each](docs/for-each.md)** - (almost) canonical syntax for iterative statements
+* **[Vector Arithmetic](docs/va.md)** - perform arithmetic operations on lists

docs/for-each.md

@@ -0,0 +1,25 @@
+
+## `.for-each`
+
+Less code:
+```less
+@fruit: banana, apple, pear, potato, carrot, peach;
+
+#fruit {
+    .for-each(@value in @fruit) {
+        some: @value;
+    }
+}
+```
+
+CSS output:
+```css
+#fruit {
+    some: banana;
+    some: apple;
+    some: pear;
+    some: potato;
+    some: carrot;
+    some: peach;
+}
+```

lib/for.js

@@ -0,0 +1,132 @@
+
+'use strict';
+
+module.exports = function(less, manager) {
+    
+// ............................................................
+
+    var tree          = less.tree,
+        Node          = tree.Node,
+        Rule          = tree.Rule,
+        Ruleset       = tree.Ruleset,
+        Variable      = tree.Variable,
+        Dimension     = tree.Dimension,
+        isArray       = Array.isArray,
+        scopeSelector = [new tree.Selector([new tree.Element('', '&')])];
+
+// ............................................................
+
+    function toArray(list) {
+        return isArray(list.value) ? list.value : [list];    
+    }
+
+    function findFileInfo(node) {
+        // Curently mixin definitions do not have index/fileInfo
+        // so... let's try and force something from its rules (if any):
+        // * for nested mixins it's usually `node.rules[0]`
+        // * for global mixins it's usually `node.rules[0].rules[0]`
+        while (node) {
+            if ((node = (node.rules && node.rules[0])
+                || node.node) && node.currentFileInfo) {
+                    var fileInfo = node.currentFileInfo;
+                    fileInfo.index = node.index;
+                    return fileInfo;
+            }
+        }
+
+        return {index: undefined};
+    }
+    
+// ............................................................
+
+    function Evaluator(node) {
+        this.node = node; 
+    }
+    
+    Evaluator.prototype = new Node();
+    Evaluator.prototype.type = "ForEvaluator";
+    Evaluator.prototype.evalFirst = true;
+    Evaluator.prototype.accept = function(visitor) {
+        this.node.rules = visitor.visitArray(this.node.rules);
+    };
+    
+    Evaluator.prototype.eval = function(context) {
+        var node  = this.node,
+            args  = node.params,
+            fileInfo = findFileInfo(node);
+
+        // parse args:
+        var n     = args.length,
+            value = args[0],
+            index = (n === 4) ? args[n - 3].name : "@__index",
+            magic = args[n - 2],
+            list  = args[n - 1],
+            valid;
+
+        valid = (n > 2) || (n < 5);
+        valid = valid && magic && magic.value
+            && (magic.value.value === "in");
+
+        if (!valid) throw {
+            type:    "Syntax",
+            message: "[plugin-lists] unexpected .for-each parameters",
+            index:    fileInfo.index,
+            filename: fileInfo.filename
+        };
+
+        // apply:
+        var result = [],
+            rules  = node.rules;
+        value = value.name;
+        list  = toArray((new Variable(list.name,
+            fileInfo.index, fileInfo)).eval(context));
+
+        for (var i = 0; i < list.length; i++) {
+            var push = true,
+                iter = [new Rule(value, list[i]), 
+                        new Rule(index, new Dimension(i + 1))];
+                iter =  new Ruleset(scopeSelector, iter);
+
+            if (node.condition) {
+                var frames = context.frames;
+                frames.unshift(iter[0], iter[1]);
+                push = node.condition.eval(context);
+                frames.shift(); frames.shift();
+            }
+
+            if (push) {
+                Array.prototype.push.apply(iter.rules, rules); // iter.rules = iter.rules.concat(rules);
+                result.push(iter);
+            }
+        }
+
+        return (new Ruleset(scopeSelector, result)).eval(context);
+    };
+
+// ............................................................
+    
+    function Visitor() {
+        this.native_ = new less.visitors.Visitor(this);
+    }
+
+    Visitor.prototype = {
+        isPreEvalVisitor: true,
+        isReplacing:      true,
+        
+        run: function(root) {
+            return this.native_.visit(root);
+        },
+        
+        visitMixinDefinition: function(node) {
+            if (node.name === ".for-each")
+                return new Evaluator(node);
+
+            return node;
+        },
+    };
+    
+    manager.addVisitor(new Visitor());
+
+// ............................................................
+
+}; // ~ end of module.exports

lib/index.js

@@ -8,4 +8,5 @@ function ThisPlugin() {}
 ThisPlugin.prototype.install
     = function(less, manager) {
         require("./main")(less, manager);
+        require("./for")(less, manager);
 };

package.json

@@ -1,6 +1,6 @@
 {
   "name": "less-plugin-lists",
-  "version": "1.0.0",
+  "version": "1.0.8",
   "description": "list/array manipulation functions for Less",
   "homepage": "https://github.com/seven-phases-max/less-plugin-lists",
   "author": "Max Mikhailov",

test/css/for-each.css

@@ -0,0 +1,58 @@
+#for-each-fruit {
+  value: banana;
+  value: apple;
+  value: pear;
+  value: potato;
+  value: carrot;
+  value: peach;
+}
+#for-each-index-fruit {
+  1: banana;
+  2: apple;
+  3: pear;
+  4: potato;
+  5: carrot;
+  6: peach;
+}
+#for-each-nested {
+  r: a of [a b c];
+  r: b of [a b c];
+  r: c of [a b c];
+  r: e of [e f g];
+  r: f of [e f g];
+  r: g of [e f g];
+}
+#for-each-nested-index {
+  11: a;
+  12: b;
+  13: c;
+  21: e;
+  22: f;
+  23: g;
+}
+#for-each-nested-scope {
+  outer-1: outer a b c;
+  inner-1: inner a;
+  inner-2: inner b;
+  inner-3: inner c;
+  outer-2: outer e f g;
+  inner-1: inner e;
+  inner-2: inner f;
+  inner-3: inner g;
+}
+#for-each-nested-lazy-eval {
+  outer-1: a b c;
+  inner-1: a = a;
+  inner-2: b = b;
+  inner-3: c = c;
+  outer-2: e f g;
+  inner-1: e = e;
+  inner-2: f = f;
+  inner-3: g = g;
+}
+.for-each {
+  me: is not a loop;
+}
+.for-each .for-each {
+  me: is not a loop too;
+}

test/less/for-each.less

@@ -0,0 +1,58 @@
+
+@fruit: banana, apple, pear, potato, carrot, peach;
+@2d-list: a b c, e f g;
+
+#for-each-fruit {
+    .for-each(@value in @fruit) {
+        value: @value;
+    }
+}
+
+#for-each-index-fruit {
+    .for-each(@value, @index in @fruit) {
+        @{index}: @value;
+    }
+}
+
+#for-each-nested {
+    .for-each(@x in @2d-list) {
+        .for-each(@y in @x) { 
+            r: @y of _inspect(@x);
+        }
+    }
+}
+
+#for-each-nested-index {
+    .for-each(@x, @i in @2d-list) {
+        .for-each(@y, @j in @x) {
+            @p:   @i * 10 + @j;
+            @{p}: @y;
+        }
+    }
+}
+
+#for-each-nested-scope {
+    .for-each(@x, @i in @2d-list) {
+        outer-@{i}: outer @x;
+        .for-each(@x, @i in @x) {
+            inner-@{i}: inner @x;
+        }
+    }
+}
+
+#for-each-nested-lazy-eval {
+    .for-each(@x, @i in @2d-list) {
+        outer-@{i}: @lazy;
+        .for-each(@x, @j in @x) {
+            inner-@{j}: @x ~'=' @lazy;
+        }
+        @lazy: @x;
+    }
+}
+
+.for-each {
+    me: is not a loop;
+    .for-each {
+        me: is not a loop too;
+    }
+}