nirvdrum-less 1.1.4

data/lib/ext.rb

@@ -0,0 +1,62 @@
+module Treetop
+  module Runtime
+    class CompiledParser
+      def failure_message
+        return nil unless (tf = terminal_failures) && tf.size > 0
+        "on line #{failure_line}: expected " + (
+          tf.size == 1 ? 
+            tf[0].expected_string : 
+            "one of #{Less::YELLOW[tf.map {|f| f.expected_string }.uniq * ' ']}"
+        ) +
+        " got #{Less::YELLOW[input[failure_index].chr]}" +
+        " after:\n\n#{input[index...failure_index]}\n"
+      end
+    end
+  end
+end
+
+class Object
+  def verbose
+    $verbose = true
+    yield
+  ensure
+    $verbose = false
+  end
+  
+  def tap
+    yield self
+    self
+  end
+  
+  def log(s = '')  puts "* #{s}" if $verbose end
+  def log!(s = '') puts "* #{s}" end
+  def error(s) $stderr.puts s end
+  def error!(s) raise Exception, s end
+end
+
+class Array
+  def dissolve
+    ary = flatten.compact
+    case ary.size
+      when 0 then []
+      when 1 then first
+      else ary
+    end
+  end
+  
+  def one?
+    size == 1
+  end
+end
+
+class Class
+  def to_sym
+    self.to_s.to_sym
+  end
+end
+
+class Symbol
+  def to_proc
+    proc {|obj, *args| obj.send(self, *args) }
+  end
+end

data/lib/less.rb

@@ -0,0 +1,33 @@
+$:.unshift File.join(File.dirname(__FILE__), 'vendor', 'treetop', 'lib'), 
+           File.dirname(__FILE__)
+
+require 'cgi'
+require 'treetop'
+require 'delegate'
+
+LESS_ROOT = File.expand_path(File.dirname(__FILE__))
+LESS_PARSER = File.join(LESS_ROOT, 'less', 'engine', 'parser.rb')
+LESS_GRAMMAR = File.join(LESS_ROOT, 'less', 'engine', 'grammar')
+
+require 'ext'
+require 'less/command'
+require 'less/engine'
+
+module Less  
+  MixedUnitsError   = Class.new(RuntimeError)
+  PathError         = Class.new(RuntimeError)
+  VariableNameError = Class.new(NameError)
+  MixinNameError    = Class.new(NameError)
+  SyntaxError       = Class.new(RuntimeError)
+  ImportError       = Class.new(RuntimeError)
+  
+  $verbose = false
+
+  def self.version
+    File.read( File.join( File.dirname(__FILE__), '..', 'VERSION') ).strip
+  end
+  
+  def self.parse less
+    Engine.new(less).to_css
+  end
+end

data/lib/less/command.rb

@@ -0,0 +1,106 @@
+module Less
+  ESC = "\033"
+  RESET   = "#{ESC}[0m"
+  
+  GREEN  = lambda {|s| "#{ESC}[1;32m#{s}#{RESET}"}
+  RED    = lambda {|s| "#{ESC}[1;31m#{s}#{RESET}"}
+  YELLOW = lambda {|s| "#{ESC}[1;33m#{s}#{RESET}"}
+  BOLD   = lambda {|s| "#{ESC}[1m#{s}#{RESET}"}
+  
+  class Command
+    attr_accessor :source, :destination, :options
+
+    def initialize options
+      $verbose = options[:debug]
+      @source = options[:source]
+      @destination = (options[:destination] || options[:source]).gsub /\.(less|lss)/, '.css'
+      @options = options
+    end
+
+    def watch?()    @options[:watch]    end
+    def compress?() @options[:compress] end
+    def debug?()    @options[:debug]    end
+
+    # little function which allows us to
+    # Ctrl-C exit inside the passed block
+    def watch
+      begin
+        yield
+      rescue Interrupt
+        puts
+        exit 0
+      end
+    end
+
+    def run!
+      parse(true) unless File.exist? @destination
+
+      if watch?
+        log "Watching for changes in #@source... Ctrl-C to abort.\n: "
+
+        # Main watch loop
+        loop do
+          watch { sleep 1 }
+
+          # File has changed
+          if File.stat( @source ).mtime > File.stat( @destination ).mtime
+            print "Change detected... "
+
+            # Loop until error is fixed
+            until parse
+              log "Press [return] to continue..."
+              watch { $stdin.gets }
+            end
+          end
+        end
+      else
+        parse
+      end
+    end
+
+    def parse new = false
+      begin
+        # Create a new Less object with the contents of a file
+        css = Less::Engine.new(File.new(@source)).to_css
+        css = css.delete " \n" if compress?
+
+        File.open( @destination, "w" ) do |file|
+          file.write css
+        end
+        print "#{GREEN['* ' + (new ? 'Created'  : 'Updated')]} " + 
+              "#{@destination.split('/').last}\n: " if watch?
+      rescue Errno::ENOENT => e
+        abort "#{e}"
+      rescue SyntaxError => e
+        err "#{e}\n", "Syntax"
+      rescue MixedUnitsError => e
+        err "`#{e}` you're  mixing units together! What do you expect?\n"
+      rescue PathError => e
+        err "`#{e}` was not found.\n", "Path"
+      rescue VariableNameError => e
+        err "#{YELLOW[e]} is undefined.\n", "Name"
+      rescue MixinNameError => e
+        err "#{YELLOW[e]} is undefined.\n", "Name"
+      else
+        true
+      end
+    end
+
+    # Just a logging function to avoid typing '*'
+    def log s = ''
+      print '* ' + s.to_s
+    end
+
+    def err s = '', type = ''
+      type = type.strip + ' ' unless type.empty?
+      print "#{RED["! #{type}Error"]}: #{s}"
+      if @options[:growl]
+        growl = Growl.new
+        growl.title = "LESS"
+        growl.message = "#{type}Error in #@source!"
+        growl.run
+        false
+      end
+    end
+  end
+end

