railsdog-less 1.2.17

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,229 @@
+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.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)
+          else
+            first
+          end
+        else
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Less
+  module Node
+    class Ruleset < Array
+      def initialize elements = []
+        super elements
+      end
+      
+      def to_css
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Less
+  module Node
+    class Selector < String
+      include Entity
+      
+      Selectors = {
+        :Descendant    => '',
+        :Child         => '>',
+        :Adjacent      => '+',
+        :PseudoClass   => ':',
+        :PseudoElement => '::',
+        :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 PseudoClass < Selector
+      def to_css; self end
+    end
+    
+    class PseudoElement < Selector
+      def to_css; self end
+    end
+  end
+end