less 0.8.8 → 1.2.21

data/lib/less/engine/nodes/property.rb

@@ -0,0 +1,232 @@
+module Less
+  module Node
+    class Property < String
+      include Entity
+
+      attr_accessor :value
+
+      def initialize key, value = nil, parent = nil
+        super key, parent
+        value = if value.is_a? Array
+          value.each {|v| v.parent = self if v.respond_to? :parent }.
+                map  {|v| v.is_a?(Expression) ? v : Expression.new(v, self) }
+        elsif value.nil?
+          []
+        else
+          value
+        end
+        @value = value.is_a?(Expression) ? value : Expression.new(value, self)
+        @value.parent = self
+        @value.delimiter = ','
+#        puts "new property #{to_s}: #{value} => #{@value}, contains: #{@value[0].class}"
+#        puts
+      end
+
+      def parent= obj
+        @parent = obj
+        value.parent = self
+      end
+
+      def copy
+        clone.tap {|c| c.value = value.copy }
+      end
+
+      def << token
+        token = Node::Anonymous.new(*token) unless token.is_a? Entity or token.respond_to? :to_ruby
+        token.parent = self if token.respond_to? :parent
+        @value << token
+      end
+
+      def empty?; !@value || @value.empty? end
+
+      def inspect
+        self + (empty?? "" : ": `#{value.map {|i| i.to_s } * ' | '}`")
+      end
+
+      def == other
+        self.to_s == other.to_s
+      end
+
+      def eql? other
+        self == other and value.eql? other.value
+      end
+
+      def to_s
+        super
+      end
+
+      def nearest node
+        parent.nearest node
+      end
+
+      def evaluate env = nil
+#        puts "evaluating property `#{to_s}`: #{value.inspect}"
+        if value.is_a?(Expression) #Value
+#          puts "value is a Value"
+          value.map {|e| e.evaluate(env) } #6
+        else
+#          puts "value is a #{value.class}"
+          [value.evaluate(env)]
+        end
+
+
+      end
+
+      def to_css env = nil
+#        puts "property.to_css `#{to_s}` env:#{env ? env.variables : "nil"}"
+        val = evaluate(env)
+        "#{self}: #{if val.respond_to? :to_css
+            val.to_css
+          else
+#            p val
+#            puts "#{val.class} #{val.first.class}"
+            val.map {|i| i.to_css }.join(", ")
+          end};"
+      end
+    end
+
+    class Variable < Property
+      attr_reader :declaration
+
+      def initialize key, value = nil, parent = nil
+        @declaration = value ? true : false
+        super key.delete('@'), value, parent
+      end
+
+      def inspect
+        "@#{super}"
+      end
+
+      def to_s
+        "@#{super}"
+      end
+
+      def evaluate env = nil
+        if declaration
+#          puts "evaluating DEC"
+          value.evaluate #2
+        else
+#          puts "evaluating #{to_s} par: #{parent} env: #{env ? env.variables : "nil"}"
+        begin
+          var = (env || self.parent).nearest(to_s) #3
+        rescue VariableNameError
+          var = self.parent.nearest(to_s)
+        end
+          var.evaluate
+        end
+      end
+
+      def to_ruby
+        evaluate.to_ruby
+      end
+
+      def to_css env = nil
+        val = evaluate env
+        if val.respond_to? :to_css
+          env ? val.to_css(env) : val.to_css
+        else
+          val.map {|i| env ? i.to_css(env) : i.to_css }.join ', '
+        end
+      end
+    end
+
+    class Expression < Array
+      attr_accessor :parent, :delimiter
+
+      def initialize ary, parent = nil, delimiter = ' '
+        self.parent = parent
+        self.delimiter = delimiter
+#        puts "new expression #{ary} |#{delimiter}|"
+        super(ary.is_a?(Array) ? ary : [ary].flatten)
+      end
+
+      def expressions; select {|i| i.kind_of? Expression } end
+      def variables;   select {|i| i.kind_of? Variable   } end
+      def operators;   select {|i| i.is_a? Operator }      end
+      def entities;    select {|i| i.kind_of? Entity }     end
+      def literals;    select {|i| i.kind_of? Literal }    end
+
+      def parent= obj
+        @parent = obj
+        each {|e| e.parent = obj if e.respond_to? :parent }
+      end
+
+      def inspect
+        '[' + map {|i| i.inspect }.join(', ') + ']'
+      end
+
+      def delimiter= d
+        @delimiter = d.strip + ' '
+      end
+
+      def flatten
+        self
+      end
+
+      def terminal?
+        expressions.empty? #&& variables.empty?
+      end
+
+      def to_css env = nil
+#        puts "TOCSS, delim: |#{@delimiter}|"
+        map do |i|
+          i.parent = self.parent
+          i.respond_to?(:to_css) ? i.to_css() : i.to_s
+        end * @delimiter
+      end
+
+      def to_ruby
+        map do |i|
+          i.respond_to?(:to_ruby) ? i.to_ruby : i.to_s
+        end
+      end
+
+      #
+      # Evaluates the expression and instantiates a new Literal with the result
+      # ex: [#111, +, #111] will evaluate to a Color node, with value #222
+      #
+      def evaluate env = nil
+#        puts "expression #{self.inspect} env: #{env ? env.variables : "nil"}"
+        if size > 2 or !terminal?
+#          puts " SIZE > 2 or !terminal"
+
+#          puts "--- sub evaluation ---"
+
+          # Replace self with an evaluated sub-expression
+          evaled = self.class.new(map {|e| e.respond_to?(:evaluate) ? e.evaluate(env) : e }, parent, delimiter) #5
+
+#          puts "======================"
+#          puts "evaled => #{evaled.inspect}"
+
+          unit = evaled.literals.map do |node|
+            node.unit
+          end.compact.uniq.tap do |ary|
+            raise MixedUnitsError, evaled * ' ' if ary.size > 1 && !evaled.operators.empty?
+          end.join
+
+          entity = evaled.literals.find {|e| e.unit == unit } || evaled.literals.first || evaled.entities.first
+          result = evaled.operators.empty?? evaled : eval(evaled.to_ruby.join)
+
+#          puts "entity is a #{entity.class}"
+#          puts "delimiter is |#{@delimiter}|"
+
+          case result
+            when Entity     then result
+            when Expression then result.one?? result.first : self.class.new(result, parent, delimiter)
+            else entity.class.new(result, *(unit if entity.class == Node::Number))
+          end
+        elsif size == 1
+          if first.is_a? Variable
+            first.evaluate(env)
+          elsif first.is_a? Function
+            first.evaluate(env)
+          else
+            first
+          end
+        else
+          self
+        end
+      end
+    end
+  end
+end