data/lib/less/engine.rb

@@ -0,0 +1,54 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'engine/builder'
+require 'engine/nodes'
+
+begin
+  require 'engine/parser'
+rescue LoadError
+  Treetop.load File.join(LESS_GRAMMAR, 'common.tt')
+  Treetop.load File.join(LESS_GRAMMAR, 'entity.tt')
+  Treetop.load File.join(LESS_GRAMMAR, 'less.tt')
+end
+
+module Less
+  class Engine
+    attr_reader :css, :less
+    
+    def initialize obj
+      @less = if obj.is_a? File
+        @path = File.dirname File.expand_path(obj.path)
+        obj.read
+      elsif obj.is_a? String
+        obj.dup
+      else
+        raise ArgumentError, "argument must be an instance of File or String!"
+      end
+      
+      @parser = StyleSheetParser.new
+    end
+    
+    def parse build = true, env = Node::Element.new
+      root = @parser.parse(self.prepare)
+      
+      return root unless build
+      
+      if root
+        @tree = root.build env.tap {|e| e.file = @path }
+      else
+        raise SyntaxError, @parser.failure_message
+      end
+
+      @tree
+    end
+    alias :to_tree :parse
+    
+    def to_css
+      @css || @css = self.parse.group.to_css
+    end
+    
+    def prepare
+      @less.gsub(/\r\n/, "\n").gsub(/\t/, '  ')
+    end
+  end
+end

data/lib/less/engine/builder.rb

@@ -0,0 +1,8 @@
+module Builder
+  def build env = Less::Element.new
+    elements.map do |e|
+      e.build env if e.respond_to? :build
+    end
+    env
+  end
+end

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

