less 0.8.13 → 1.0.4

data/lib/less/engine.rb

@@ -1,154 +1,50 @@
-module Less  
-  class Engine < String
-    # Compound properties, such as `border: 1px solid black`
-    COMPOUND = {'font' => true, 'background' => false, 'border' => false }
-    REGEX = {
-      :path     => /([#.][->#.\w ]+)?( ?> ?)?/,              # #header > .title
-      :selector => /[-\w #.,>*+:\(\)\=\[\]']/,               # .cow .milk > a
-      :variable => /@([-\w]+)/,                              # @milk-white
-      :property => /@[-\w]+|[-a-z*0-9_]+/,                   # 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
+require 'engine/builder'
+require 'engine/nodes'
 
-      #
-      # 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|
-          # Disallow operations on certain compound declarations
-          if COMPOUND[ key ]
-            next value
-          else
-            raise CompoundOperationError, "#{key}: #{value}"
-          end if COMPOUND.include? key
+begin
+  require 'engine/parser'
+rescue LoadError
+  Treetop.load LESS_GRAMMAR
+end
 
-          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
+module Less
+  class Engine
+    attr_reader :css, :less
+    
+    def initialize obj
+      @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
+      
+      @parser = LessParser.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 env = Node::Element.new
+      root = @parser.parse(self.prepare)
+      
+      if root
+        @tree = root.build env.tap {|e| e.file = @path }
+      else
+        raise SyntaxError, @parser.failure_message
       end
+                  
+      @tree
     end
+    alias :to_tree :parse
     
-    def to_css chain = :desc
-      self.compile.to_css chain
+    def to_css
+      @css || @css = self.parse.to_css
     end
     
-    def hashify
-    #
-    # Parse the LESS structure into a hash
-    #
-    ###
-      #   less:     color: black;
-      #   hashify: "color" => "black"
-      #
-      hash = self.gsub(/\r\n/, "\n").                                                     # m$
-                  gsub(/"/, "'").                                                         # " to '
-                  gsub(/'(.*?)'/) { "'" + CGI.escape( $1 ) + "'" }.                       # Escape string values
-                  gsub(/\/\/.*\n/, '').                                                   # Comments //
-                  gsub(/\/\*.*?\*\//m, '').                                               # Comments /*
-                  gsub(/\s+/, ' ').                                                       # Replace \t\n
-                  gsub(/(#{REGEX[:property]}): *([^\{\}]+?) *(;|(?=\}))/,'"\1"=>"\2",').  # Rules
-                  gsub(/\}/, "},").                                                       # Closing }
-                  gsub(/([, ]*)(#{REGEX[:selector]}+?)[ \n]*(?=\{)/, '\1"\2"=>').         # Selectors
-                  gsub(/([.#][->\w .#]+);/, '"\\1" => :mixin,')                           # Mixins
-      eval "{#{ hash }}"                                                                  # Return {hash}
+    def prepare
+      @less.gsub(/\r\n/, "\n").gsub(/\t/, '  ')
     end
   end
 end

data/lib/less/engine/builder.rb

@@ -0,0 +1,8 @@
+module Builder
+  def build env = Less::Element.new
+    elements.map do |e|
+      e.build env if e.respond_to? :build
+    end
+    env
+  end
+end

data/lib/less/engine/less.tt

@@ -0,0 +1,374 @@
+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, :tree).each do |sel|
+          primary.build sel
+        end
+      end
+    } / ws selectors ';' ws {
+      def build env        
+        selectors.build(env, :path).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 =~ /\.less$/
+        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
+    (s select element s)+ {
+      def tree env
+        elements.inject(env) do |node, e|
+          node << Node::Element.new(e.element.text_value, e.select.text_value)
+          node.last
+        end
+      end
+      
+      def path env
+        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 expression s (';'/ ws &'}') ws {
+      def build env
+        env << (name.text_value =~ /^@/ ? Node::Variable : Node::Property).new(name.text_value)
+        expression.build env
+      end
+    # Empty rule
+    } / ws ident s ':' s ';' ws
+  end
+  
+  #
+  # An operation or compound value
+  #
+  rule expression
+    entity (operator / S) expression <Builder> / entity
+  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 env
+        fonts = ([font] + family.elements.map {|f| f.font }).map do |font|
+          font.build env
+        end
+        env.identifiers.last << Node::FontFamily.new(fonts)
+      end
+    }
+  end
+  
+  rule font
+    [a-zA-Z] [-a-zA-Z0-9]* {
+      def build env
+        Node::Keyword.new(text_value)
+      end
+    } / string {
+      def build env
+        Node::String.new(text_value)
+      end
+    }
+  end
+  
+  #
+  # An identifier
+  #
+  rule ident
+    '-'? [-a-z0-9_]+
+  end
+  
+  rule variable
+    '@' [-a-zA-Z0-9_]+  {
+      def build env
+        env.identifiers.last << env.nearest(text_value)
+      end
+    }
+  end
+  
+  #
+  # div / .class / #id / input[type="text"] / lang(fr)
+  #
+  rule element
+    (class_id / tag / ident) attribute* ('(' ident ')')? / '@media' / '@font-face'
+  end
+  
+  rule class_id
+    tag? class+ / tag? id
+  end
+  
+  #
+  # [type="text"]
+  #
+  rule attribute
+    '[' [a-z]+ ([|~]? '=')? (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)?
+  end
+  
+  # TODO: Merge this with attribute rule
+  rule accessor
+    ident:(class_id / tag) '[' attr:(string / variable) ']' {
+      def build env
+        env.identifiers.last << env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
+      end
+    }
+  end
+  
+  rule operator
+    S [-+*/] S {
+      def build env
+        env.identifiers.last << Node::Operator.new(text_value.strip)
+      end
+    } / [-+*/] {
+      def build env
+        env.identifiers.last << Node::Operator.new(text_value)
+      end
+    }
+  end
+  
+  #
+  # Tokens which don't need to be evaluated
+  #
+  rule literal
+    color / (dimension / [-a-z]+) '/' dimension {
+      def build env
+        env.identifiers.last << Node::Anonymous.new(text_value)
+      end
+    } / number unit {
+      def build env
+        env.identifiers.last << Node::Number.new(number.text_value, unit.text_value)
+      end
+    } / string {
+      def build env
+        env.identifiers.last << Node::String.new(text_value)
+      end
+    }
+  end
+  
+  # !important
+  rule important
+    '!important' {
+      def build env
+        env.identifiers.last << Node::Keyword.new(text_value)
+      end
+    }
+  end
+  
+  #
+  # `blue`, `small`, `normal` etc.
+  #
+  rule keyword
+    [a-zA-Z] [-a-zA-Z]* !ns {
+      def build env
+        env.identifiers.last << Node::Keyword.new(text_value)
+      end
+    }
+  end
+    
+  #
+  # 'hello world' / "hello world"
+  #
+  rule string
+    "'" content:(!"'" . )* "'" {
+      def value
+        text_value[1...-1]
+      end
+    } / ["] content:(!["] . )* ["] {
+      def value
+        text_value[1...-1]
+      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
+    '#' hex {
+      def build env
+        env.identifiers.last << Node::Color.new(hex.text_value)
+      end
+    } / fn:(('hsl'/'rgb') 'a'?) '(' arguments ')' {
+      def build env
+        args = arguments.build env
+        env.identifiers.last << Node::Function.new(fn.text_value, args.flatten)
+      end
+    }
+  end
+  
+  rule hex
+    [a-fA-F0-9] [a-fA-F0-9] [a-fA-F0-9]+
+  end
+  
+  #
+  # Functions and arguments
+  #
+  rule function
+    name:([-a-zA-Z_]+) '(' arguments ')' {
+      def build env
+        args = arguments.build env
+        env.identifiers.last << Node::Function.new(name.text_value, [args].flatten)
+      end
+    }
+  end
+  
+  rule arguments
+    argument s ',' s arguments {
+      def build env
+        elements.map do |e|
+          e.build env if e.respond_to? :build
+        end.compact
+      end
+    } / argument
+  end
+  
+  rule argument
+    color {
+      def build env
+        Node::Color.new text_value
+      end
+    } / number unit {
+      def build env
+        Node::Number.new number.text_value, unit.text_value
+      end
+    } / string {
+      def build env
+        Node::String.new text_value
+      end
+    } / [a-zA-Z]+ '=' dimension {
+      def build env
+        Node::Anonymous.new text_value
+      end
+    } / [-a-zA-Z0-9_%$/.&=:;#+?]+ {
+      def build env
+        Node::String.new text_value
+      end
+    }
+  end
+  
+  #
+  # Whitespace
+  #
+  rule s
+    [ ]*
+  end
+  
+  rule S
+    [ ]+
+  end
+  
+  rule ws
+    [\n ]*
+  end
+  
+  # Non-space char
+  rule ns
+    ![ ;] .
+  end
+end