nirvdrum-less 1.1.4

data/lib/less/engine/nodes.rb

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

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

@@ -0,0 +1,186 @@
+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, :set
+  
+      def initialize name = "", selector = ''
+        super name   
+        
+        @set = []
+        @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?
+        parent.nil?
+      end
+    
+      def empty?
+        @rules.empty?
+      end
+  
+      def leaf?
+        elements.empty?
+      end
+      
+      # Group similar rulesets together
+      # This is horrible, horrible code,
+      # but it'll have to do until I find
+      # a proper way to do it.
+      def group
+        matched = false
+        stack, result = elements.dup, []
+        return self unless elements.size > 1
+        
+        elements.each do
+          e = stack.first
+          result << e unless matched
+          
+          matched = stack[1..-1].each do |ee|
+            if e.rules.size == ee.rules.size and 
+               e.elements.size == 0 and
+              !e.rules.zip(ee.rules).map {|a, b| 
+                a.to_css == b.to_css
+              }.include?(false)
+              
+              # Add to set unless it's a duplicate
+              if e == ee
+                # Do something with dups
+              else
+                self[e].set << ee
+              end
+              stack.shift
+            else
+              stack.shift
+              break false
+            end
+          end if stack.size > 1
+        end
+        @rules -= (elements - result)
+        self
+      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; root?? '*' : 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, *@set] * ', '} {#{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
+  
+      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,79 @@
+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
+    
+    class Paren < ::String
+      def to_ruby
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+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
+      Node::Color.new *rgba.flatten
+    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
+    
+    def self.available
+      self.instance_methods.map(&:to_sym)
+    end
+  end
+  
+  module Node
+    #
+    # A CSS function, like rgb() or url()
+    #
+    #   it calls functions from the Functions module
+    #
+    class Function < ::String
+      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
+      #
+      # If the function isn't found, we just print it out,
+      # this is the case for url(), for example,
+      #
+      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
+end

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

@@ -0,0 +1,167 @@
+module Less
+  module Node
+    module Literal
+      include Entity
+      
+      def unit
+        nil
+      end
+    end
+  
+    #
+    # rgb(255, 0, 0) #f0f0f0
+    #
+    class Color
+      include Literal
+      attr_reader :r, :g, :b, :a
+
+      def initialize r, g, b, a = 1.0
+        @r, @g, @b = [r, g, b].map do |c|
+          normalize(c.is_a?(::String) ? c.to_i(16) : c)
+        end
+        @a = normalize(a, 1.0)
+      end
+      
+      def alpha v
+        self.class.new r, g, b, v
+      end
+      
+      def rgb
+        [r, g, b]
+      end
+      
+      def operate op, other
+        color = if other.is_a? Numeric
+          rgb.map {|c| c.send(op, other) }
+        else
+          rgb.zip(other.rgb).map {|a, b| a.send(op, b) }
+        end
+        self.class.new *[color, @a].flatten # Ruby 1.8 hack
+      end
+      
+      def + other; operate :+, other end
+      def - other; operate :-, other end
+      def * other; operate :*, other end
+      def / other; operate :/, other end
+      
+      def coerce other
+        return self, other
+      end
+
+      def to_s
+        if a < 1.0
+          "rgba(#{r.to_i}, #{g.to_i}, #{b.to_i}, #{a})"
+        else
+          "#%02x%02x%02x" % [r, g, b]
+        end
+      end
+
+      def inspect
+        if a < 1.0
+          "rgba(#{r}, #{g}, #{b}, #{a})"
+        else
+          "rgb(#{r}, #{g}, #{b})"
+        end
+      end
+
+      def to_css
+        to_s
+      end
+      
+      def to_ruby
+        "#{self.class}.new(#{r},#{g},#{b},#{a})"
+      end
+      
+    protected
+      def normalize(v, max = 255, min = 0)
+        [[min, v].max, max].min
+      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
+      include Literal
+      
+      def initialize family = []
+        @family = family
+      end
+    
+      def to_css
+        @family.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