@@ -0,0 +1,29 @@
+module Less
+  module StyleSheet
+    grammar Common
+      #
+      # Whitespace
+      #
+      rule s
+        [ ]*
+      end
+
+      rule S
+        [ ]+
+      end
+
+      rule ws
+        [\n ]*
+      end
+
+      rule WS
+        [\n ]+
+      end
+
+      # Non-space char
+      rule ns
+        ![ ;\n] .
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+module Less
+  module StyleSheet
+    grammar Entity
+      #
+      # Entity: Any whitespace delimited token
+      #
+      rule entity
+        function / fonts / keyword / accessor / variable / literal / important
+      end
+
+      rule fonts
+        font family:(s ',' s font)+ {
+          def build
+            Node::FontFamily.new(all.map(&:build))
+          end
+
+          def all
+            [font] + family.elements.map {|f| f.font }
+          end
+        }
+      end
+
+      rule font
+        [a-zA-Z] [-a-zA-Z0-9]* {
+          def build
+            Node::Keyword.new(text_value)
+          end
+        } / string {
+          def build
+            Node::String.new(text_value)
+          end
+        }
+      end
+      
+      #
+      # Tokens which don't need to be evaluated
+      #
+      rule literal
+        color / (dimension / [-a-z]+) '/' dimension {
+          def build
+            Node::Anonymous.new(text_value)
+          end
+        } / number unit {
+          def build
+            Node::Number.new(number.text_value, unit.text_value)
+          end
+        } / string {
+          def build
+            Node::String.new(text_value)
+          end
+        }
+      end
+
+      # !important
+      rule important
+        '!important' {
+          def build
+            Node::Keyword.new(text_value)
+          end
+        }
+      end
+
+      #
+      # `blue`, `small`, `normal` etc.
+      #
+      rule keyword
+        [-a-zA-Z]+ !ns {
+          def build
+            Node::Keyword.new(text_value)
+          end
+        }
+      end
+
+      #
+      # 'hello world' / "hello world"
+      #
+      rule string
+        "'" content:(!"'" . )* "'" {
+          def value
+            content.text_value
+          end
+        } / ["] content:(!["] . )* ["] {
+          def value
+            content.text_value
+          end
+        }
+      end
+
+      #
+      # Numbers & Units
+      #
+      rule dimension
+        number unit
+      end
+
+      rule number
+        '-'? [0-9]* '.' [0-9]+ / '-'? [0-9]+
+      end
+
+      rule unit
+        ('px'/'em'/'pc'/'%'/'ex'/'pt'/'cm'/'mm')?
+      end
+
+      #
+      # Color
+      #
+      rule color
+        '#' rgb {
+          def build
+            Node::Color.new(*rgb.build)
+          end
+        } / fn:(('hsl'/'rgb') 'a'?) arguments {
+          def build
+            Node::Function.new(fn.text_value, arguments.build.flatten)
+          end
+        }
+      end
+
+      #
+      # 00ffdd / 0fd
+      #
+      rule rgb
+        r:(hex hex) g:(hex hex) b:(hex hex) {
+          def build
+            [r.text_value, g.text_value, b.text_value]
+          end
+        } / r:hex g:hex b:hex {
+          def build
+            [r.text_value, g.text_value, b.text_value].map {|c| c * 2 }
+          end
+        }
+      end
+
+      rule hex
+        [a-fA-F0-9]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,271 @@
+module Less
+  grammar StyleSheet
+    include Common
+    include Entity
+    
+    rule primary
+      (declaration / ruleset / import / comment)+ <Builder> / declaration* <Builder> / import* <Builder> / comment*
+    end
+
+    rule comment
+      ws '/*' (!'*/' . )* '*/' ws / ws '//' (!"\n" .)* "\n" ws
+    end
+
+    #
+    # div, .class, body > p {...}
+    #
+    rule ruleset
+      selectors "{" ws primary ws "}" ws {
+        def build env
+          # Build the ruleset for each selector
+          selectors.build(env, :ruleset).each do |sel|
+            primary.build sel
+          end
+        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, path.join
+            end.rules
+            env.rules += rules
+          end
+        end
+      }
+    end
+
+    rule import
+      "@import" S url:(string / url) medias? s ';' ws {
+        def build env
+          path = File.join(env.root.file, url.value)
+          path += '.less' unless path =~ /\.(le|c)ss$/
+          if File.exist? path
+            imported = Less::Engine.new(File.new(path)).to_tree
+            env.rules += imported.rules
+          else
+            raise ImportError, path
+          end
+        end
+      }
+    end
+
+    rule url
+      'url(' path:(string / [-a-zA-Z0-9_%$/.&=:;#+?]+) ')' {
+        def build env = nil
+          Node::String.new CGI.unescape(path.text_value)
+        end
+    
+        def value
+          build
+        end
+      }
+    end
+
+    rule medias
+      [-a-z]+ (s ',' s [a-z]+)*
+    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)+ arguments? {
+        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
+
+    #
+    # @my-var: 12px;
+    # height: 100%;
+    #
+    rule declaration
+      ws name:(ident / variable) s ':' s expressions s (';'/ ws &'}') ws {
+        def build env
+          env << (name.text_value =~ /^@/ ? 
+            Node::Variable : Node::Property).new(name.text_value, expressions.build(env), env)
+        end
+      # Empty rule
+      } / ws ident s ':' s ';' ws
+    end
+
+    #
+    # An operation or compound value
+    #
+    rule expressions
+      # Operation
+      expression tail:(operator expression)+ {
+        def build env 
+          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)* {
+        def build env
+          all.map {|e| e.build(env) if e.respond_to? :build }.compact
+        end
+        
+        def all
+          [expression] + tail.elements.map {|f| f.expression }
+        end
+      } 
+    end
+
+    rule expression
+      '(' s expressions s ')' {
+        def build env
+          Node::Expression.new(['('] + expressions.build(env).flatten + [')'])
+        end
+      } / entity '' {
+        def build env
+          entity.method(:build).arity.zero?? entity.build : entity.build(env)
+        end
+      }
+    end
+
+    #
+    # An identifier
+    #
+    rule ident
+      '*'? '-'? [-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* ('(' ident? attribute* ')')? / attribute+ / '@media' / '@font-face'
+    end
+
+    rule class_id
+      tag? (class / id)+
+    end
+
+    #
+    # [type="text"]
+    #
+    rule attribute
+      '[' tag ([|~*$^]? '=') (tag / string) ']' / '[' (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].flatten)
+        end
+      }
+    end
+
+    rule arguments
+      '(' s argument s tail:(',' s argument s)* ')' {
+        def build
+          all.map do |e|
+            e.build if e.respond_to? :build
+          end.compact
+        end
+  
+        def all
+          [argument] + tail.elements.map {|e| e.argument }
+        end
+      }
+    end
+
+    rule argument
+      color / number unit {
+        def build
+          Node::Number.new number.text_value, unit.text_value
+        end
+      } / string {
+        def build
+          Node::String.new text_value
+        end
+      } / [a-zA-Z]+ '=' dimension {
+        def build
+          Node::Anonymous.new text_value
+        end
+      } / [-a-zA-Z0-9_%$/.&=:;#+?]+ {
+        def build
+          Node::String.new text_value
+        end
+      } / function / keyword other:(S keyword)* {
+        def build
+        end
+      }
+    end
+  end
+end