less 0.8.8 → 1.2.21

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

@@ -0,0 +1,144 @@
+require 'grammar/common'
+
+module Less
+  module StyleSheet
+    grammar Entity
+      #
+      # Entity: Any whitespace delimited token
+      #
+      rule entity
+        url / alpha / function / accessor / keyword / variable / literal / font
+      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]* !ns {
+          def build
+            Node::Keyword.new(text_value)
+          end
+        } / string {
+          def build
+            Node::Quoted.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::Quoted.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'/'%'/'ex'/'in'/'deg'/'s'/'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
+
+      #
+      # Special case for IE alpha filter
+      #
+      rule alpha
+        "alpha" '(' "opacity=" variable ')' {
+          def build env
+            var = variable.text_value
+            Node::Quoted.new(text_value.sub(var, env.nearest(var).evaluate.to_i.to_s))
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,341 @@
+require 'grammar/common'
+require 'grammar/entity'
+
+module Less
+  grammar StyleSheet
+    include Common
+    include Entity
+
+    rule primary
+      (import / declaration / ruleset / mixin / comment)* {
+        def build env = Less::Element.new
+          elements.map do |e|
+            e.build env if e.respond_to? :build
+          end; env
+        end
+      }
+    end
+
+    rule comment
+      ws '/*' (!'*/' . )* '*/' ws / ws '//' (!"\n" .)* "\n" ws
+    end
+
+    #
+    # div, .class, body > p {...}
+    #
+    rule ruleset
+      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
+        # Mixin Declaration
+      } / ws '.' 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
+        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}() in #{env}"
+          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, "#{selectors.text_value} in #{env}"
+            end.rules
+            env.rules += rules
+          end
+        end
+      }
+    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)+ '' {
+        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
+
+    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
+          standard_path = File.join(env.root.file || Dir.pwd, url.value)
+
+          # Compile a list of possible paths for this file
+          paths = $LESS_LOAD_PATH.map { |p| File.join(p, url.value) } + [standard_path]
+          # Standardize and make uniq
+          paths = paths.map do |p|
+            p = File.expand_path(p)
+            p += '.less' unless p =~ /\.(le|c)ss$/
+            p
+          end.uniq
+
+          # Use the first that exists if any
+          if path = paths.detect {|p| File.exists?(p)}
+            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, standard_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 ':' ws 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, result, env)
+        end
+
+        def all
+          [expressions] + tail.elements.map {|f| f.expressions }
+        end
+      # Empty rule
+      } / ws ident s ':' s ';' ws
+    end
+
+    #
+    # An operation or compound value
+    #
+    rule expressions
+      # Operation
+      expression tail:(operator expression)+ {
+        def build env = nil
+          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)* i:important? {
+        def build env = nil
+          all.map {|e| e.build(env) if e.respond_to? :build }.compact
+        end
+
+        def all
+          [expression] + tail.elements.map {|f| f.expression } + [i]
+        end
+      # Catch-all rule
+      } / [-a-zA-Z0-9_.&*/=:,+? \[\]()#%]+ {
+        def build env
+          [Node::Anonymous.new(text_value)]
+        end
+      }
+    end
+
+    rule expression
+      '(' s expressions s ')' {
+        def build env = nil
+          Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
+        end
+      } / entity '' {
+        def build env = nil
+          e = entity.method(:build).arity.zero?? entity.build : entity.build(env)
+          e.respond_to?(:dissolve) ? e.dissolve : e
+        end
+      }
+    end
+
+    # !important
+    rule important
+      s '!' s 'important' {
+        def build env = nil
+          Node::Keyword.new(text_value.strip)
+        end
+      }
+    end
+
+    #
+    # An identifier
+    #
+    rule ident
+      '*'? '-'? [-a-z_] [-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* ('(' [a-zA-Z]+ ')' / '(' (pseudo_exp / selector / [0-9]+) ')' )?)+
+      / attribute+ / '@media' / '@font-face'
+    end
+
+    #
+    # 4n+1
+    #
+    rule pseudo_exp
+      '-'? ([0-9]+)? 'n' ([-+] [0-9]+)?
+    end
+
+    #
+    # [type="text"]
+    #
+    rule attribute
+      '[' tag ([|~*$^]? '=') (string / [-a-zA-Z_0-9]+) ']' / '[' (tag / string) ']'
+    end
+
+    rule class
+      '.' [_a-zA-Z] [-a-zA-Z0-9_]*
+    end
+
+    rule id
+      '#' [_a-zA-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)
+        end
+      }
+    end
+
+    rule arguments
+      '(' s expressions s tail:(',' s expressions s)* ')' {
+        def build
+          all.map do |e|
+            e.build if e.respond_to? :build
+          end.compact
+        end
+
+        def all
+          [expressions] + tail.elements.map {|e| e.expressions }
+        end
+      } / '(' s ')' {
+        def build
+          []
+        end
+      }
+    end
+  end
+end