less 1.1.13 → 1.2.9

data/lib/less/engine/grammar/less.tt

@@ -4,7 +4,7 @@ module Less
     include Entity
     
     rule primary
-      (declaration / ruleset / import / comment)* {
+      (import / declaration / mixin / ruleset / comment)* {
         def build env = Less::Element.new
           elements.map do |e|
             e.build env if e.respond_to? :build
@@ -21,56 +21,44 @@ module Less
     # div, .class, body > p {...}
     #
     rule ruleset
-      selectors "{" ws primary ws "}" ws {
+      selectors "{" ws primary ws "}" s hide:(';'?) ws {
         def build env
           # Build the ruleset for each selector
           selectors.build(env, :ruleset).each do |sel|
+            sel.hide unless hide.empty?
             primary.build sel
           end
         end
-      } / ws selectors ';' ws {
+        # Mixin Declaration
+      } / '.' name:[-a-zA-Z0-9_]+ ws parameters ws "{" ws primary ws "}" ws {
+        def build env
+          env << Node::Mixin::Def.new(name.text_value, parameters.build(env))
+          primary.build env.last
+          #env.last
+        end
+      }
+    end
+    
+    rule mixin
+      name:('.' [-a-zA-Z0-9_]+) args:(arguments) s ';' ws {
+        def build env
+          definition = env.nearest(name.text_value, :mixin) or raise MixinNameError, name.text_value                        
+          params = args.build.map {|i| Node::Expression.new i } unless args.empty?
+          env << Node::Mixin::Call.new(definition, params || [], env)
+        end
+    } / ws selectors ';' ws {
         def build env        
           selectors.build(env, :mixin).each do |path|
             rules = path.inject(env.root) do |current, node|
-              current.descend(node.selector, node) or raise MixinNameError, path.join
+              current.descend(node.selector, node) or raise MixinNameError, selectors.text_value
             end.rules
             env.rules += rules
+            #env.mix(rules)
           end
         end
-      }
-    end
-
-    rule import
-      ws "@import" S url:(string / url) medias? s ';' ws {
-        def build env
-          path = File.join(env.root.file || Dir.pwd, url.value)
-          path += '.less' unless path =~ /\.(le|c)ss$/
-          if File.exist? path
-            imported = Less::Engine.new(File.new(path)).to_tree
-            env.rules += imported.rules
-          else
-            raise ImportError, path
-          end
-        end
-      }
+      } 
     end
-
-    rule url
-      'url(' path:(string / [-a-zA-Z0-9_%$/.&=:;#+?]+) ')' {
-        def build env = nil
-          Node::String.new CGI.unescape(path.text_value)
-        end
     
-        def value
-          build
-        end
-      }
-    end
-
-    rule medias
-      [-a-z]+ (s ',' s [a-z]+)*
-    end
-
     rule selectors
       ws selector tail:(s ',' ws selector)* ws {
         def build env, method 
@@ -89,7 +77,7 @@ module Less
     # div > p a {...}
     #
     rule selector
-      sel:(s select element s)+ arguments? {
+      sel:(s select element s)+ '' {
         def ruleset env
           sel.elements.inject(env) do |node, e|
             node << Node::Element.new(e.element.text_value, e.select.text_value)
@@ -104,16 +92,80 @@ module Less
         end
       }
     end
+    
+    rule parameters
+      '(' s ')' {
+        def build env
+          []
+        end
+      } / '(' parameter tail:(s ',' s parameter)* ')' {
+        def build env
+          all.map do |e|
+            e.build(env)
+          end
+        end
+        
+        def all
+          [parameter] + tail.elements.map {|e| e.parameter }
+        end
+      }
+    end
+
+    rule parameter
+      variable s ':' s expressions {
+        def build env
+          Node::Variable.new(variable.text_value, expressions.build(env), env)
+        end
+      }
+    end
+    
+    rule import
+      ws "@import" S url:(string / url) medias? s ';' ws {
+        def build env
+          path = File.join(env.root.file || Dir.pwd, url.value)
+          path += '.less' unless path =~ /\.(le|c)ss$/
+          if File.exist? path
+            unless env.root.imported.include?(path)
+              env.root.imported << path
+              env.rules += Less::Engine.new(File.new(path)).to_tree.rules
+            end
+          else
+            raise ImportError, path
+          end
+        end
+      }
+    end
+
+    rule url
+      'url(' path:(string / [-a-zA-Z0-9_%$/.&=:;#+?]+) ')' {
+        def build env = nil
+          Node::Function.new('url', value)
+        end
+    
+        def value
+          Node::Quoted.new CGI.unescape(path.text_value)
+        end
+      }
+    end
+
+    rule medias
+      [-a-z]+ (s ',' s [a-z]+)*
+    end
 
     #
     # @my-var: 12px;
     # height: 100%;
     #
     rule declaration
-      ws name:(ident / variable) s ':' s expressions s (';'/ ws &'}') ws {
+      ws name:(ident / variable) s ':' s expressions tail:(ws ',' ws expressions)* s (';'/ ws &'}') ws {
         def build env
+          result = all.map {|e| e.build(env) if e.respond_to? :build }.compact
           env << (name.text_value =~ /^@/ ? 
-            Node::Variable : Node::Property).new(name.text_value, expressions.build(env), env)
+            Node::Variable : Node::Property).new(name.text_value, result, env)
+        end
+
+        def all
+          [expressions] + tail.elements.map {|f| f.expressions }
         end
       # Empty rule
       } / ws ident s ':' s ';' ws
@@ -125,7 +177,7 @@ module Less
     rule expressions
       # Operation
       expression tail:(operator expression)+ {
-        def build env 
+        def build env = nil          
           all.map {|e| e.build(env) }.dissolve
         end
 
@@ -134,7 +186,7 @@ module Less
         end
       # Space-delimited expressions
       } / expression tail:(WS expression)* i:important? {
-        def build env
+        def build env = nil
           all.map {|e| e.build(env) if e.respond_to? :build }.compact
         end
         
@@ -151,12 +203,13 @@ module Less
 
     rule expression
       '(' s expressions s ')' {
-        def build env
+        def build env = nil
           Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
         end
       } / entity '' {
-        def build env
-          entity.method(:build).arity.zero?? entity.build : entity.build(env)
+        def build env = nil
+          e = entity.method(:build).arity.zero?? entity.build : entity.build(env)
+          e.respond_to?(:dissolve) ? e.dissolve : e
         end
       }
     end
@@ -164,7 +217,7 @@ module Less
     # !important
     rule important
       s '!' s 'important' {
-        def build env
+        def build env = nil
           Node::Keyword.new(text_value.strip)
         end
       }
@@ -174,7 +227,7 @@ module Less
     # An identifier
     #
     rule ident
-      '*'? '-'? [-a-z0-9_]+
+      '*'? '-'? [-a-z_] [-a-z0-9_]*
     end
 
     rule variable
@@ -189,18 +242,14 @@ module Less
     # div / .class / #id / input[type="text"] / lang(fr)
     #
     rule element
-      (class_id / tag / ident) attribute* ('(' ident? attribute* ')')? / attribute+ / '@media' / '@font-face'
-    end
-
-    rule class_id
-      tag? (class / id)+
+      ((class / id / tag / ident) attribute* ('(' (selector / number) ')')?)+ / attribute+ / '@media' / '@font-face'
     end
 
     #
     # [type="text"]
     #
     rule attribute
-      '[' tag ([|~*$^]? '=') (tag / string) ']' / '[' (tag / string) ']'
+      '[' tag ([|~*$^]? '=') (string / [-a-zA-Z_0-9]+) ']' / '[' (tag / string) ']'
     end
 
     rule class
@@ -221,7 +270,7 @@ module Less
 
     # TODO: Merge this with attribute rule
     rule accessor
-      ident:(class_id / tag) '[' attr:(string / variable) ']' {
+      ident:(class / id / tag) '[' attr:(string / variable) ']' {
         def build env
           env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
         end
@@ -246,13 +295,13 @@ module Less
     rule function
       name:([-a-zA-Z_]+) arguments {
         def build
-          Node::Function.new(name.text_value, [arguments.build].flatten)
+          Node::Function.new(name.text_value, arguments.build)
         end
       }
     end
 
     rule arguments
-      '(' s argument s tail:(',' s argument s)* ')' {
+      '(' s expressions s tail:(',' s expressions s)* ')' {
         def build
           all.map do |e|
             e.build if e.respond_to? :build
@@ -260,30 +309,11 @@ module Less
         end
   
         def all
-          [argument] + tail.elements.map {|e| e.argument }
-        end
-      }
-    end
-
-    rule argument
-      color / number unit {
-        def build
-          Node::Number.new number.text_value, unit.text_value
-        end
-      } / string {
-        def build
-          Node::String.new text_value
-        end
-      } / [a-zA-Z]+ '=' dimension {
-        def build
-          Node::Anonymous.new text_value
-        end
-      } / [-a-zA-Z0-9_%$/.&=:;#+?]+ {
-        def build
-          Node::String.new text_value
+          [expressions] + tail.elements.map {|e| e.expressions }
         end
-      } / function / keyword other:(S keyword)* {
+      } / '(' s ')' {
         def build
+          []
         end
       }
     end

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

@@ -13,11 +13,11 @@ module Less
       include Entity
 
       attr_accessor :rules, :selector, :file,
-                    :set,   :name
+                    :set,   :imported, :name     
 
       def initialize name = "", selector = ''
         @name = name
-        @set = []
+        @set, @imported = [], []
         @rules = [] # Holds all the nodes under this element's hierarchy
         @selector = Selector[selector.strip].new  # descendant | child | adjacent
       end
@@ -73,10 +73,12 @@ module Less
       #
       # Accessors for the different nodes in @rules
       #
-      def identifiers; @rules.select {|r| r.kind_of?     Property } end
-      def properties;  @rules.select {|r| r.instance_of? Property } end
-      def variables;   @rules.select {|r| r.instance_of? Variable } end
-      def elements;    @rules.select {|r| r.instance_of? Element  } end
+      def identifiers; @rules.select {|r| r.kind_of?     Property   } end
+      def properties;  @rules.select {|r| r.instance_of? Property   } end
+      def variables;   @rules.select {|r| r.instance_of? Variable   } end
+      def elements;    @rules.select {|r| r.kind_of?     Element    } end
+      def mixins;      @rules.select {|r| r.instance_of? Mixin::Call} end
+      def parameters;  []                                             end
 
       # Select a child element
       # TODO: Implement full selector syntax & merge with descend()
@@ -84,7 +86,7 @@ module Less
         case key
           when Entity
             @rules.find {|i| i.eql? key }
-          when ::String
+          when String
             @rules.find {|i| i.to_s == key }
           else raise ArgumentError
         end
@@ -117,7 +119,13 @@ module Less
           self[element.name] if self[element.name].selector.class == selector.class
         end
       end
-
+      
+      def mix arr = []
+        @rules += arr.map do |r|
+          r.copy.tap {|i| i.parent = self }
+        end
+      end
+      
       #
       # Add an arbitrary node to this element
       #
@@ -137,35 +145,42 @@ module Less
       #
       # Entry point for the css conversion
       #
-      def to_css path = []
+      def to_css path = [], env = nil
         path << @selector.to_css << name unless root?
 
-        content = properties.map do |i|
-          ' ' * 2 + i.to_css
+#        puts "to_css env: #{env ? env.variables : "nil"}"
+
+        content = (properties + mixins).map do |i|
+          ' ' * 2 + i.to_css(env)
         end.compact.reject(&:empty?) * "\n"
 
-        content = content.include?("\n") ?
-          "\n#{content}\n" : " #{content.strip} "
-        ruleset = !content.strip.empty??
-          "#{[path.reject(&:empty?).join.strip,
-          *@set.map(&:name)].uniq * ', '} {#{content}}\n" : ""
+        content = content.include?("\n") ? "\n#{content}\n"
+                                         : " #{content.strip} "
+        ruleset = if is_a?(Mixin::Def)
+          content.strip
+        else
+          !content.strip.empty??
+            "#{[path.reject(&:empty?).join.strip,
+            *@set.map(&:name)].uniq * ', '} {#{content}}\n" : ""
+        end
 
-        css = ruleset + elements.map do |i|
-          i.to_css(path)
+        css = ruleset + elements.
+              reject {|e| e.is_a? Mixin::Def }.map do |i|
+          i.to_css(path, env)
         end.reject(&:empty?).join
-        path.pop; path.pop
+        2.times {path.pop}
         css
       end
 
       #
-      # Find the nearest variable in the hierarchy or raise a NameError
+      # Find the nearest node in the hierarchy or raise a NameError
       #
-      def nearest ident
-        ary = ident =~ /^[.#]/ ? :elements : :variables
+      def nearest ident, type = nil
+        ary = type || ident =~ /^[.#]/ ? :elements : :variables
         path.map do |node|
           node.send(ary).find {|i| i.to_s == ident }
         end.compact.first.tap do |result|
-          raise VariableNameError, ident unless result
+          raise VariableNameError, ("#{ident} in #{self.to_s}") unless result
         end
       end
 
@@ -188,11 +203,75 @@ module Less
 
         (root?? "\n" : "") + [
           indent[ depth ] + self.to_s,
-          put[ properties ],
           put[ variables ],
+          put[ properties ],
+          put[ mixins ],
           elements.map {|i| i.inspect( depth + 1 ) } * "\n"
         ].reject(&:empty?).join("\n") + "\n" + indent[ depth ]
       end
     end
+
+    module Mixin
+      class Call
+        include Entity
+
+        def initialize mixin, params, parent
+#          puts "Initializing a Mixin::Call #{mixin}"
+          @mixin = mixin
+          self.parent = parent
+          @params = params.each do |e|
+            e.parent = self.parent
+          end
+        end
+
+        def to_css env = nil
+#          puts "\n\n"
+#          puts "call .#{@mixin.name} #{@params} <#{@params.class}>"
+          @mixin.call(@params.map {|e| e.evaluate(env) })
+        end
+
+        def inspect
+          "#{@mixin.to_s} (#{@params})"
+        end
+      end
+
+      class Def < Element
+        attr_accessor :params
+
+        def initialize name, params = []
+          super name
+          @params = params.each do |param|
+            param.parent = self
+          end
+        end
+
+        def call args = []
+          env = Element.new
+
+          @params.zip(args).each do |param, val|
+            env << (val ? Variable.new(param.to_s, Expression.new([val])) : param)
+          end
+
+          #b ? Node::Variable.new(a.to_s, Expression.new([b])) : a
+
+#          puts "#{self.inspect}"
+#          puts "env: #{env.variables}      root?: #{env.root?}"
+#          puts "\nTOCSS"
+          to_css([], env)
+        end
+
+        def variables
+          params + super
+        end
+
+        def to_s
+          '.' + name
+        end
+
+        def to_css path, env
+          super(path, env)
+        end
+      end
+    end
   end
 end