data/lib/less/engine/nodes/ruleset.rb

@@ -0,0 +1,12 @@
+module Less
+  module Node
+    class Ruleset < Array
+      def initialize elements = []
+        super elements
+      end
+      
+      def to_css
+      end
+    end
+  end
+end

data/lib/less/engine/nodes/selector.rb

@@ -0,0 +1,44 @@
+module Less
+  module Node
+    class Selector < String
+      include Entity
+      
+      Selectors = {
+        :Descendant    => '',
+        :Child         => '>',
+        :Adjacent      => '+',
+        :PseudoClass   => ':',
+        :PseudoElement => '::',
+        :Sibling       => '~'
+      }
+  
+      def initialize
+        super Selectors[ self.class.to_s.split('::').last.to_sym ]
+      end
+  
+      def self.[] key
+        Node.const_get(Selectors.find {|k, v| v == key }.first)
+      end
+    end
+
+    class Descendant < Selector
+      def to_css; " " end
+    end
+
+    class Child < Selector
+      def to_css; " #{self} " end
+    end
+
+    class Adjacent < Selector
+      def to_css; " #{self} " end
+    end
+
+    class PseudoClass < Selector
+      def to_css; self end
+    end
+    
+    class PseudoElement < Selector
+      def to_css; self end
+    end
+  end
+end

data/lib/less/engine/nodes.rb

