cloudhead-less 0.8.12 → 1.0.0

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

@@ -0,0 +1,153 @@
+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
+      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
+  
+      def each path = [], &blk
+      #
+      # Traverse the whole tree, returning each leaf or branch (recursive)
+      #
+      ###
+        #   Aside from the key & value, we yield the full path of the leaf,  
+        #   aswell as the branch which contains it (self).
+        #   Note that in :branch mode, we only return 'twigs', branches which contain leaves.
+        #
+        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,59 @@
+module Less
+  #
+  # Node::Entity
+  #
+  # TODO: Use delegate class -> @rules
+  #
+  # Class hierarchy
+  #
+  # - Entity
+  #   - Element
+  #   - Entity
+  #     - Function
+  #     - Keyword
+  #     - Literal
+  #       - Color
+  #       - Number
+  #       - String
+  #       - FontFamily
+  #   - Property
+  #     - Variable
+  #
+  module Node
+    module Entity
+      attr_accessor :parent
+    
+      def initialize value, parent = nil
+        super value
+        @parent = parent
+      end
+
+      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
+    
+    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,61 @@
+module Less
+  module Functions
+    def rgb *rgb
+      rgba rgb, 1.0
+    end
+
+    def hsl *args
+      hsla args, 1.0
+    end
+
+    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
+
+    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
+    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
+    
+      def evaluate
+        send self.to_sym, *@args
+      end
+    
+      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,132 @@
+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.to_s : self.to_s}#@unit"
+      end
+    end
+  
+    #
+    # "hello world"
+    #
+    class String < ::String
+      include Literal
+      
+      attr_reader :quotes, :content
+      
+      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
+  
+    #
+    # red small border-collapse
+    #
+    class Keyword < ::String
+      include Entity
+      
+      def to_css
+        self
+      end
+    
+      def inspect
+        "#{self}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+module Less
+  module Node
+    class Property < ::String
+      include Entity
+      
+      attr_accessor :value
+      
+      def initialize key, value = nil
+        super key
+        log "\n[new] #{self.class} `#{key}`\n"
+        @value = Expression.new(value ? [value] : [])
+        @eval = false # Store the first evaluation in here
+      end
+  
+      def << token
+        log "[adding] to #{self.to_s}: '#{token.to_s}' <#{token.class}>\n"
+        token = Node::Anonymous.new(*token) unless token.is_a? Entity or token.is_a? Operator
+        @value << token
+      end
+  
+      def empty?; !@value || @value.empty? end
+      def eval?;  @eval end
+
+      def inspect
+        self + (empty?? "" : ": `#{value.map {|i| i.to_s } * ' | '}`")
+      end
+ 
+      def to_s
+        super
+      end
+      
+      # TODO: @eval and @value should be merged
+      def evaluate    
+        @eval || @eval = value.evaluate
+      end
+          
+      def to_css
+        "#{self}: #{evaluate.to_css};"
+      end
+    end
+
+    class Variable < Property      
+      def initialize key, value = nil      
+        super key.delete('@'), value
+      end
+  
+      def inspect
+        "@#{super}"
+      end
+    
+      def to_s
+        "@#{super}"
+      end
+    
+      def to_ruby
+        value.evaluate.to_ruby
+      end
+    
+      def to_css
+        value.evaluate.to_css
+      end
+    end
+  
+    class Expression < Array
+      def operators; select {|i| i.is_a? Operator }   end
+      def entities;  select {|i| i.kind_of? Entity }  end
+      def literals;  select {|i| i.kind_of? Literal } end
+    
+      def inspect
+        '[' + map {|i| i.inspect }.join(', ') + ']'
+      end
+    
+      def to_css
+        map {|i| i.to_css } * ' '
+      end
+    
+      #
+      # Evaluates the expression and instantiates a new Literal with the result
+      # ex: [#111, +, #111] will evaluate to a Color node, with value #222
+      #
+      def evaluate
+        log "evaluating #{self}"
+        log "#{self.select{|i| i.is_a? Entity }}"
+        if size > 2 && (entities.size == operators.size + 1)
+          # Create a sub-expression with all the variables/properties evaluated
+          evaluated = Expression.new map {|e| e.respond_to?(:evaluate) ? e.evaluate : e }
+        
+          unit = evaluated.literals.map do |node|
+            node.unit
+          end.compact.uniq.tap do |ary|
+            raise MixedUnitsError, self * ' ' if ary.size > 1
+          end.join
+        
+          entity = evaluated.literals.find {|e| e.unit == unit } || evaluated.first        
+          ruby = map {|e| e.to_ruby if e.respond_to? :to_ruby }
+        
+          unless ruby.include? nil
+            log "ruby(#{unit}): " + ruby.join(' ') + "\n"
+      
+            if entity
+              log "\n# => #{eval(ruby.join)} <#{entity.class}>\n"
+              entity.class.new(eval(ruby.join), *(unit if entity.class == Node::Number))
+            else
+              log "\n# => not evaluated"
+              first
+            end
+          else
+            log "some elements dont respond to to_ruby: #{ruby}"
+            self
+          end
+        elsif size == 1
+          log "not evaluating, size == 1"
+          first
+        else
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Less
+  module Node
+    class Selector < ::String
+      include Entity
+      
+      Selectors = {
+        :Descendant => '',
+        :Child      => '>',
+        :Adjacent   => '+',
+        :Pseudo     => ':',
+        :Sibling    => '~'
+      }
+  
+      def initialize
+        super Selectors[ self.class.to_s.split('::').last.to_sym ]
+      end
+  
+      def self.[] key
+        Node.const_get(Selectors.find {|k, v| v == key }.first)
+      end
+    end
+
+    class Descendant < Selector
+      def to_css; " " end
+    end
+
+    class Child < Selector
+      def to_css; " #{self} " end
+    end
+
+    class Adjacent < Selector
+      def to_css; " #{self} " end
+    end
+
+    class Pseudo < Selector
+      def to_css; self end
+    end
+  end
+end

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'