first commit

build/node_modules/css-tree/lib/generator/create.js

@@ -0,0 +1,161 @@
+'use strict';
+
+var sourceMapGenerator = require('./sourceMap');
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+var noop = function() {};
+
+function each(processChunk, node) {
+    var list = node.children;
+    var cursor = list.head;
+
+    while (cursor !== null) {
+        this.generate(processChunk, cursor.data, cursor, list);
+        cursor = cursor.next;
+    }
+}
+
+function eachComma(processChunk, node) {
+    var list = node.children;
+    var cursor = list.head;
+
+    while (cursor !== null) {
+        if (cursor.prev) {
+            processChunk(',');
+        }
+
+        this.generate(processChunk, cursor.data, cursor, list);
+        cursor = cursor.next;
+    }
+}
+
+function createGenerator(types) {
+    var context = {
+        generate: function(processChunk, node, item, list) {
+            if (hasOwnProperty.call(types, node.type)) {
+                types[node.type].call(this, processChunk, node, item, list);
+            } else {
+                throw new Error('Unknown node type: ' + node.type);
+            }
+        },
+        each: each,
+        eachComma: eachComma
+    };
+
+    return function(node, fn) {
+        if (typeof fn !== 'function') {
+            // default generator concats all chunks in a single string
+            var buffer = [];
+            context.generate(function(chunk) {
+                buffer.push(chunk);
+            }, node);
+            return buffer.join('');
+        }
+        context.generate(fn, node);
+    };
+}
+
+function createMarkupGenerator(types) {
+    var context = {
+        generate: function(processChunk, node, item, list) {
+            if (hasOwnProperty.call(types, node.type)) {
+                var nodeBuffer = [];
+                types[node.type].call(this, function(chunk) {
+                    nodeBuffer.push(chunk);
+                }, node, item, list);
+                processChunk({
+                    node: node,
+                    value: nodeBuffer
+                });
+            } else {
+                throw new Error('Unknown node type: ' + node.type);
+            }
+        },
+        each: each,
+        eachComma: eachComma
+    };
+
+    return function(node, enter, leave) {
+        function updatePos(str) {
+            for (var i = 0; i < str.length; i++) {
+                if (str.charCodeAt(i) === 10) { // \n
+                    line++;
+                    column = 0;
+                } else {
+                    column++;
+                }
+            }
+
+            return str;
+        }
+
+        function walk(node, buffer) {
+            var value = node.value;
+
+            enter(node.node, buffer, line, column);
+
+            if (typeof value === 'string') {
+                buffer += updatePos(value);
+            } else {
+                for (var i = 0; i < value.length; i++) {
+                    if (typeof value[i] === 'string') {
+                        buffer += updatePos(value[i]);
+                    } else {
+                        buffer = walk(value[i], buffer);
+                    }
+                }
+            }
+
+            leave(node.node, buffer, line, column);
+
+            return buffer;
+        }
+
+        if (typeof enter !== 'function') {
+            enter = noop;
+        }
+        if (typeof leave !== 'function') {
+            leave = noop;
+        }
+
+        var buffer = [];
+        var line = 1;
+        var column = 0;
+
+        context.generate(function() {
+            buffer.push.apply(buffer, arguments);
+        }, node);
+
+        return walk(buffer[0], '');
+    };
+}
+
+function getTypesFromConfig(config) {
+    var types = {};
+
+    if (config.node) {
+        for (var name in config.node) {
+            var nodeType = config.node[name];
+
+            types[name] = nodeType.generate;
+        }
+    }
+
+    return types;
+}
+
+module.exports = function(config) {
+    var types = getTypesFromConfig(config);
+    var markupGenerator = createMarkupGenerator(types);
+
+    return {
+        translate: createGenerator(types),
+        translateWithSourceMap: function(node) {
+            return sourceMapGenerator(markupGenerator, node);
+        },
+        translateMarkup: markupGenerator
+    };
+};
+
+module.exports.createGenerator = createGenerator;
+module.exports.createMarkupGenerator = createMarkupGenerator;
+module.exports.sourceMap = require('./sourceMap');

build/node_modules/css-tree/lib/generator/index.js

@@ -0,0 +1,4 @@
+var createGenerator = require('./create');
+var config = require('../syntax/config/parser');
+
+module.exports = createGenerator(config);

build/node_modules/css-tree/lib/generator/sourceMap.js

@@ -0,0 +1,78 @@
+'use strict';
+
+var SourceMapGenerator = require('source-map').SourceMapGenerator;
+var trackNodes = {
+    Atrule: true,
+    Selector: true,
+    Declaration: true
+};
+
+module.exports = function generateSourceMap(generator, ast) {
+    var map = new SourceMapGenerator();
+    var generated = {
+        line: 1,
+        column: 0
+    };
+    var original = {
+        line: 0, // should be zero to add first mapping
+        column: 0
+    };
+    var sourceMappingActive = false;
+    var activatedGenerated = {
+        line: 1,
+        column: 0
+    };
+    var activatedMapping = {
+        generated: activatedGenerated
+    };
+
+    var css = generator(ast, function(node, buffer, line, column) {
+        if (!node.loc ||
+            !node.loc.start ||
+            !trackNodes.hasOwnProperty(node.type)) {
+            return;
+        }
+
+        var nodeLine = node.loc.start.line;
+        var nodeColumn = node.loc.start.column - 1;
+
+        if (original.line !== nodeLine ||
+            original.column !== nodeColumn) {
+            original.line = nodeLine;
+            original.column = nodeColumn;
+
+            generated.line = line;
+            generated.column = column;
+
+            if (sourceMappingActive) {
+                sourceMappingActive = false;
+                if (generated.line !== activatedGenerated.line ||
+                    generated.column !== activatedGenerated.column) {
+                    map.addMapping(activatedMapping);
+                }
+            }
+
+            sourceMappingActive = true;
+            map.addMapping({
+                source: node.loc.source,
+                original: original,
+                generated: generated
+            });
+        }
+
+    }, function(node, buffer, line, column) {
+        if (sourceMappingActive && trackNodes.hasOwnProperty(node.type)) {
+            activatedGenerated.line = line;
+            activatedGenerated.column = column;
+        }
+    });
+
+    if (sourceMappingActive) {
+        map.addMapping(activatedMapping);
+    }
+
+    return {
+        css: css,
+        map: map
+    };
+};