less 0.8.13 → 1.0.4

data/lib/less/engine/nodes.rb

@@ -0,0 +1,8 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'engine/nodes/entity'
+require 'engine/nodes/element'
+require 'engine/nodes/property'
+require 'engine/nodes/literal'
+require 'engine/nodes/function'
+require 'engine/nodes/selector'

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

@@ -0,0 +1,150 @@
+module Less
+  module Node
+    #
+    # Element
+    #
+    # div {...}
+    #
+    # TODO: Look into making @rules its own hash-like class
+    # TODO: Look into whether selector should be child by default
+    #
+    class Element < ::String
+      include Enumerable
+      include Entity
+  
+      attr_accessor :rules, :selector, :partial, :file
+  
+      def initialize name = "", selector = ''
+        super name
+      
+        @partial = false
+        @rules = [] # Holds all the nodes under this element's hierarchy
+        @selector = Selector[selector.strip].new  # descendant | child | adjacent
+      end
+    
+      def class?;     self =~ /^\./ end
+      def id?;        self =~ /^#/  end
+      def universal?; self == '*'   end
+  
+      def tag? 
+        not id? || class? || universal?
+      end
+  
+      # Top-most node?
+      def root?
+        self == '' && parent.nil?
+      end
+    
+      def empty?
+        @rules.empty?
+      end
+  
+      def leaf?
+        elements.empty?
+      end
+  
+      #
+      # 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
+  
+      # Select a child element
+      # TODO: Implement full selector syntax & merge with descend()
+      def [] key
+        @rules.find {|i| i.to_s == key }
+      end
+    
+      # Same as above, except with a specific selector
+      # TODO: clean this up or implement it differently
+      def descend selector, element
+        if selector.is_a? Child
+          s = self[element].selector
+          self[element] if s.is_a? Child or s.is_a? Descendant
+        elsif selector.is_a? Descendant
+          self[element]
+        else
+          self[element] if self[element].selector.class == selector.class
+        end
+      end
+  
+      #
+      # Add an arbitrary node to this element
+      #
+      def << obj
+        if obj.kind_of? Node::Entity
+          obj.parent = self
+          @rules << obj
+        else
+          raise ArgumentError, "argument can't be a #{obj.class}"
+        end
+      end
+    
+      def last;  elements.last  end
+      def first; elements.first end
+      def to_s; super end
+      
+      #
+      # Entry point for the css conversion
+      #
+      def to_css path = []
+        path << @selector.to_css << self unless root?
+
+        content = properties.map do |i|
+          ' ' * 2 + i.to_css
+        end.compact.reject(&:empty?) * "\n"
+    
+        content = content.include?("\n") ? 
+          "\n#{content}\n" : " #{content.strip} "
+        ruleset = !content.strip.empty?? 
+          "#{path.reject(&:empty?).join.strip} {#{content}}\n" : ""
+    
+        css = ruleset + elements.map do |i|
+          i.to_css(path)
+        end.reject(&:empty?).join
+        path.pop; path.pop
+        css
+      end
+  
+      #
+      # Find the nearest variable in the hierarchy or raise a NameError
+      #
+      def nearest ident
+        ary = 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
+        end
+      end
+    
+      #
+      # Traverse the whole tree, returning each leaf (recursive)
+      #
+      def each path = [], &blk
+        elements.each do |element|                            
+          path << element                         
+          yield element, path if element.leaf?                
+          element.each path, &blk                                        
+          path.pop                    
+        end
+        self
+      end
+      alias :traverse :each
+  
+      def inspect depth = 0
+        indent = lambda {|i| '.  ' * i }
+        put    = lambda {|ary| ary.map {|i| indent[ depth + 1 ] + i.inspect } * "\n"}
+
+        (root?? "\n" : "") + [
+          indent[ depth ] + (self == '' ? '*' : self.to_s),
+          put[ properties ],
+          put[ variables ],
+          elements.map {|i| i.inspect( depth + 1 ) } * "\n"
+        ].reject(&:empty?).join("\n") + "\n" + indent[ depth ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Less
+  #
+  # Node::Entity
+  #   
+  #   Everything in the tree is an Entity
+  #
+  # Mixin/Class hierarchy
+  #
+  # - Entity
+  #   - Element
+  #   - Entity
+  #     - Function
+  #     - Keyword
+  #     - Literal
+  #       - Color
+  #       - Number
+  #       - String
+  #       - FontFamily
+  #   - Property
+  #     - Variable
+  #
+  # TODO: Use delegate class -> @rules
+  #
+  module Node
+    module Entity
+      attr_accessor :parent
+    
+      def initialize value, parent = nil
+        super value
+        @parent = parent
+      end
+      
+      #
+      # Returns the path from any given node, to the root
+      #
+      #   ex: ['color', 'p', '#header', 'body', '*']
+      #
+      def path node = self
+        path = []
+        while node do
+          path << node
+          node = node.parent
+        end
+        path
+      end
+    
+      def root
+        path.last
+      end
+    
+      def inspect;  to_s  end
+      def to_css;   to_s  end
+      def to_s;     super end
+    end
+    
+    #
+    # An anonymous node, for all the 'other' stuff
+    # which doesn't need any specific functionality.
+    #
+    class Anonymous < ::String
+      include Entity
+    end
+    
+    #
+    # + * - /
+    #
+    class Operator < ::String
+      def to_ruby
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+module Less
+  #
+  # Functions useable from within the style-sheet go here
+  #
+  module Functions
+    def rgb *rgb
+      rgba rgb, 1.0
+    end
+
+    def hsl *args
+      hsla args, 1.0
+    end
+
+    #
+    # RGBA to Node::Color
+    #
+    def rgba *rgba
+      r, g, b, a = rgba.flatten
+      hex = [r, g, b].inject("") do |str, c|
+        c = c.to_i.to_s(16)
+        c = '0' + c if c.length < 2
+        str + c
+      end
+      Node::Color.new hex, a
+    end
+    
+    #
+    # HSLA to RGBA
+    #
+    def hsla h, s, l, a = 1.0
+      m2 = ( l <= 0.5 ) ? l * ( s + 1 ) : l + s - l * s
+      m1 = l * 2 - m2;
+
+      hue = lambda do |h|
+        h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h)
+        if    h * 6 < 1 then m1 + (m2 - m1) * h * 6
+        elsif h * 2 < 1 then m2 
+        elsif h * 3 < 2 then m1 + (m2 - m1) * (2/3 - h) * 6 
+        else m1
+        end
+      end
+
+      rgba hue[ h + 1/3 ], hue[ h ], hue[ h - 1/3 ], a
+    end
+  end
+  
+  module Node
+    #
+    # A CSS function, like rgb() or url()
+    #
+    #   it calls functions from the Functions module
+    #
+    class Function < ::String
+      include Functions
+      include Entity
+    
+      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) * ', '})")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+module Less
+  module Node
+    module Literal
+      include Entity
+      
+      def unit
+        nil
+      end
+    end
+  
+    #
+    # rgb(255, 0, 0) #f0f0f0
+    #
+    class Color < DelegateClass(Fixnum)
+      include Literal
+      attr_reader :color
+      
+      def initialize color = nil, opacity = 1.0
+        @color = if color.is_a? Array
+          rgba color
+        elsif color.is_a? ::String
+          color.delete! unit
+          (color * ( color.length < 6 ? 6 / color.length : 1 )).to_i 16
+        else
+          color
+        end
+        super @color.to_i
+      end
+    
+      def unit
+        '#'
+      end
+    
+      def to_css
+        unit + (self <= 0 ? '0' * 6 : self.to_i.to_s(16))
+      end
+    
+      def to_ruby
+        color
+      end
+    
+      def to_s
+        "#{unit}#{super}"
+      end
+      
+      def inspect; to_s end
+    end
+  
+    #
+    # 6 10px 125%
+    #
+    class Number < DelegateClass(Float)
+      include Literal
+      
+      attr_accessor :unit
+    
+      def initialize value, unit = nil
+        super value.to_f
+        @unit = (unit.nil? || unit.empty?) ? nil : unit
+      end
+    
+      def to_s
+        "#{super}#@unit"
+      end
+    
+      def to_ruby
+        self.to_f
+      end
+      
+      def inspect
+        to_s
+      end
+    
+      def to_css
+        "#{(self % 1).zero?? "#{self.to_i}#@unit" : self}"
+      end
+    end
+  
+    #
+    # "hello world"
+    #
+    class String < ::String
+      include Literal
+      
+      attr_reader :quotes, :content
+      
+      # Strip quotes if necessary, and save them in @quotes
+      def initialize str
+        @quotes, @content = unless str.nil? or str.empty?
+          str.match(/('|")(.*?)(\1)/).captures rescue [nil, str]
+        else
+          [nil, ""]
+        end
+        super @content
+      end
+      
+      def to_css
+        "#@quotes#{@content}#@quotes"
+      end
+    end
+  
+    class Font
+      include Literal
+    end
+  
+    class FontFamily < Array
+      include Literal
+      
+      def initialize family = []
+        super family
+      end
+    
+      def to_css
+        self.map(&:to_css) * ', '
+      end
+    end
+  
+    #
+    # Any un-quoted word
+    #   
+    #   ex: red, small, border-collapse
+    #
+    class Keyword < ::String
+      include Entity
+      
+      def to_css
+        self
+      end
+    
+      def inspect
+        "#{self}"
+      end
+    end
+  end
+end