less 1.0.16 → 1.1.3

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

@@ -0,0 +1,271 @@
+module Less
+  grammar StyleSheet
+    include Common
+    include Entity
+    
+    rule primary
+      (declaration / ruleset / import / comment)+ <Builder> / declaration* <Builder> / import* <Builder> / comment*
+    end
+
+    rule comment
+      ws '/*' (!'*/' . )* '*/' ws / ws '//' (!"\n" .)* "\n" ws
+    end
+
+    #
+    # div, .class, body > p {...}
+    #
+    rule ruleset
+      selectors "{" ws primary ws "}" ws {
+        def build env
+          # Build the ruleset for each selector
+          selectors.build(env, :ruleset).each do |sel|
+            primary.build sel
+          end
+        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
+            end.rules
+            env.rules += rules
+          end
+        end
+      }
+    end
+
+    rule import
+      "@import" S url:(string / url) medias? s ';' ws {
+        def build env
+          path = File.join(env.root.file, 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 
+          all.map do |e|
+            e.send(method, env) if e.respond_to? method
+          end.compact
+        end
+    
+        def all
+          [selector] + tail.elements.map {|e| e.selector }
+        end
+      }
+    end
+
+    #
+    # div > p a {...}
+    #
+    rule selector
+      sel:(s select element s)+ arguments? {
+        def ruleset env
+          sel.elements.inject(env) do |node, e|
+            node << Node::Element.new(e.element.text_value, e.select.text_value)
+            node.last
+          end
+        end
+    
+        def mixin env
+          sel.elements.map do |e|
+            Node::Element.new(e.element.text_value, e.select.text_value)
+          end
+        end
+      }
+    end
+
+    #
+    # @my-var: 12px;
+    # height: 100%;
+    #
+    rule declaration
+      ws name:(ident / variable) s ':' s expressions s (';'/ ws &'}') ws {
+        def build env
+          env << (name.text_value =~ /^@/ ? 
+            Node::Variable : Node::Property).new(name.text_value, expressions.build(env), env)
+        end
+      # Empty rule
+      } / ws ident s ':' s ';' ws
+    end
+
+    #
+    # An operation or compound value
+    #
+    rule expressions
+      # Operation
+      expression tail:(operator expression)+ {
+        def build env 
+          all.map {|e| e.build(env) }.dissolve
+        end
+
+        def all
+          [expression] + tail.elements.map {|i| [i.operator, i.expression] }.flatten.compact
+        end
+      # Space-delimited expressions
+      } / expression tail:(WS expression)* {
+        def build env
+          all.map {|e| e.build(env) if e.respond_to? :build }.compact
+        end
+        
+        def all
+          [expression] + tail.elements.map {|f| f.expression }
+        end
+      } 
+    end
+
+    rule expression
+      '(' s expressions s ')' {
+        def build env
+          Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
+        end
+      } / entity '' {
+        def build env
+          entity.method(:build).arity.zero?? entity.build : entity.build(env)
+        end
+      }
+    end
+
+    #
+    # An identifier
+    #
+    rule ident
+      '*'? '-'? [-a-z0-9_]+
+    end
+
+    rule variable
+      '@' [-a-zA-Z0-9_]+  {
+        def build
+          Node::Variable.new(text_value)
+        end
+      }
+    end
+
+    #
+    # 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)+
+    end
+
+    #
+    # [type="text"]
+    #
+    rule attribute
+      '[' tag ([|~*$^]? '=') (tag / string) ']' / '[' (tag / string) ']'
+    end
+
+    rule class
+      '.' [_a-z] [-a-zA-Z0-9_]*
+    end
+
+    rule id
+      '#' [_a-z] [-a-zA-Z0-9_]*
+    end
+
+    rule tag
+      [a-zA-Z] [-a-zA-Z]* [0-9]? / '*'
+    end
+
+    rule select
+      (s [+>~] s / s ':' / S)?
+    end
+
+    # TODO: Merge this with attribute rule
+    rule accessor
+      ident:(class_id / tag) '[' attr:(string / variable) ']' {
+        def build env
+          env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
+        end
+      }
+    end
+
+    rule operator
+      S [-+*/] S {
+        def build env
+          Node::Operator.new(text_value.strip)
+        end
+      } / [-+*/] {
+        def build env
+          Node::Operator.new(text_value)
+        end
+      }
+    end
+    
+    #
+    # Functions and arguments
+    #
+    rule function
+      name:([-a-zA-Z_]+) arguments {
+        def build
+          Node::Function.new(name.text_value, [arguments.build].flatten)
+        end
+      }
+    end
+
+    rule arguments
+      '(' s argument s tail:(',' s argument s)* ')' {
+        def build
+          all.map do |e|
+            e.build if e.respond_to? :build
+          end.compact
+        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
+        end
+      } / function / keyword other:(S keyword)* {
+        def build
+        end
+      }
+    end
+  end
+end

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

@@ -36,6 +36,10 @@ module Less
 
       rgba hue[ h + 1/3 ], hue[ h ], hue[ h - 1/3 ], a
     end
+    
+    def self.available
+      self.instance_methods.map(&:to_sym)
+    end
   end
   
   module Node
@@ -45,31 +49,30 @@ module Less
     #   it calls functions from the Functions module
     #
     class Function < ::String
-      include Functions
       include Entity
+      include Functions
     
       def initialize name, *args
         @args = args.flatten
         super name
       end
-    
+      
       def to_css
         self.evaluate.to_css
       end
       
       #
       # Call the function
-      #
-      def evaluate
-        send self.to_sym, *@args
-      end
-      
       #
       # If the function isn't found, we just print it out,
       # this is the case for url(), for example,
       #
-      def method_missing meth, *args
-        Node::Anonymous.new("#{meth}(#{args.map(&:to_css) * ', '})")
+      def evaluate
+        if Functions.available.include? self.to_sym
+          send to_sym, *@args
+        else
+          Node::Anonymous.new("#{to_sym}(#{@args.map(&:to_css) * ', '})")
+        end
       end
     end
   end

data/spec/css/parens.css

@@ -4,4 +4,13 @@
   width: 36;
   padding: 2px 36px;
 }