@@ -0,0 +1,9 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'engine/nodes/entity'
+require 'engine/nodes/function'
+require 'engine/nodes/ruleset'
+require 'engine/nodes/element'
+require 'engine/nodes/property'
+require 'engine/nodes/literal'
+require 'engine/nodes/selector'

data/lib/less/engine.rb

@@ -1,148 +1,52 @@
-module Less  
-  class Engine < String
-    # Compound properties, such as `border: 1px solid black`
-    COMPOUND = ['font', 'background', 'border']
-    REGEX = {
-      :path     => /([#.][->#.\w ]+)?( ?> ?)?/,              # #header > .title
-      :selector => /[-\w #.,>*:\(\)]/,                       # .cow .milk > a
-      :variable => /@([-\w]+)/,                              # @milk-white
-      :property => /@[-\w]+|[-a-z]+/,                        # font-size
-      :color    => /#([a-zA-Z0-9]{3,6})\b/,                  # #f0f0f0
-      :number   => /\d+(?>\.\d+)?/,                          # 24.8
-      :unit     => /px|em|pt|cm|mm|%/                        # em
-    }
-    REGEX[:numeric] = /#{REGEX[:number]}(#{REGEX[:unit]})?/
-    REGEX[:operand] = /#{REGEX[:color]}|#{REGEX[:numeric]}/
-    
-    def initialize s
-      super
-      @tree = Tree.new self.hashify
-    end
+$:.unshift File.dirname(__FILE__)
 
-    def compile     
-      #
-      # Parse the variables and mixins
-      #
-      # We use symbolic keys, such as :mixins, to store LESS-only data,
-      # each branch has its own :mixins => [], and :variables => {}
-      # Once a declaration has been recognised as LESS-specific, it is copied 
-      # in the appropriate data structure in that branch. The declaration itself
-      # can then be deleted.
-      #
-      @tree = @tree.traverse :leaf do |key, value, path, node|
-        matched = if match = key.match( REGEX[:variable] )          
-          node[:variables] ||= Tree.new
-          node[:variables][ match.captures.first ] = value
-        elsif value == :mixin
-          node[:mixins] ||= []          
-          node[:mixins] << key
-        end
-        node.delete key if matched # Delete the property if it's LESS-specific
-      end
-      
-      #
-      # Evaluate mixins
-      #
-      @tree = @tree.traverse :branch do |path, node|
-        if node.include? :mixins
-          node[:mixins].each do |m|
-            @tree.find( :mixin, m.delete(' ').split('>') ).each {|k, v| node[ k ] = v }
-          end
-        end
-      end
-      
-      # Call `evaluate` on variables, such as '@dark: @light / 2'
-      @tree = @tree.traverse :branch do |path, node|
-        node.vars.each do |key, value|
-          evaluate key, value, path, node.vars
-        end if node.vars?
-      end
-      
-      # Call `evaluate` on css properties, such as 'font-size: @big'
-      @tree = @tree.traverse :leaf do |key, value, path, node|
-        evaluate key, value, path, node
-      end
-      
-      #
-      # Evaluate operations (2+2)
-      #
-      # Units are: 1px, 1em, 1%, #111
-      @tree = @tree.traverse :leaf do |key, value, path, node|
-        node[ key ] = value.gsub /(#{REGEX[:operand]}(\s?)[-+\/*](\4))+(#{REGEX[:operand]})/ do |operation|
-          raise CompoundOperationError, "#{key}: #{value}" if COMPOUND.include? key # Disallow operations on compound declarations
-          if (unit = operation.scan(/#{REGEX[:numeric]}|(#)/i).flatten.compact.uniq).size <= 1
-            unit = unit.join            
-            operation = if unit == '#'
-              evaluate = lambda do |v| 
-                result = eval v
-                unit + ( result.zero?? '000' : result.to_s(16) )
-              end
-              operation.gsub REGEX[:color] do
-                hex = $1 * ( $1.size < 6 ? 6 / $1.size : 1 )
-                hex.to_i(16)
-              end.delete unit
-            else
-              evaluate = lambda {|v| eval( v ).to_s + unit }
-              operation.gsub REGEX[:unit], ''
-            end.to_s                
-            next if operation.match /[a-z]/i
-            evaluate.call operation
-          else
-            raise MixedUnitsError, value
-          end
-        end
+require 'engine/nodes'
+
+begin
+  require 'engine/parser'
+rescue LoadError
+  Treetop.load File.join(LESS_GRAMMAR, 'less.tt')
+end
+
+module Less
+  class Engine
+    attr_reader :css, :less
+
+    def initialize obj, options = {}
+      @less = if obj.is_a? File
+        @path = File.dirname File.expand_path(obj.path)
+        obj.read
+      elsif obj.is_a? String
+        obj.dup
+      else
+        raise ArgumentError, "argument must be an instance of File or String!"
       end
+
+      @options = options
+      @parser = StyleSheetParser.new
     end
-    alias render compile
-    
-    #
-    # Evaluate variables
-    #
-    def evaluate key, expression, path, node               
-      if expression.is_a? String and expression.include? '@' # There's a var to evaluate  
-        expression.scan /#{REGEX[:path]}#{REGEX[:variable]}/ do |var|
-          name = var.last
-          var = var.join.delete ' '
-          
-          value = if var.include? '>'
-            @tree.find :var, var.split('>')                  # Try finding it in a specific namespace
-          else            
-           node.var(var) or @tree.nearest var, path          # Try local first, then nearest scope            
-          end
-          
-          if value
-            # Substitute variable with value
-            node[ key ] = node[ key ].gsub /#{REGEX[:path]}@#{name}/, value
-          else
-            node.delete key                                  # Discard the declaration if the variable wasn't found
-          end
-        end    
+
+    def parse build = true, env = Node::Element.new
+      root = @parser.parse(self.prepare)
+
+      return root unless build
+
+      if root
+        @tree = root.build env.tap {|e| e.file = @path }
+      else
+        raise SyntaxError, @parser.failure_message(@options[:color])
       end
+
+      @tree
     end
-    
-    def to_css chain = :desc
-      self.compile.to_css chain
+    alias :to_tree :parse
+
+    def to_css
+      @css || @css = self.parse.group.to_css
     end
-    
-    def hashify
-    #
-    # Parse the LESS structure into a hash
-    #
-    ###
-      #   less:     color: black;
-      #   hashify: "color" => "black"
-      #
-      hash = self.gsub(/\t+/, ' ').                                                       # Tabs
-                  gsub(/\r\n/, "\n").                                                     # m$
-                  gsub(/\/\/.*/, '').                                                     # Comments //
-                  gsub(/\/\*.*?\*\//m, '').                                               # Comments /*
-                  gsub(/"/, "'").                                                         # " => '
-                  gsub(/("|')(.+?)(\1)/) { $1 + CGI.escape( $2 ) + $1 }.                  # Escape string values
-                  gsub(/(#{REGEX[:property]}):\s*(.+?)\s*(;|(?=\}))/,'"\1"=>"\2",').      # Rules
-                  gsub(/\}/, "},").                                                       # Closing }
-                  gsub(/( *)(#{REGEX[:selector]}+?)[ \n]*(?=\{)/m, '\1"\2"=>').           # Selectors
-                  gsub(/([.#][->\w .#]+);/, '"\\1" => :mixin,')                           # Mixins
-      eval "{" + hash + "}"                                                               # Return {hash}
+
+    def prepare
+      @less.gsub(/\r\n/, "\n").gsub(/\t/, '  ')
     end
   end
-end
+end

data/lib/less/ext.rb

@@ -0,0 +1,60 @@
+module Treetop
+  module Runtime
+    class CompiledParser
+      def failure_message color
+        o = color ? Mutter.new.clear : lambda {|i, *args| i }
+        return nil unless (tf = terminal_failures) && tf.size > 0
+        msg = "on line #{failure_line}: expected " + (
+          tf.size == 1 ?
+            o[tf[0].expected_string, :yellow] :
+            "one of #{o[tf.map {|f| f.expected_string }.uniq * ' ', :yellow]}"
+        )
+        f = input[failure_index]
+        got = case f
+          when "\n" then o['\n',  :cyan]
+          when nil  then o["EOF", :cyan]
+          when ' '  then o["white-space", :cyan]
+          else           o[f.chr, :yellow]
+        end
+        msg += " got #{got} after:\n\n#{input[index...failure_index]}\n"
+      end
+    end
+  end
+end
+
+class Object
+  def verbose
+    $verbose = true
+    yield
+  ensure
+    $verbose = false
+  end
+  
+  def tap
+    yield self
+    self
+  end
+end
+
+class Array
+  def dissolve
+    ary = flatten.compact
+    case ary.size
+      when 0 then []
+      when 1 then first
+      else ary
+    end
+  end
+  
+  def one?
+    size == 1
+  end
+end
+
+unless :symbol.respond_to?(:to_proc)
+  class Symbol
+    def to_proc
+      Proc.new {|*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/lib/less.rb

@@ -1,24 +1,36 @@
-$:.unshift File.dirname(__FILE__)
-
 require 'cgi'
+require 'treetop'
+require 'mutter'
+require 'delegate'
+
+LESS_ROOT = File.expand_path(File.dirname(__FILE__))
+LESS_PARSER = File.join(LESS_ROOT, 'less', 'engine', 'parser.rb')
+LESS_GRAMMAR = File.join(LESS_ROOT, 'less', 'engine', 'grammar')
 
+$LESS_LOAD_PATH = []
+
+$:.unshift File.dirname(__FILE__)
+
+require 'less/ext'
 require 'less/command'
 require 'less/engine'
-require 'less/tree'
 
 module Less
-  MixedUnitsError = Class.new(Exception)
-  PathError = Class.new(Exception)
-  CompoundOperationError = Class.new(Exception)
+  MixedUnitsError   = Class.new(RuntimeError)
+  PathError         = Class.new(RuntimeError)
+  VariableNameError = Class.new(NameError)
+  MixinNameError    = Class.new(NameError)
+  SyntaxError       = Class.new(RuntimeError)
+  ImportError       = Class.new(RuntimeError)
+  CompileError      = Class.new(RuntimeError)
+
+  $verbose = false
 
   def self.version
-    File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') )
+    File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') ).strip
   end
-end
 
-class Hash
-  # Convert a hash into a Tree
-  def to_tree
-    Less::Tree.new self
+  def self.parse less
+    Engine.new(less).to_css
   end
-end
+end

data/spec/command_spec.rb

@@ -2,11 +2,11 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 module LessCommandSpecHelper
   def required_options
-    {:source => File.dirname(__FILE__) + '/spec.less'}
+    {:source => File.dirname(__FILE__) + '/less/css.less', :destination => File.dirname(__FILE__) + '/spec.css' }
   end
 
   def valid_options
-    {:destination => File.dirname(__FILE__) + '/spec.css', :watch => true, :chain => true, :debug => false}.merge(required_options)
+    {:destination => File.dirname(__FILE__) + '/spec.css', :watch => true, :debug => false}.merge(required_options)
   end
 end
 
@@ -48,10 +48,6 @@ describe Less::Command do
       @command.options[:watch].should == valid_options[:watch]
     end
 
-    it "should set the chain" do
-      @command.options[:chain].should == valid_options[:chain]
-    end
-
     it "should set the debug" do
       @command.options[:debug].should == valid_options[:debug]
     end
@@ -80,7 +76,7 @@ describe Less::Command do
         end
 
         it "should attempt to re-compile" do
-          @command.should_receive(:compile).with().once
+          @command.should_receive(:parse).with().once
         end
       end
 

data/spec/css/accessors.css

@@ -0,0 +1,18 @@
+.magic-box {
+  content: "gold";
+  width: 60cm;
+  height: 40cm;
+}
+.magic-box #lock { color: silver; }
+#accessors {
+  content: "gold";
+  width: 60cm;
+}
+.unlock {
+  content: "gold";
+  width: 60cm;
+  height: 40cm;
+  color: silver;
+  border-color: orange;
+}
+.unlock #lock { color: silver; }