lesslateral 1.2.21

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,93 @@
+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].flatten
+    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 = if args.is_a? Array
+          args.map {|e| e.is_a?(Expression) ? e : Expression.new(e, self)}
+        else
+          [args]
+        end
+        
+        super name
+      end
+      
+      def to_css env = nil
+        self.evaluate(env).to_css
+      end
+      
+      def nearest node
+        parent.nearest node
+      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 context = nil
+        if Functions.available.include? self.to_sym
+          send to_sym, *@args
+        else
+          args = @args.map { |e|
+            e.parent = self.parent
+            e = e.evaluate(context) if e.respond_to?(:evaluate)
+            e.to_css
+          }  * ', '
+          Node::Anonymous.new("#{to_sym}(#{args})")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+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 dup
+        self
+      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 Quoted < 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

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

@@ -0,0 +1,232 @@
+module Less
+  module Node
+    class Property < String
+      include Entity
+
+      attr_accessor :value
+
+      def initialize key, value = nil, parent = nil
+        super key, parent
+        value = if value.is_a? Array
+          value.each {|v| v.parent = self if v.respond_to? :parent }.
+                map  {|v| v.is_a?(Expression) ? v : Expression.new(v, self) }
+        elsif value.nil?
+          []
+        else
+          value
+        end
+        @value = value.is_a?(Expression) ? value : Expression.new(value, self)
+        @value.parent = self
+        @value.delimiter = ','
+#        puts "new property #{to_s}: #{value} => #{@value}, contains: #{@value[0].class}"
+#        puts
+      end
+
+      def parent= obj
+        @parent = obj
+        value.parent = self
+      end
+
+      def copy
+        clone.tap {|c| c.value = value.copy }
+      end
+
+      def << token
+        token = Node::Anonymous.new(*token) unless token.is_a? Entity or token.respond_to? :to_ruby
+        token.parent = self if token.respond_to? :parent
+        @value << token
+      end
+
+      def empty?; !@value || @value.empty? end
+
+      def inspect
+        self + (empty?? "" : ": `#{value.map {|i| i.to_s } * ' | '}`")
+      end
+
+      def == other
+        self.to_s == other.to_s
+      end
+
+      def eql? other
+        self == other and value.eql? other.value
+      end
+
+      def to_s
+        super
+      end
+
+      def nearest node
+        parent.nearest node
+      end
+
+      def evaluate env = nil
+#        puts "evaluating property `#{to_s}`: #{value.inspect}"
+        if value.is_a?(Expression) #Value
+#          puts "value is a Value"
+          value.map {|e| e.evaluate(env) } #6
+        else
+#          puts "value is a #{value.class}"
+          [value.evaluate(env)]
+        end
+
+
+      end
+
+      def to_css env = nil
+#        puts "property.to_css `#{to_s}` env:#{env ? env.variables : "nil"}"
+        val = evaluate(env)
+        "#{self}: #{if val.respond_to? :to_css
+            val.to_css
+          else
+#            p val
+#            puts "#{val.class} #{val.first.class}"
+            val.map {|i| i.to_css }.join(", ")
+          end};"
+      end
+    end
+
+    class Variable < Property
+      attr_reader :declaration
+
+      def initialize key, value = nil, parent = nil
+        @declaration = value ? true : false
+        super key.delete('@'), value, parent
+      end
+
+      def inspect
+        "@#{super}"
+      end
+
+      def to_s
+        "@#{super}"
+      end
+
+      def evaluate env = nil
+        if declaration
+#          puts "evaluating DEC"
+          value.evaluate #2
+        else
+#          puts "evaluating #{to_s} par: #{parent} env: #{env ? env.variables : "nil"}"
+        begin
+          var = (env || self.parent).nearest(to_s) #3
+        rescue VariableNameError
+          var = self.parent.nearest(to_s)
+        end
+          var.evaluate
+        end
+      end
+
+      def to_ruby
+        evaluate.to_ruby
+      end
+
+      def to_css env = nil
+        val = evaluate env
+        if val.respond_to? :to_css
+          env ? val.to_css(env) : val.to_css
+        else
+          val.map {|i| env ? i.to_css(env) : i.to_css }.join ', '
+        end
+      end
+    end
+
+    class Expression < Array
+      attr_accessor :parent, :delimiter
+
+      def initialize ary, parent = nil, delimiter = ' '
+        self.parent = parent
+        self.delimiter = delimiter
+#        puts "new expression #{ary} |#{delimiter}|"
+        super(ary.is_a?(Array) ? ary : [ary].flatten)
+      end
+
+      def expressions; select {|i| i.kind_of? Expression } end
+      def variables;   select {|i| i.kind_of? Variable   } end
+      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 parent= obj
+        @parent = obj
+        each {|e| e.parent = obj if e.respond_to? :parent }
+      end
+
+      def inspect
+        '[' + map {|i| i.inspect }.join(', ') + ']'
+      end
+
+      def delimiter= d
+        @delimiter = d.strip + ' '
+      end
+
+      def flatten
+        self
+      end
+
+      def terminal?
+        expressions.empty? #&& variables.empty?
+      end
+
+      def to_css env = nil
+#        puts "TOCSS, delim: |#{@delimiter}|"
+        map do |i|
+          i.parent = self.parent
+          i.respond_to?(:to_css) ? i.to_css() : i.to_s
+        end * @delimiter
+      end
+
+      def to_ruby
+        map do |i|
+          i.respond_to?(:to_ruby) ? i.to_ruby : i.to_s
+        end
+      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 env = nil
+#        puts "expression #{self.inspect} env: #{env ? env.variables : "nil"}"
+        if size > 2 or !terminal?
+#          puts " SIZE > 2 or !terminal"
+
+#          puts "--- sub evaluation ---"
+
+          # Replace self with an evaluated sub-expression
+          evaled = self.class.new(map {|e| e.respond_to?(:evaluate) ? e.evaluate(env) : e }, parent, delimiter) #5
+
+#          puts "======================"
+#          puts "evaled => #{evaled.inspect}"
+
+          unit = evaled.literals.map do |node|
+            node.unit
+          end.compact.uniq.tap do |ary|
+            raise MixedUnitsError, evaled * ' ' if ary.size > 1 && !evaled.operators.empty?
+          end.join
+
+          entity = evaled.literals.find {|e| e.unit == unit } || evaled.literals.first || evaled.entities.first
+          result = evaled.operators.empty?? evaled : eval(evaled.to_ruby.join)
+
+#          puts "entity is a #{entity.class}"
+#          puts "delimiter is |#{@delimiter}|"
+
+          case result
+            when Entity     then result
+            when Expression then result.one?? result.first : self.class.new(result, parent, delimiter)
+            else entity.class.new(result, *(unit if entity.class == Node::Number))
+          end
+        elsif size == 1
+          if first.is_a? Variable
+            first.evaluate(env)
+          elsif first.is_a? Function
+            first.evaluate(env)
+          else
+            first
+          end
+        else
+          self
+        end
+      end
+    end
+  end
+end