-.more-parens { padding: 8 4 4 4px; }
+.more-parens {
+  padding: 8 4 4 4px;
+  width: 96;
+  height: 113;
+  margin: 12;
+}
+.nested-parens {
+  width: 71;
+  height: 6;
+}

data/spec/less/parens.less

@@ -9,7 +9,13 @@
 .more-parens {
   @var: (2 * 2);
   padding: (2 * @var) 4 4 (@var * 1px);
-  //width: (@var * @var) * 6;
+  width: (@var * @var) * 6;
+  height: (7 * 7) + (8 * 8);
+  margin: 4 * (5 + 5) / 2 - (@var * 2);
   //margin: (6 * 6)px;
-  //height: (7 * 7) + (8 * 8);
 }
+
+.nested-parens {
+  width: 2 * (4 * (2 + (1 + 6))) - 1;
+  height: ((2+3)*(2+3) / (9-4)) + 1;
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: less
 version: !ruby/object:Gem::Version 
-  version: 1.0.16
+  version: 1.1.3
 platform: ruby
 authors: 
 - cloudhead
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-23 00:00:00 -04:00
+date: 2009-07-27 00:00:00 -04:00
 default_executable: lessc
 dependencies: []
 
@@ -30,11 +30,14 @@ files:
 - VERSION
 - bin/lessc
 - less.gemspec
+- lib/ext.rb
 - lib/less.rb
 - lib/less/command.rb
 - lib/less/engine.rb
 - lib/less/engine/builder.rb
-- lib/less/engine/less.tt
+- lib/less/engine/grammar/common.tt
+- lib/less/engine/grammar/entity.tt
+- lib/less/engine/grammar/less.tt
 - lib/less/engine/nodes.rb
 - lib/less/engine/nodes/element.rb
 - lib/less/engine/nodes/entity.rb
@@ -43,7 +46,6 @@ files:
 - lib/less/engine/nodes/property.rb
 - lib/less/engine/nodes/ruleset.rb
 - lib/less/engine/nodes/selector.rb
-- lib/less/engine/parser.rb
 - lib/vendor/treetop/.gitignore
 - lib/vendor/treetop/LICENSE
 - lib/vendor/treetop/README

data/lib/less/engine/less.tt

@@ -1,422 +0,0 @@
-grammar Less
-  rule primary
-    (declaration / ruleset / import / comment)+ <Builder> / declaration* <Builder> / import* <Builder> / comment*
-  end
-  
-  rule comment
-    ws '/*' (!'*/' . )* '*/' ws / ws '//' (!"\n" .)* "\n" ws
-  end
-  
-  #
-  # div, .class, body > p {...}
-  #
-  rule ruleset
-    selectors "{" ws primary ws "}" ws {
-      def build env
-        # Build the ruleset for each selector
-        selectors.build(env, :ruleset).each do |sel|
-          primary.build sel
-        end
-      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
-          end.rules
-          env.rules += rules
-        end
-      end
-    }
-  end
-  
-  rule import
-    "@import" S url:(string / url) medias? s ';' ws {
-      def build env
-        path = File.join(env.root.file, 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 
-        all.map do |e|
-          e.send(method, env) if e.respond_to? method
-        end.compact
-      end
-      
-      def all
-        [selector] + tail.elements.map {|e| e.selector }
-      end
-    }
-  end
-  
-  #
-  # div > p a {...}
-  #
-  rule selector
-    sel:(s select element s)+ arguments? {
-      def ruleset env
-        sel.elements.inject(env) do |node, e|
-          node << Node::Element.new(e.element.text_value, e.select.text_value)
-          node.last
-        end
-      end
-      
-      def mixin env
-        sel.elements.map do |e|
-          Node::Element.new(e.element.text_value, e.select.text_value)
-        end
-      end
-    }
-  end
-  
-  #
-  # @my-var: 12px;
-  # height: 100%;
-  #
-  rule declaration
-    ws name:(ident / variable) s ':' s expressions s (';'/ ws &'}') ws {
-      def build env
-        env << (name.text_value =~ /^@/ ? 
-          Node::Variable : Node::Property).new(name.text_value, expressions.build(env), env)
-
-      end
-    # Empty rule
-    } / ws ident s ':' s ';' ws
-  end
-  
-  rule expressions
-    expression+ {
-      def build env
-        elements.map do |e|
-          e.build(env) if e.respond_to? :build
-        end.compact
-      end
-    }
-  end
-  
-  #
-  # An operation or compound value
-  #
-  rule expression
-    s '(' s expressions s ')' s {
-      def build env
-        Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
-      end
-    } / entity tail:(operator entity)* ws {
-      def build env 
-        exp = all.map do |e|
-          e.method(:build).arity.zero?? 
-            e.build : e.build(env) if e.respond_to? :build
-        end.dissolve
-        exp.is_a?(Array) ? Node::Expression.new(exp) : exp
-      end
-      
-      def all
-        [entity] + tail.elements.map {|i| [i.operator, i.entity] }.flatten.compact
-      end
-    }
-  end
-  
-  #
-  # Entity: Any whitespace delimited token
-  #
-  rule entity
-    function / fonts / keyword / accessor / variable / literal / important
-  end
-  
-  rule fonts
-    font family:(s ',' s font)+ {
-      def build
-        Node::FontFamily.new(all.map(&:build))
-      end
-      
-      def all
-        [font] + family.elements.map {|f| f.font }
-      end
-    }
-  end
-  
-  rule font
-    [a-zA-Z] [-a-zA-Z0-9]* {
-      def build
-        Node::Keyword.new(text_value)
-      end
-    } / string {
-      def build
-        Node::String.new(text_value)
-      end
-    }
-  end
-  
-  #
-  # An identifier
-  #
-  rule ident
-    '*'? '-'? [-a-z0-9_]+
-  end
-  
-  rule variable
-    '@' [-a-zA-Z0-9_]+  {
-      def build
-        Node::Variable.new(text_value)
-      end
-    }
-  end
-  
-  #
-  # 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)+
-  end
-  
-  #
-  # [type="text"]
-  #
-  rule attribute
-    '[' tag ([|~*$^]? '=') (tag / string) ']' / '[' (tag / string) ']'
-  end
-  
-  rule class
-    '.' [_a-z] [-a-zA-Z0-9_]*
-  end
-  
-  rule id
-    '#' [_a-z] [-a-zA-Z0-9_]*
-  end
-  
-  rule tag
-    [a-zA-Z] [-a-zA-Z]* [0-9]? / '*'
-  end
-  
-  rule select
-    (s [+>~] s / s ':' / S)?
-  end
-  
-  # TODO: Merge this with attribute rule
-  rule accessor
-    ident:(class_id / tag) '[' attr:(string / variable) ']' {
-      def build env
-        env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
-      end
-    }
-  end
-  
-  rule operator
-    S [-+*/] S {
-      def build
-        Node::Operator.new(text_value.strip)
-      end
-    } / [-+*/] {
-      def build
-        Node::Operator.new(text_value)
-      end
-    }
-  end
-  
-  #
-  # Tokens which don't need to be evaluated
-  #
-  rule literal
-    color / (dimension / [-a-z]+) '/' dimension {
-      def build
-        Node::Anonymous.new(text_value)
-      end
-    } / number unit {
-      def build
-        Node::Number.new(number.text_value, unit.text_value)
-      end
-    } / string {
-      def build
-        Node::String.new(text_value)
-      end
-    }
-  end
-  
-  # !important
-  rule important
-    '!important' {
-      def build
-        Node::Keyword.new(text_value)
-      end
-    }
-  end
-  
-  #
-  # `blue`, `small`, `normal` etc.
-  #
-  rule keyword
-    [-a-zA-Z]+ !ns {
-      def build
-        Node::Keyword.new(text_value)
-      end
-    }
-  end
-    
-  #
-  # 'hello world' / "hello world"
-  #
-  rule string
-    "'" content:(!"'" . )* "'" {
-      def value
-        content.text_value
-      end
-    } / ["] content:(!["] . )* ["] {
-      def value
-        content.text_value
-      end
-    }
-  end
-  
-  #
-  # Numbers & Units
-  #
-  rule dimension
-    number unit
-  end
-  
-  rule number
-    '-'? [0-9]* '.' [0-9]+ / '-'? [0-9]+
-  end
-  
-  rule unit
-    ('px'/'em'/'pc'/'%'/'pt'/'cm'/'mm')?
-  end
-
-  #
-  # Color
-  #
-  rule color
-    '#' rgb {
-      def build
-        Node::Color.new(*rgb.build)
-      end
-    } / fn:(('hsl'/'rgb') 'a'?) arguments {
-      def build
-        Node::Function.new(fn.text_value, arguments.build.flatten)
-      end
-    }
-  end
-  
-  #
-  # 00ffdd / 0fd
-  #
-  rule rgb
-    r:(hex hex) g:(hex hex) b:(hex hex) {
-      def build
-        [r.text_value, g.text_value, b.text_value]
-      end
-    } / r:hex g:hex b:hex {
-      def build
-        [r.text_value, g.text_value, b.text_value].map {|c| c * 2 }
-      end
-    }
-  end
-  
-  rule hex
-    [a-fA-F0-9]
-  end
-      
-  #
-  # Functions and arguments
-  #
-  rule function
-    name:([-a-zA-Z_]+) arguments {
-      def build
-        Node::Function.new(name.text_value, [arguments.build].flatten)
-      end
-    }
-  end
-  
-  rule arguments
-    '(' s argument s tail:(',' s argument s)* ')' {
-      def build
-        all.map do |e|
-          e.build if e.respond_to? :build
-        end.compact
-      end
-    
-      def all
-        [argument] + tail.elements.map {|e| e.argument }
-      end
-    }
-  end
-  
-  rule argument
-    color {
-      def build
-        Node::Color.new text_value
-      end
-    } / 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
-      end
-    }
-  end
-  
-  #
-  # Whitespace
-  #
-  rule s
-    [ ]*
-  end
-  
-  rule S
-    [ ]+
-  end
-  
-  rule ws
-    [\n ]*
-  end
-  
-  rule WS
-    [\n ]+
-  end
-  
-  # Non-space char
-  rule ns
-    ![ ;\n] .
-  end
-end