lesslateral 1.2.21

data/lib/less/engine/grammar/less.tt

@@ -0,0 +1,341 @@
+require 'grammar/common'
+require 'grammar/entity'
+
+module Less
+  grammar StyleSheet
+    include Common
+    include Entity
+
+    rule primary
+      (import / declaration / ruleset / mixin / comment)* {
+        def build env = Less::Element.new
+          elements.map do |e|
+            e.build env if e.respond_to? :build
+          end; env
+        end
+      }
+    end
+
+    rule comment
+      ws '/*' (!'*/' . )* '*/' ws / ws '//' (!"\n" .)* "\n" ws
+    end
+
+    #
+    # div, .class, body > p {...}
+    #
+    rule ruleset
+      selectors "{" ws primary ws "}" s hide:(';'?) ws {
+        def build env
+          # Build the ruleset for each selector
+          selectors.build(env, :ruleset).each do |sel|
+            sel.hide unless hide.empty?
+            primary.build sel
+          end
+        end
+        # Mixin Declaration
+      } / ws '.' name:[-a-zA-Z0-9_]+ ws parameters ws "{" ws primary ws "}" ws {
+        def build env
+          env << Node::Mixin::Def.new(name.text_value, parameters.build(env))
+          primary.build env.last
+        end
+      }
+    end
+
+    rule mixin
+      name:('.' [-a-zA-Z0-9_]+) args:(arguments) s ';' ws {
+        def build env
+          definition = env.nearest(name.text_value, :mixin) or raise MixinNameError, "#{name.text_value}() in #{env}"
+          params = args.build.map {|i| Node::Expression.new i } unless args.empty?
+          env << Node::Mixin::Call.new(definition, params || [], env)
+        end
+    } / ws selectors ';' ws {
+        def build env
+          selectors.build(env, :mixin).each do |path|
+            rules = path.inject(env.root) do |current, node|
+              current.descend(node.selector, node) or raise MixinNameError, "#{selectors.text_value} in #{env}"
+            end.rules
+            env.rules += rules
+          end
+        end
+      }
+    end
+
+    rule selectors
+      ws selector tail:(s ',' ws selector)* ws {
+        def build env, method
+          all.map do |e|
+            e.send(method, env) if e.respond_to? method
+          end.compact
+        end
+
+        def all
+          [selector] + tail.elements.map {|e| e.selector }
+        end
+      }
+    end
+
+    #
+    # div > p a {...}
+    #
+    rule selector
+      sel:(s select element s)+ '' {
+        def ruleset env
+          sel.elements.inject(env) do |node, e|
+            node << Node::Element.new(e.element.text_value, e.select.text_value)
+            node.last
+          end
+        end
+
+        def mixin env
+          sel.elements.map do |e|
+            Node::Element.new(e.element.text_value, e.select.text_value)
+          end
+        end
+      }
+    end
+
+    rule parameters
+      '(' s ')' {
+        def build env
+          []
+        end
+      } / '(' parameter tail:(s ',' s parameter)* ')' {
+        def build env
+          all.map do |e|
+            e.build(env)
+          end
+        end
+
+        def all
+          [parameter] + tail.elements.map {|e| e.parameter }
+        end
+      }
+    end
+
+    rule parameter
+      variable s ':' s expressions {
+        def build env
+          Node::Variable.new(variable.text_value, expressions.build(env), env)
+        end
+      }
+    end
+
+    rule import
+      ws "@import" S url:(string / url) medias? s ';' ws {
+        def build env
+          standard_path = File.join(env.root.file || Dir.pwd, url.value)
+
+          # Compile a list of possible paths for this file
+          paths = $LESS_LOAD_PATH.map { |p| File.join(p, url.value) } + [standard_path]
+          # Standardize and make uniq
+          paths = paths.map do |p|
+            p = File.expand_path(p)
+            p += '.less' unless p =~ /\.(le|c)ss$/
+            p
+          end.uniq
+
+          # Use the first that exists if any
+          if path = paths.detect {|p| File.exists?(p)}
+            unless env.root.imported.include?(path)
+              env.root.imported << path
+              env.rules += Less::Engine.new(File.new(path)).to_tree.rules
+            end
+          else
+            raise ImportError, standard_path
+          end
+
+        end
+      }
+    end
+
+    rule url
+      'url(' path:(string / [-a-zA-Z0-9_%$/.&=:;#+?]+) ')' {
+        def build env = nil
+          Node::Function.new('url', value)
+        end
+
+        def value
+          Node::Quoted.new CGI.unescape(path.text_value)
+        end
+      }
+    end
+
+    rule medias
+      [-a-z]+ (s ',' s [a-z]+)*
+    end
+
+    #
+    # @my-var: 12px;
+    # height: 100%;
+    #
+    rule declaration
+      ws name:(ident / variable) s ':' ws expressions tail:(ws ',' ws expressions)* s (';'/ ws &'}') ws {
+        def build env
+          result = all.map {|e| e.build(env) if e.respond_to? :build }.compact
+          env << (name.text_value =~ /^@/ ?
+            Node::Variable : Node::Property).new(name.text_value, result, env)
+        end
+
+        def all
+          [expressions] + tail.elements.map {|f| f.expressions }
+        end
+      # Empty rule
+      } / ws ident s ':' s ';' ws
+    end
+
+    #
+    # An operation or compound value
+    #
+    rule expressions
+      # Operation
+      expression tail:(operator expression)+ {
+        def build env = nil
+          all.map {|e| e.build(env) }.dissolve
+        end
+
+        def all
+          [expression] + tail.elements.map {|i| [i.operator, i.expression] }.flatten.compact
+        end
+      # Space-delimited expressions
+      } / expression tail:(WS expression)* i:important? {
+        def build env = nil
+          all.map {|e| e.build(env) if e.respond_to? :build }.compact
+        end
+
+        def all
+          [expression] + tail.elements.map {|f| f.expression } + [i]
+        end
+      # Catch-all rule
+      } / [-a-zA-Z0-9_.&*/=:,+? \[\]()#%]+ {
+        def build env
+          [Node::Anonymous.new(text_value)]
+        end
+      }
+    end
+
+    rule expression
+      '(' s expressions s ')' {
+        def build env = nil
+          Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
+        end
+      } / entity '' {
+        def build env = nil
+          e = entity.method(:build).arity.zero?? entity.build : entity.build(env)
+          e.respond_to?(:dissolve) ? e.dissolve : e
+        end
+      }
+    end
+
+    # !important
+    rule important
+      s '!' s 'important' {
+        def build env = nil
+          Node::Keyword.new(text_value.strip)
+        end
+      }
+    end
+
+    #
+    # An identifier
+    #
+    rule ident
+      '*'? '-'? [-a-z_] [-a-z0-9_]*
+    end
+
+    rule variable
+      '@' [-a-zA-Z0-9_]+  {
+        def build
+          Node::Variable.new(text_value)
+        end
+      }
+    end
+
+    #
+    # div / .class / #id / input[type="text"] / lang(fr)
+    #
+    rule element
+      ((class / id / tag / ident) attribute* ('(' [a-zA-Z]+ ')' / '(' (pseudo_exp / selector / [0-9]+) ')' )?)+
+      / attribute+ / '@media' / '@font-face'
+    end
+
+    #
+    # 4n+1
+    #
+    rule pseudo_exp
+      '-'? ([0-9]+)? 'n' ([-+] [0-9]+)?
+    end
+
+    #
+    # [type="text"]
+    #
+    rule attribute
+      '[' tag ([|~*$^]? '=') (string / [-a-zA-Z_0-9]+) ']' / '[' (tag / string) ']'
+    end
+
+    rule class
+      '.' [_a-zA-Z] [-a-zA-Z0-9_]*
+    end
+
+    rule id
+      '#' [_a-zA-Z] [-a-zA-Z0-9_]*
+    end
+
+    rule tag
+      [a-zA-Z] [-a-zA-Z]* [0-9]? / '*'
+    end
+
+    rule select
+      (s [+>~] s / '::' / s ':' / S)?
+    end
+
+    # TODO: Merge this with attribute rule
+    rule accessor
+      ident:(class / id / tag) '[' attr:(string / variable) ']' {
+        def build env
+          env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
+        end
+      }
+    end
+
+    rule operator
+      S [-+*/] S {
+        def build env
+          Node::Operator.new(text_value.strip)
+        end
+      } / [-+*/] {
+        def build env
+          Node::Operator.new(text_value)
+        end
+      }
+    end
+
+    #
+    # Functions and arguments
+    #
+    rule function
+      name:([-a-zA-Z_]+) arguments {
+        def build
+          Node::Function.new(name.text_value, arguments.build)
+        end
+      }
+    end
+
+    rule arguments
+      '(' s expressions s tail:(',' s expressions s)* ')' {
+        def build
+          all.map do |e|
+            e.build if e.respond_to? :build
+          end.compact
+        end
+
+        def all
+          [expressions] + tail.elements.map {|e| e.expressions }
+        end
+      } / '(' s ')' {
+        def build
+          []
+        end
+      }
+    end
+  end
+end

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,281 @@
+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
+      include Enumerable
+      include Entity
+
+      attr_accessor :rules, :selector, :file,
+                    :set,   :imported, :name
+
+      def initialize name = "", selector = ''
+        @name = name
+        @set, @imported = [], []
+        @rules = [] # Holds all the nodes under this element's hierarchy
+        @selector = Selector[selector.strip].new  # descendant | child | adjacent
+      end
+
+      def class?;     name =~ /^\./ end
+      def id?;        name =~ /^#/  end
+      def universal?; name == '*'   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
+        elements = self.elements.reject {|e| e.is_a?(Mixin::Def) }
+        return self unless elements.size > 1
+
+        stack, result, matched = elements.dup, [], false
+
+        elements.each do
+          e = stack.first
+          result << e unless matched
+
+          matched = stack[1..-1].each do |ee|
+            if e.equiv? ee and e.elements.size == 0
+              self[e].set << ee
+              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.kind_of?     Element    } end
+      def mixins;      @rules.select {|r| r.instance_of? Mixin::Call} end
+      def parameters;  []                                             end
+
+      # Select a child element
+      # TODO: Implement full selector syntax & merge with descend()
+      def [] key
+        case key
+          when Entity
+            @rules.find {|i| i.eql? key }
+          when String
+            @rules.find {|i| i.to_s == key }
+          else raise ArgumentError
+        end
+      end
+
+      def == other
+        name == other.name
+      end
+
+      def eql? other
+        super and self.equiv? other
+      end
+
+      def equiv? other
+        rules.size == other.rules.size and
+        !rules.zip(other.rules).map do |a, b|
+          a.to_css == b.to_css
+        end.include?(false)
+      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.name].selector
+          self[element.name] if s.is_a? Child or s.is_a? Descendant
+        elsif selector.is_a? Descendant
+          self[element.name]
+        else
+          self[element.name] if self[element.name].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?? '*' : name end
+
+      #
+      # Entry point for the css conversion
+      #
+      def to_css path = [], env = nil
+        path << @selector.to_css << name unless root?
+
+#       puts "to_css env: #{env ? env.variables : "nil"}"
+        content = @rules.select do |r|
+          r.is_a?(Mixin::Call) || r.instance_of?(Property)
+        end.map do |i|
+          ' ' * 2 + i.to_css(env)
+        end.compact.reject(&:empty?) * "\n"
+
+        content = content.include?("\n") ? "\n#{content}\n" : " #{content.strip} "
+
+        ruleset = if is_a?(Mixin::Def)
+          content.strip
+        else
+          !content.strip.empty??
+            "#{[path.reject(&:empty?).join.strip,
+            *@set.map(&:name)].uniq * ', '} {#{content}}\n" : ""
+        end
+
+        ruleset + elements.reject {|e| e.is_a?(Mixin::Def) }.map do |i|
+          i.to_css(path, env)
+        end.reject(&:empty?).join
+
+      ensure
+        2.times { path.pop }
+      end
+
+      #
+      # Find the nearest node in the hierarchy or raise a NameError
+      #
+      def nearest ident, type = nil
+        ary = type || 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} in #{self.to_s}") if result.nil? && type != :mixin
+        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.to_s,
+          put[ variables ],
+          put[ properties ],
+          put[ mixins ],
+          elements.map {|i| i.inspect( depth + 1 ) } * "\n"
+        ].reject(&:empty?).join("\n") + "\n" + indent[ depth ]
+      end
+    end
+
+    module Mixin
+      class Call
+        include Entity
+
+        def initialize mixin, params, parent
+#          puts "Initializing a Mixin::Call #{mixin}"
+          @mixin = mixin
+          self.parent = parent
+          @params = params.each do |e|
+            e.parent = self.parent
+          end
+        end
+
+        def to_css env = nil
+#          puts "\n\n"
+#          puts "call .#{@mixin.name} #{@params} <#{@params.class}>"
+          @mixin.call(@params.map {|e| e.evaluate(env) })
+        end
+
+        def inspect
+          "#{@mixin.to_s} (#{@params})"
+        end
+      end
+
+      class Def < Element
+        attr_accessor :params
+
+        def initialize name, params = []
+          super name
+          @params = params.each do |param|
+            param.parent = self
+          end
+        end
+
+        def call args = []
+          if e = @rules.find {|r| r.is_a? Element }
+            raise CompileError, "#{e} in #{self.inspect}: can't nest selectors inside a dynamic mixin."
+          end
+
+          env = Element.new
+
+          @params.zip(args).each do |param, val|
+            env << (val ? Variable.new(param.to_s, Expression.new([val])) : param)
+          end
+
+          #b ? Node::Variable.new(a.to_s, Expression.new([b])) : a
+
+#          puts "#{self.inspect}"
+#          puts "env: #{env.variables}      root?: #{env.root?}"
+#          puts "\nTOCSS"
+          to_css([], env)
+        end
+
+        def variables
+          params + super
+        end
+
+        def to_s
+          '.' + name
+        end
+
+        def inspect
+          ".#{name}()"
+        end
+
+        def to_css path, env
+          super(path, env)
+        end
+      end
+    end
+  end
+end