less 2.0.0 → 2.6.0

data/lib/less/parser.rb

@@ -1,46 +1,107 @@
-
-require 'v8'
+require 'pathname'
 
 module Less
+
+  # Convert lesscss source into an abstract syntax Tree
   class Parser
 
+    # Construct and configure new Less::Parser
+    #
+    # @param [Hash] options configuration options
+    # @option options [Array] :paths a list of directories to search when handling \@import statements
+    # @option options [String] :filename to associate with resulting parse trees (useful for generating errors)
+    # @option options [TrueClass, FalseClass] :compress
+    # @option options [TrueClass, FalseClass] :strictImports
+    # @option options [TrueClass, FalseClass] :relativeUrls
+    # @option options [String] :dumpLineNumbers one of 'mediaquery', 'comments', or 'all'
     def initialize(options = {})
-      stringy = {}
-      options.each do |k,v|
-        stringy[k.to_s] = v.is_a?(Array) ? v.map(&:to_s) : v.to_s
+      # LeSS supported _env_ options :
+      # 
+      # - paths (unmodified) - paths to search for imports on
+      # - optimization - optimization level (for the chunker)
+      # - mime (browser only) mime type for sheet import
+      # - contents (browser only)
+      # - strictImports
+      # - dumpLineNumbers - whether to dump line numbers
+      # - compress - whether to compress
+      # - processImports - whether to process imports. if false then imports will not be imported
+      # - relativeUrls (true/false) whether to adjust URL's to be relative
+      # - errback (error callback function)
+      # - rootpath string
+      # - entryPath string
+      # - files (internal) - list of files that have been imported, used for import-once
+      # - currentFileInfo (internal) - information about the current file - 
+      #   for error reporting and importing and making urls relative etc :
+      #     this.currentFileInfo = {
+      #        filename: filename,
+      #        relativeUrls: this.relativeUrls,
+      #        rootpath: options.rootpath || "",
+      #        currentDirectory: entryPath,
+      #        entryPath: entryPath,
+      #        rootFilename: filename
+      #     };
+      #
+      env = {}
+      Less.defaults.merge(options).each do |key, val|
+        env[key.to_s] = 
+          case val
+          when Symbol, Pathname then val.to_s
+          when Array
+            val.map!(&:to_s) if key.to_sym == :paths # might contain Pathname-s
+            val # keep the original passed Array
+          else val # true/false/String/Method
+          end
       end
-      @parser = Less.Parser.new(stringy)
+      @parser = Less::JavaScript.exec { Less['Parser'].new(env) }
     end
 
+    # Convert `less` source into a abstract syntaxt tree
+    # @param [String] less the source to parse
+    # @return [Less::Tree] the parsed tree
     def parse(less)
-      error,tree = nil
-      @parser.parse(less, lambda {|e, t| error = e; tree = t})
-      return Tree.new(tree) if tree
-    rescue V8::JSError => e
-      raise ParseError.new(e)
+      error, tree = nil, nil
+      Less::JavaScript.exec do
+        @parser.parse(less, lambda { |*args| # (error, tree)
+          # v8 >= 0.10 passes this as first arg :
+          if args.size > 2
+            error, tree = args[-2], args[-1]
+          elsif args.last.respond_to?(:message) && args.last.message
+            # might get invoked as callback(error)
+            error = args.last
+          else
+            error, tree = *args
+          end
+          fail error.message unless error.nil?
+        })
+      end
+      Tree.new(tree) if tree
     end
 
-  end
-
-  class Tree
-    def initialize(tree)
-      @tree = tree
+    def imports
+      Less::JavaScript.exec { @parser.imports.files.map { |file, _| file } }
     end
 
-    def to_css(options = {})
-      @tree.toCSS(options)
-    end
-  end
-  
-  class ParseError < StandardError
-    
-    def initialize(error)
-      super(error.message)
-      @backtrace = error.backtrace
-    end
-  
-    def backtrace
-      @backtrace
+    private
+
+    # Abstract LessCSS syntax tree Less. Mainly used to emit CSS
+    class Tree
+
+      # Create a tree from a native javascript object.
+      # @param [V8::Object] tree the native less.js tree
+      def initialize(tree)
+        @tree = tree
+      end
+
+      # Serialize this tree into CSS.
+      # By default this will be in pretty-printed form.
+      # @param [Hash] opts modifications to the output
+      # @option opts [Boolean] :compress minify output instead of pretty-printing
+      def to_css(options = {})
+        Less::JavaScript.exec { @tree.toCSS(options) }
+      end
+
     end
+
   end
+
 end

data/lib/less/version.rb

@@ -1,3 +1,3 @@
 module Less
-  VERSION = '2.0.0'
-end
+  VERSION = '2.6.0'
+end

data/lib/less.rb

