cloudhead-less 0.8.12 → 1.0.0

data/lib/less/engine.rb

@@ -1,154 +1,57 @@
-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]+/,                        # 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
+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
       
-      #
-      # 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
-
-          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
+      begin
+        require Less::PARSER
+      rescue LoadError
+        Treetop.load Less::GRAMMAR
       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
+      
+      log @tree.inspect
+            
+      @tree
     end
+    alias :to_tree :parse
     
-    def to_css chain = :desc
-      self.compile.to_css chain
+    def to_css
+      "/* Generated with Less #{Less.version} */\n\n" +  
+      (@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(/\/\/.*\n/, '').                                                   # Comments //
-                  gsub(/\/\*.*?\*\//m, '').                                               # Comments /*
-                  gsub(/\s+/, ' ').                                                       # Replace \t\n
-                  gsub(/"/, "'").                                                         # " to '
-                  gsub(/("|')(.*?)(\1)/) { $1 + CGI.escape( $2 ) + $1 }.                  # Escape string values
-                  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").                                      # m$
+            gsub(/\t/, '  ')                                        # Tabs to spaces
+            #gsub(/('|")(.*?)(\1)/) { $1 + CGI.escape( $2 ) + $1 }   # Escape string values
+           # gsub(/\/\/.*\n/, '').                                    # Comments //
+          #  gsub(/\/\*.*?\*\//m, '')                                 # Comments /*
     end
   end
 end

data/lib/less.rb

@@ -1,24 +1,79 @@
-$:.unshift File.dirname(__FILE__)
+$:.unshift File.dirname(__FILE__), File.join(File.dirname(__FILE__), 'vendor', 'treetop', 'lib')
 
+require 'rubygems'
 require 'cgi'
+require 'delegate'
+require 'treetop'
 
 require 'less/command'
 require 'less/engine'
-require 'less/tree'
 
 module Less
-  MixedUnitsError = Class.new(Exception)
-  PathError = Class.new(Exception)
-  CompoundOperationError = Class.new(Exception)
+  PARSER = 'lib/less/engine/parser.rb'
+  GRAMMAR = 'lib/less/engine/less.tt'
+  
+  MixedUnitsError   = Class.new(Exception)
+  PathError         = Class.new(Exception)
+  VariableNameError = Class.new(NameError)
+  MixinNameError    = Class.new(NameError)
+  SyntaxError       = Class.new(RuntimeError)
+  ImportError       = Class.new(Exception)
+  
+  $verbose = false
 
   def self.version
-    File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') )
+    File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') ).strip
+  end
+  
+  def self.parse less
+    Engine.new(less).to_css
+  end
+end
+
+module Treetop
+  module Runtime
+    class CompiledParser
+      def failure_message
+        return nil unless (tf = terminal_failures) && tf.size > 0
+        "on line #{failure_line}: expected " + (
+          tf.size == 1 ? 
+            tf[0].expected_string : 
+            "one of #{tf.map {|f| f.expected_string }.uniq * ' '}"
+        ) +
+        " got `#{input[failure_index]}`" +
+        " 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
+  
+  def log(s = '')  puts "* #{s}" if $verbose end
+  def log!(s = '') puts "* #{s}" end
+  def error(s) $stderr.puts s end
+  def error!(s) raise CradleError, s end
+end
+
+class Class
+  def to_sym
+    self.to_s.to_sym
   end
 end
 
-class Hash
-  # Convert a hash into a Tree
-  def to_tree
-    Less::Tree.new self
+class Symbol
+  def to_proc
+    proc {|obj, *args| obj.send(self, *args) }
   end
 end

data/spec/command_spec.rb

@@ -6,7 +6,7 @@ module LessCommandSpecHelper
   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-1.0.css

@@ -0,0 +1,20 @@
+/* Generated with Less 1.0.0 */
+
+.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; }