less 2.2.2 → 2.6.0

data/lib/less/js/test/less-test.js

@@ -1,73 +1,259 @@
-var path = require('path'),
-    fs = require('fs'),
-    sys = require('util');
-
-var less = require('../lib/less');
-
-less.tree.functions.add = function (a, b) {
-    return new(less.tree.Dimension)(a.value + b.value);
-}
-less.tree.functions.increment = function (a) {
-    return new(less.tree.Dimension)(a.value + 1);
-}
-less.tree.functions._color = function (str) {
-    if (str.value === "evil red") { return new(less.tree.Color)("600") }
-}
-
-sys.puts("\n" + stylize("LESS", 'underline') + "\n");
-
-fs.readdirSync('test/less').forEach(function (file) {
-    if (! /\.less/.test(file)) { return }
-
-    toCSS('test/less/' + file, function (err, less) {
-        var name = path.basename(file, '.less');
-
-        fs.readFile(path.join('test/css', name) + '.css', 'utf-8', function (e, css) {
-            sys.print("- " + name + ": ")
-            if (less === css) { sys.print(stylize('OK', 'green')) }
-            else if (err) {
-                sys.print(stylize("ERROR: " + (err && err.message), 'red'));
+/*jshint latedef: nofunc */
+
+module.exports = function() {
+    var path = require('path'),
+        fs = require('fs'),
+        sys = require('util');
+
+    var less = require('../lib/less');
+    var stylize = require('../lib/less/lessc_helper').stylize;
+
+    var globals = Object.keys(global);
+
+    var oneTestOnly = process.argv[2];
+
+    var isVerbose = process.env.npm_config_loglevel === 'verbose';
+
+    var totalTests = 0,
+        failedTests = 0,
+        passedTests = 0;
+
+
+    less.tree.functions.add = function (a, b) {
+        return new(less.tree.Dimension)(a.value + b.value);
+    };
+    less.tree.functions.increment = function (a) {
+        return new(less.tree.Dimension)(a.value + 1);
+    };
+    less.tree.functions._color = function (str) {
+        if (str.value === "evil red") { return new(less.tree.Color)("600"); }
+    };
+
+    function testSourcemap(name, err, compiledLess, doReplacements, sourcemap) {
+        fs.readFile(path.join('test/', name) + '.json', 'utf8', function (e, expectedSourcemap) {
+            sys.print("- " + name + ": ");
+            if (sourcemap === expectedSourcemap) {
+                ok('OK');
+            } else if (err) {
+                fail("ERROR: " + (err && err.message));
+                if (isVerbose) {
+                    console.error();
+                    console.error(err.stack);
+                }
             } else {
-                sys.print(stylize("FAIL", 'yellow'));
+                difference("FAIL", expectedSourcemap, sourcemap);
             }
-            sys.puts("");
         });
-    });
-});
-
-function toCSS(path, callback) {
-    var tree, css;
-    fs.readFile(path, 'utf-8', function (e, str) {
-        if (e) { return callback(e) }
-
-        new(less.Parser)({
-            paths: [require('path').dirname(path)],
-            optimization: 0
-        }).parse(str, function (err, tree) {
-            if (err) {
-                callback(err);
+    }
+
+    function testErrors(name, err, compiledLess, doReplacements) {
+        fs.readFile(path.join('test/less/', name) + '.txt', 'utf8', function (e, expectedErr) {
+            sys.print("- " + name + ": ");
+            expectedErr = doReplacements(expectedErr, 'test/less/errors/');
+            if (!err) {
+                if (compiledLess) {
+                    fail("No Error", 'red');
+                } else {
+                    fail("No Error, No Output");
+                }
             } else {
-                try {
-                    css = tree.toCSS();
-                    callback(null, css);
-                } catch (e) {
-                    callback(e);
+                var errMessage = less.formatError(err);
+                if (errMessage === expectedErr) {
+                    ok('OK');
+                } else {
+                    difference("FAIL", expectedErr, errMessage);
                 }
             }
         });
-    });
-}
-
-// Stylize a string
-function stylize(str, style) {
-    var styles = {
-        'bold'      : [1,  22],
-        'inverse'   : [7,  27],
-        'underline' : [4,  24],
-        'yellow'    : [33, 39],
-        'green'     : [32, 39],
-        'red'       : [31, 39]
+    }
+
+    function globalReplacements(input, directory) {
+        var p = path.join(process.cwd(), directory),
+            pathimport = path.join(process.cwd(), directory + "import/"),
+            pathesc = p.replace(/[.:/\\]/g, function(a) { return '\\' + (a=='\\' ? '\/' : a); }),
+            pathimportesc = pathimport.replace(/[.:/\\]/g, function(a) { return '\\' + (a=='\\' ? '\/' : a); });
+
+        return input.replace(/\{path\}/g, p)
+                .replace(/\{pathesc\}/g, pathesc)
+                .replace(/\{pathimport\}/g, pathimport)
+                .replace(/\{pathimportesc\}/g, pathimportesc)
+                .replace(/\r\n/g, '\n');
+    }
+
+    function checkGlobalLeaks() {
+        return Object.keys(global).filter(function(v) {
+            return globals.indexOf(v) < 0;
+        });
+    }
+
+    function runTestSet(options, foldername, verifyFunction, nameModifier, doReplacements, getFilename) {
+        foldername = foldername || "";
+
+        if(!doReplacements) {
+            doReplacements = globalReplacements;
+        }
+
+        function getBasename(file) {
+             return foldername + path.basename(file, '.less');
+        }
+
+        fs.readdirSync(path.join('test/less/', foldername)).forEach(function (file) {
+            if (! /\.less/.test(file)) { return; }
+
+            var name = getBasename(file);
+
+            if (oneTestOnly && name !== oneTestOnly) {
+                return;
+            }
+
+            totalTests++;
+
+            if (options.sourceMap) {
+                var sourceMapOutput;
+                options.writeSourceMap = function(output) {
+                    sourceMapOutput = output;
+                };
+                options.sourceMapOutputFilename = name + ".css";
+                options.sourceMapBasepath = path.join(process.cwd(), "test/less");
+                options.sourceMapRootpath = "testweb/";
+            }
+
+            options.getVars = function(file) {
+                return JSON.parse(fs.readFileSync(getFilename(getBasename(file), 'vars'), 'utf8'));
+            };
+
+            toCSS(options, path.join('test/less/', foldername + file), function (err, less) {
+
+                if (verifyFunction) {
+                    return verifyFunction(name, err, less, doReplacements, sourceMapOutput);
+                }
+                var css_name = name;
+                if(nameModifier) { css_name = nameModifier(name); }
+                fs.readFile(path.join('test/css', css_name) + '.css', 'utf8', function (e, css) {
+                    sys.print("- " + css_name + ": ");
+
+                    css = css && doReplacements(css, 'test/less/' + foldername);
+                    if (less === css) { ok('OK'); }
+                    else if (err) {
+                        fail("ERROR: " + (err && err.message));
+                        if (isVerbose) {
+                            console.error();
+                            console.error(err.stack);
+                        }
+                    } else {
+                        difference("FAIL", css, less);
+                    }
+                });
+            });
+        });
+    }
+
+    function diff(left, right) {
+        require('diff').diffLines(left, right).forEach(function(item) {
+          if(item.added || item.removed) {
+            var text = item.value.replace("\n", String.fromCharCode(182) + "\n");
+            sys.print(stylize(text, item.added ? 'green' : 'red'));
+          } else {
+            sys.print(item.value);
+          }
+        });
+        console.log("");
+    }
+
+    function fail(msg) {
+        console.error(stylize(msg, 'red'));
+        failedTests++;
+        endTest();
+    }
+
+    function difference(msg, left, right) {
+        console.warn(stylize(msg, 'yellow'));
+        failedTests++;
+
+        diff(left, right);
+        endTest();
+    }
+
+    function ok(msg) {
+        console.log(stylize(msg, 'green'));
+        passedTests++;
+        endTest();
+    }
+
+    function endTest() {
+        var leaked = checkGlobalLeaks();
+        if (failedTests + passedTests === totalTests) {
+            console.log("");
+            if (failedTests > 0) {
+                console.error(failedTests + stylize(" Failed", "red") + ", " + passedTests + " passed");
+            } else {
+                console.log(stylize("All Passed ", "green") + passedTests + " run");
+            }
+            if (leaked.length > 0) {
+                console.log("");
+                console.warn(stylize("Global leak detected: ", "red") + leaked.join(', '));
+            }
+
+            if (leaked.length || failedTests) {
+                //process.exit(1);
+                process.on('exit', function() { process.reallyExit(1) });
+            }
+        }
+    }
+
+    function toCSS(options, path, callback) {
+        var css;
+        options = options || {};
+        fs.readFile(path, 'utf8', function (e, str) {
+            if (e) { return callback(e); }
+
+            options.paths = [require('path').dirname(path)];
+            options.filename = require('path').resolve(process.cwd(), path);
+            options.optimization = options.optimization || 0;
+
+            var parser = new(less.Parser)(options);
+            var additionalData = {};
+            if (options.globalVars) {
+                additionalData.globalVars = options.getVars(path);
+            } else if (options.modifyVars) {
+                additionalData.modifyVars = options.getVars(path);
+            }
+            if (options.banner) {
+                additionalData.banner = options.banner;
+            }
+            parser.parse(str, function (err, tree) {
+                if (err) {
+                    callback(err);
+                } else {
+                    try {
+                        css = tree.toCSS(options);
+                        var css2 = tree.toCSS(options); // integration test that 2nd call gets same output
+                        if (css2 !== css) { throw new Error("css not equal to 2nd call"); }
+                        callback(null, css);
+                    } catch (e) {
+                        callback(e);
+                    }
+                }
+                }, additionalData);
+            });
+    }
+
+    function testNoOptions() {
+        totalTests++;
+        try {
+            sys.print("- Integration - creating parser without options: ");
+            new(less.Parser)();
+        } catch(e) {
+            fail(stylize("FAIL\n", "red"));
+            return;
+        }
+        ok(stylize("OK\n", "green"));
+    }
+
+    return {
+        runTestSet: runTestSet,
+        testErrors: testErrors,
+        testSourcemap: testSourcemap,
+        testNoOptions: testNoOptions
     };
-    return '\033[' + styles[style][0] + 'm' + str +
-           '\033[' + styles[style][1] + 'm';
-}
+};

data/lib/less/js/test/rhino/test-header.js

@@ -0,0 +1,15 @@
+function initRhinoTest() {
+    process = { title: 'dummy' };
+
+    less.tree.functions.add = function (a, b) {
+        return new(less.tree.Dimension)(a.value + b.value);
+    };
+    less.tree.functions.increment = function (a) {
+        return new(less.tree.Dimension)(a.value + 1);
+    };
+    less.tree.functions._color = function (str) {
+        if (str.value === "evil red") { return new(less.tree.Color)("600"); }
+    };
+}
+
+initRhinoTest();

data/lib/less/js/test/sourcemaps/basic.json

@@ -0,0 +1 @@
+{"version":3,"file":"sourcemaps/basic.css","sources":["testweb/sourcemaps/imported.css","testweb/sourcemaps/basic.less"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;ACAA;EACE,YAAA;EAJA,UAAA;EAWA,iBAAA;EALA,WAAA;EACA,mBAAA;;AAJF,EASE;AATF,EASM;EACF,gBAAA;;AACA,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;EAGA,UAAA;;AALN;AAAI;AAUJ;EATE,iBAAA;;AADF,EAEE;AAFE,EAEF;AAFF,EAEM;AAFF,EAEE;AAQN,OARE;AAQF,OARM;EACF,gBAAA;;AACA,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFJ;AAEE,EAFF,GAEI,KAFA;AAEF,EAFF,GAEI,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFJ;AAEE,EAFE,GAEA,KAFA;AAEF,EAFE,GAEA,KAFA;AAQN,OARE,GAQF,UARE;AAQF,OARE,GAEI,KAFJ;AAQF,OARE,GAQF,UARM;AAQN,OARE,GAEI,KAFA;AAEF,EAFF,GAQF,UARE;AAEE,EAFF,GAQF,UARM;AAQN,OARM,GAQN,UARE;AAQF,OARM,GAEA,KAFJ;AAQF,OARM,GAQN,UARM;AAQN,OARM,GAEA,KAFA;AAEF,EAFE,GAQN,UARE;AAEE,EAFE,GAQN,UARM;EAGA,UAAA;;AAKN;EACE,WAAA"}

data/lib/less/js/test/sourcemaps/index.html

@@ -0,0 +1,17 @@
+<html>
+   <link type="text/css" rel="stylesheet" media="all" href="import.css">
+   <link type="text/css" rel="stylesheet" media="all" href="basic.css">
+<head>
+</head>
+<body>
+<div id="import-test">id import-test</div>
+<div id="import">id import-test</div>
+<div class="imported inline">class imported inline</div>
+<div id="mixin">class mixin</div>
+<div class="a">class a</div>
+<div class="b">class b</div>
+<div class="b">class b<div class="c">class c</div></div>
+<div class="a">class a<div class="d">class d</div></div>
+<div class="extend">class extend<div class="c">class c</div></div>
+</body>
+</html>

data/lib/less/loader.rb

@@ -1,69 +1,233 @@
 require 'pathname'
 require 'commonjs'
+require 'net/http'
+require 'uri'
+require 'base64'
 
 module Less
   class Loader
-    
+
     attr_reader :environment
-    
+
     def initialize
       context_wrapper = Less::JavaScript.context_wrapper.instance
       @context = context_wrapper.unwrap
       @context['process'] = Process.new
       @context['console'] = Console.new
+      @context['Buffer'] = Buffer
       path = Pathname(__FILE__).dirname.join('js', 'lib')
       @environment = CommonJS::Environment.new(@context, :path => path.to_s)
-      @environment.native('path', Path.new)
-      @environment.native('util', Sys.new)
-      @environment.native('fs', Fs.new)
+      @environment.native('path', Path)
+      @environment.native('util', Util)
+      @environment.native('fs', FS)
+      @environment.native('url', Url)
+      @environment.native('http', Http)
     end
-    
+
     def require(module_id)
       @environment.require(module_id)
     end
-    
-    # stubbed JS modules required by less.js
-    
-    class Path
-      def join(*components)
-        File.join(*components)
+
+    # JS exports (required by less.js) :
+
+    class Process # :nodoc:
+      def exit(*args)
+        warn("JS process.exit(#{args.first}) called from: \n#{caller.join("\n")}")
       end
+    end
 
-      def dirname(path)
+    class Console # :nodoc:
+      def log(*msgs)
+        puts msgs.join(', ')
+      end
+
+      def warn(*msgs)
+        $stderr.puts msgs.join(', ')
+      end
+    end
+
+    # stubbed JS modules (required by less.js) :
+
+    module Path # :nodoc:
+      def self.join(*components)
+        # node.js expands path on join
+        File.expand_path(File.join(*components))
+      end
+
+      def self.dirname(path)
         File.dirname(path)
       end
 
-      def basename(path)
+      def self.basename(path)
         File.basename(path)
       end
+
+      def self.extname(path)
+        File.extname(path)
+      end
+
+      def self.resolve(path)
+        File.basename(path)
+      end
+
     end
-    
-    class Sys
-      def error(*errors)
+
+    module Util # :nodoc:
+
+      def self.error(*errors)
         raise errors.join(' ')
       end
+
+      def self.puts(*args)
+        args.each { |arg| STDOUT.puts(arg) }
+      end
+
     end
 
-    class Fs
-      def statSync(path)
+    module FS # :nodoc:
+
+      def self.statSync(path)
         File.stat(path)
       end
 
-      def readFile(path, encoding, callback)
+      def self.readFile(path, encoding, callback)
         callback.call(nil, File.read(path))
       end
+
+      def self.readFileSync(path, encoding = nil)
+        buf = Buffer.new(File.read(path),  encoding)
+        encoding.nil? ? buf : buf.toString(encoding)
+      end
+
     end
 
-    class Process
-      def exit(*args)
+    class Buffer # :nodoc:
+
+      attr_accessor :data
+
+      def initialize(data, encoding = nil)
+        unless data.is_a? String
+          data = data.to_ruby
+        end
+        @data = data
+      end
+
+      def length
+        @data.length
+      end
+
+      def toString(encoding = nil, begPos = 0, endPos = length)
+        data = @data[ begPos..endPos ]
+        if encoding == 'base64'
+          data = Base64.encode64(data)
+          data.delete!("\n"); data
+        else # encoding == 'binary'
+          data
+        end
       end
     end
 
-    class Console
-      def self.log(*msgs)
-        puts msgs.join(', ')
+    module Url # :nodoc:
+
+      def self.resolve(*args)
+        URI.join(*args)
+      end
+
+      def self.parse(url_string)
+        u = URI.parse(url_string)
+        result = {}
+        result['protocol'] = u.scheme  + ':' if u.scheme
+        result['hostname'] = u.host if u.host
+        result['pathname'] = u.path if u.path
+        result['port']     = u.port if u.port
+        result['query']    = u.query if u.query
+        result['search']   = '?' + u.query if u.query
+        result['hash']     = '#' + u.fragment if u.fragment
+        result
+      end
+
+    end
+
+    module Http # :nodoc:
+
+      def self.get(options, callback)
+        err = nil
+        begin
+          #less always sends options as an object, so no need to check for string
+          uri_hash = {}
+          uri_hash[:host]     = options['hostname'] ? options['hostname'] : options['host']
+          path_components = options['path'] ? options['path'].split('?', 2) : ['']  #have to do this because node expects path and query to be combined
+          if path_components.length > 1
+            uri_hash[:path]   = path_components[0]
+            uri_hash[:query]  = path_components[0]
+          else
+            uri_hash[:path]   = path_components[0]
+          end
+          uri_hash[:port]     = options['port'] ? options['port'] : Net::HTTP.http_default_port
+          uri_hash[:scheme]   = uri_hash[:port] == Net::HTTP.https_default_port ? 'https' : 'http'  #have to check this way because of node's http.get
+          case uri_hash[:scheme]
+          when 'http'
+            uri = URI::HTTP.build(uri_hash)
+          when 'https'
+            uri = URI::HTTPS.build(uri_hash)
+          else
+            raise Exception, 'Less import only supports http and https'
+          end
+          http = Net::HTTP.new uri.host, uri.port
+          if uri.scheme == 'https'
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+            http.use_ssl = true
+          end
+          response = nil
+          http.start do |req|
+            response = req.get(uri.to_s)
+          end
+          callback.call ServerResponse.new(response.read_body, response.code.to_i)
+        rescue => e
+          err = e.message
+        ensure
+          ret = HttpGetResult.new(err)
+        end
+        ret
+      end
+
+      class HttpGetResult
+        attr_accessor :err
+
+        def initialize(err)
+          @err = err
+        end
+
+        def on(event, callback)
+          case event
+          when 'error'
+            callback.call(@err) if @err  #only call when error exists
+          else
+            callback.call()
+          end
+        end
       end
+
+      class ServerResponse
+        attr_accessor :statusCode
+        attr_accessor :data   #faked because ServerResponse acutally implements WriteableStream
+
+        def initialize(data, status_code)
+          @data = data
+          @statusCode = status_code
+        end
+
+        def on(event, callback)
+          case event
+          when 'data'
+            callback.call(@data)
+          else
+            callback.call()
+          end
+        end
+      end
+
     end
-    
+
   end
-end
+end