@@ -1,17 +1,32 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-module Less
-  require 'v8'
-  require 'less/parser'
-  require 'less/loader'
-  require 'less/version'
+require 'less/defaults'
+require 'less/errors'
+require 'less/loader'
+require 'less/parser'
+require 'less/version'
+require 'less/java_script'
 
+module Less
+  extend Less::Defaults
+  
+  # NOTE: keep the @loader as less-rails depends on 
+  # it as it overrides some less/tree.js functions!
   @loader = Less::Loader.new
   @less = @loader.require('less/index')
 
+  def self.[](name)
+    @less[name]
+  end
+  
+  # exposes less.Parser
   def self.Parser
-    @less['Parser']
+    self['Parser']
   end
 
+  # exposes less.tree e.g. for attaching custom functions
+  # Less.tree.functions['foo'] = lambda { |*args| 'bar' }
+  def self.tree
+    self['tree']
+  end
+  
 end

data/spec/less/faulty/faulty.less

@@ -0,0 +1,3 @@
+body {
+  color: @a;
+}

data/spec/less/loader_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Less::Loader do
+
+  describe 'eval console.log()' do
+
+    it 'should write message to $stdout' do
+      stdout = $stdout; io_stub = StringIO.new
+      begin
+        $stdout = io_stub
+        subject.environment.runtime.eval("console.log('log much?');")
+      ensure
+        $stdout = stdout
+      end
+      io_stub.string.should == "log much?\n"
+    end
+
+    it 'should write messages to $stdout' do
+      stdout = $stdout; io_stub = StringIO.new
+      begin
+        $stdout = io_stub
+        subject.environment.runtime.eval("console.log('1','2','3');")
+      ensure
+        $stdout = stdout
+      end
+      io_stub.string.should == "1, 2, 3\n"
+    end
+
+  end
+
+  describe 'eval process.exit()' do
+
+    process = Less::Loader::Process
+
+    it 'should not raise an error' do
+      process.any_instance.should_receive(:warn) do |msg|
+        msg.should match(/JS process\.exit\(-2\)/)
+      end
+      subject.environment.runtime.eval("process.exit(-2);")
+    end
+
+  end
+
+end

data/spec/less/parser_spec.rb

@@ -4,6 +4,10 @@ describe Less::Parser do
 
   cwd = Pathname(__FILE__).dirname
 
+  it "instantiates" do
+    lambda { Less::Parser.new }.should_not raise_error
+  end
+
   describe "simple usage" do
     it "parse less into a tree" do
       root = subject.parse(".class {width: 1+1}")
@@ -11,20 +15,153 @@ describe Less::Parser do
     end
 
     it "accepts options when assembling the parse tree" do
-      subject.parse(".class {width: 1+1}").to_css(:compress => true).strip.should eql ".class{width:2;}"
+      subject.parse(".class {width: 1+1}").to_css(:compress => true).strip.should eql ".class{width:2}"
     end
   end
+
   it "throws a ParseError if the lesscss is bogus" do
-    expect {subject.parse('{^)')}.should raise_error(Less::ParseError)
+    lambda { subject.parse('{^)') }.should raise_error(Less::ParseError, /missing opening `\(`/)
   end
 
-  describe "when configured with mulitple load paths" do
-    before {@parser = Less::Parser.new :paths => [cwd.join('one'), cwd.join('two')]}
+  it "passes exceptions from the less compiler" do
+    lambda { subject.parse('body { color: @a; }').to_css }.should raise_error(Less::ParseError, /variable @a is undefined/)
+  end
+
+  describe "when configured with source mapping" do
+    subject { Less::Parser.new(:filename => 'one.less', :paths => [ cwd.join('one'), cwd.join('two') ], :dumpLineNumbers => 'mediaquery') }
+
+    it "prints source maps" do
+      subject.parse('@import "one.less"; @import "two.less";').to_css(:compress => false).gsub(/\n/,'').strip.should eql "@media -sass-debug-info{filename{font-family:file\\:\\/\\/one\\.less}line{font-family:\\000031}}.one {  width: 1;}@media -sass-debug-info{filename{font-family:file\\:\\/\\/two\\.less}line{font-family:\\000031}}.two {  width: 1;}"
+    end
+
+  end
+
+  describe "when configured with multiple load paths" do
+    subject { Less::Parser.new :paths => [ cwd.join('one'), cwd.join('two'), cwd.join('faulty') ] }
 
     it "will load files from both paths" do
+      subject.parse('@import "one.less";').to_css.gsub(/\n/,'').strip.should eql ".one {  width: 1;}"
+      subject.parse('@import "two.less";').to_css.gsub(/\n/,'').strip.should eql ".two {  width: 1;}"
+    end
+
+    it "passes exceptions from less imported less files" do
+      lambda { subject.parse('@import "faulty.less";').to_css }.should raise_error(Less::ParseError, /variable @a is undefined/)
+    end
+
+    it "will track imported files" do
+      subject.parse('@import "one.less";')
+      subject.parse('@import "two.less";')
+      # Parser#imports returns full path names
+      subject.imports.grep(/one\.less$/).should_not be_empty
+      subject.imports.grep(/two\.less$/).should_not be_empty
+    end
+
+    it "reports type, line, column and filename of (parse) error" do
+      begin
+        subject.parse('@import "faulty.less";').to_css
+      rescue Less::ParseError => e
+        e.type.should == 'Name'
+        e.filename.should == cwd.join('faulty/faulty.less').to_s
+        e.line.should == 2
+        e.column.should == 9
+      else
+        fail "parse error not raised"
+      end
+    end
+
+  end
+
+  describe "when load paths are specified in as default options" do
+    before do
+      Less.paths << cwd.join('one')
+      Less.paths << cwd.join('two')
+      @parser = Less::Parser.new
+    end
+    after do
+      Less.paths.clear
+    end
+
+    it "will load files from default load paths" do
       @parser.parse('@import "one.less";').to_css.gsub(/\n/,'').strip.should eql ".one {  width: 1;}"
       @parser.parse('@import "two.less";').to_css.gsub(/\n/,'').strip.should eql ".two {  width: 1;}"
     end
   end
 
+  describe "relative urls" do
+
+    it "keeps relative imports when true" do
+      parser = Less::Parser.new :paths => [ cwd ], :relativeUrls => true
+      expected = "@import \"some/some.css\";\nbody {\n  background: url('some/assets/logo.png');\n}\n"
+      expect( parser.parse('@import "some/some.less";').to_css ).to eql expected
+    end
+
+    it "does not keep relative imports when false" do
+      parser = Less::Parser.new :paths => [ cwd ], :relativeUrls => false
+      expected = "@import \"some.css\";\nbody {\n  background: url('assets/logo.png');\n}\n"
+      expect( parser.parse('@import "some/some.less";').to_css ).to eql expected
+    end
+
+  end
+
+  # NOTE: runs JS tests from less.js it's a replacement for less-test.js
+  describe "less-test", :integration => true do
+
+    TEST_LESS_DIR = File.expand_path('../../lib/less/js/test/less', File.dirname(__FILE__))
+    TEST_CSS_DIR =  File.expand_path('../../lib/less/js/test/css' , File.dirname(__FILE__))
+
+    before :all do
+      # functions.less test expects these exposed :
+      Less.tree.functions[:add] = lambda do |*args| # function (a, b)
+        a, b = args[-2], args[-1]
+        Less.tree['Dimension'].new(a['value'] + b['value'])
+        # return new(less.tree.Dimension)(a.value + b.value);
+      end
+      Less.tree.functions[:increment] = lambda do |*args| # function (a)
+        a = args[-1]
+        Less.tree['Dimension'].new(a['value'] + 1)
+        # return new(less.tree.Dimension)(a.value + 1);
+      end
+      Less.tree.functions[:_color] = lambda do |*args| # function (str)
+        str = args[-1]
+        if str.value == 'evil red'
+        # if (str.value === "evil red")
+          Less.tree['Color'].new('600')
+          # return new(less.tree.Color)("600")
+        end
+      end
+    end
+
+    after :all do
+      Less.tree.functions[:add] = nil
+      Less.tree.functions[:increment] = nil
+      Less.tree.functions[:_color] = nil
+    end
+
+    Dir.glob(File.join(TEST_LESS_DIR, '*.less')).each do |less_file|
+
+      base_name = File.basename(less_file, '.less')
+      css_file = File.join(TEST_CSS_DIR, "#{base_name}.css")
+      raise "missing css file: #{css_file}" unless File.exists?(css_file)
+
+      less_content = File.read(less_file)
+      case base_name
+        when 'javascript'
+          # adjust less .eval line :
+          #   title: `process.title`;
+          # later replaced by line :
+          #   title: `typeof process.title`;
+          # with something that won't fail (since we're not in Node.JS)
+          less_content.sub!('process.title', '"node"')
+      end
+
+      it "#{base_name}.less" do
+        parser = Less::Parser.new(:filename => less_file, :paths => [ File.dirname(less_file) ])
+        less = parser.parse( less_content )
+        less.to_css(:strictMath => true, :silent => true).should == File.read(css_file)
+      end
+
+    end
+
+  end
+
 end

data/spec/less/some/some.less

@@ -0,0 +1,4 @@
+@import "some.css";
+body {
+  background: url('assets/logo.png');
+}

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
-$:.unshift Pathname(__FILE__).dirname.join('..','lib')
+require 'pathname'
 
-require 'less'
+$:.unshift Pathname(__FILE__).dirname.join('..', 'lib').to_s
+
+require 'less'