cloudhead-less 0.8.12 → 1.0.0

data/README.md

@@ -27,4 +27,13 @@ LESS allows you to write CSS the way (I think) it was meant to, that is: with *v
 If you have CSS nightmares, just 
 	$ lessc style.less
 
-For more information, see you at http://lesscss.org
+For more information, see you at [http://lesscss.org]
+
+People without whom this wouldn't have happened a.k.a *Credits*
+---------------------------------------------------------------
+
+- **Dmitry Fadeyev**, for pushing me to do this, and designing our awesome website
+- **August Lilleaas**, for initiating the work on the treetop grammar, as well as writing the rails plugin
+- **Nathan Sobo**, for creating treetop
+- **Jason Garber**, for his magical performance optimizations on treetop
+- And finally, the people of #ruby-lang for answering all my ruby questions. **apeiros**, **manveru** and **rue** come to mind

data/Rakefile

@@ -3,7 +3,7 @@ begin
   Jeweler::Tasks.new do |s|
     s.name        = "less"
     s.authors     = ["cloudhead"]
-    s.email       = "alexis@cloudhead.net"
+    s.email       = "self@cloudhead.net"
     s.summary     = "LESS compiler"
     s.homepage    = "http://www.lesscss.org"
     s.description = "LESS is leaner CSS"
@@ -58,4 +58,23 @@ begin
     t.rcov = true
     t.rcov_opts = ['--exclude', '^spec,/gems/']
   end
-end
+end
+
+begin
+  require 'lib/less'
+  
+  task :compile do
+    puts "compiling #{Less::GRAMMAR}..."
+    File.open(Less::PARSER, 'w') {|f| f.write Treetop::Compiler::GrammarCompiler.new.ruby_source(Less::GRAMMAR) }
+  end
+  
+  task :benchmark do
+    puts "benchmarking..."
+    less = File.read("spec/less/big-1.0.less")
+    start = Time.now.to_f
+    Less::Engine.new(less).parse
+    total = Time.now.to_f - start
+    puts "total time: #{total}s"
+  end
+end
+

data/VERSION

@@ -1 +1 @@
-0.8.12
+1.0.0

data/bin/lessc

@@ -5,14 +5,11 @@ $:.unshift File.dirname(__FILE__) + "/../lib"
 require 'optparse'
 require 'less'
 
-CSS = '.css'
-
 # Argument defaults
 options = {
   :watch => false,
   :compress => false,
   :debug => false,
-  :inheritance => :desc
 }
 
 # Get arguments
@@ -25,11 +22,6 @@ opts = OptionParser.new do |o|
     options[:watch] = true
   end
   
-  # Child-type inheritance
-  o.on("-c", "--child", "nesting uses child-type inheritance") do
-    options[:chain] = :child
-  end
-  
   # Compression needs a proper algorithm
   #
   #  o.on("-x", "--compress", "compress css file") do

data/less.gemspec

@@ -2,14 +2,14 @@
 
 Gem::Specification.new do |s|
   s.name = %q{less}
-  s.version = "0.8.12"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["cloudhead"]
-  s.date = %q{2009-06-21}
+  s.date = %q{2009-07-08}
   s.default_executable = %q{lessc}
   s.description = %q{LESS is leaner CSS}
-  s.email = %q{alexis@cloudhead.net}
+  s.email = %q{self@cloudhead.net}
   s.executables = ["lessc"]
   s.extra_rdoc_files = [
     "LICENSE",
@@ -26,20 +26,54 @@ Gem::Specification.new do |s|
      "lib/less.rb",
      "lib/less/command.rb",
      "lib/less/engine.rb",
-     "lib/less/tree.rb",
+     "lib/less/engine/builder.rb",
+     "lib/less/engine/less.tt",
+     "lib/less/engine/nodes.rb",
+     "lib/less/engine/nodes/element.rb",
+     "lib/less/engine/nodes/entity.rb",
+     "lib/less/engine/nodes/function.rb",
+     "lib/less/engine/nodes/literal.rb",
+     "lib/less/engine/nodes/property.rb",
+     "lib/less/engine/nodes/selector.rb",
+     "lib/less/engine/parser.rb",
      "spec/command_spec.rb",
-     "spec/css/less-0.8.10.css",
-     "spec/css/less-0.8.11.css",
-     "spec/css/less-0.8.12.css",
-     "spec/css/less-0.8.5.css",
-     "spec/css/less-0.8.6.css",
-     "spec/css/less-0.8.7.css",
-     "spec/css/less-0.8.8.css",
+     "spec/css/accessors-1.0.css",
+     "spec/css/big-1.0.css",
+     "spec/css/comments-1.0.css",
+     "spec/css/css-1.0.css",
+     "spec/css/functions-1.0.css",
+     "spec/css/import-1.0.css",
+     "spec/css/mixins-1.0.css",
+     "spec/css/operations-1.0.css",
+     "spec/css/rulesets-1.0.css",
+     "spec/css/scope-1.0.css",
+     "spec/css/strings-1.0.css",
+     "spec/css/variables-1.0.css",
+     "spec/css/whitespace-1.0.css",
      "spec/engine_spec.rb",
+     "spec/less/accessors-1.0.less",
+     "spec/less/big-1.0.less",
+     "spec/less/colors-1.0.less",
+     "spec/less/comments-1.0.less",
+     "spec/less/css-1.0.less",
+     "spec/less/exceptions/mixed-units-error.less",
+     "spec/less/exceptions/name-error-1.0.less",
+     "spec/less/exceptions/syntax-error-1.0.less",
+     "spec/less/functions-1.0.less",
+     "spec/less/import-1.0.less",
+     "spec/less/import/import-test-a.less",
+     "spec/less/import/import-test-b.less",
+     "spec/less/import/import-test-c.less",
+     "spec/less/mixins-1.0.less",
+     "spec/less/operations-1.0.less",
+     "spec/less/rulesets-1.0.less",
+     "spec/less/scope-1.0.less",
+     "spec/less/strings-1.0.less",
+     "spec/less/variables-1.0.less",
+     "spec/less/whitespace-1.0.less",
      "spec/spec.css",
      "spec/spec.less",
-     "spec/spec_helper.rb",
-     "spec/tree_spec.rb"
+     "spec/spec_helper.rb"
   ]
   s.has_rdoc = true
   s.homepage = %q{http://www.lesscss.org}
@@ -51,8 +85,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/command_spec.rb",
      "spec/engine_spec.rb",
-     "spec/spec_helper.rb",
-     "spec/tree_spec.rb"
+     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/less/command.rb

@@ -1,12 +1,11 @@
 module Less
   class Command
-    CSS = '.css'
-
     attr_accessor :source, :destination, :options
 
     def initialize options
+      $verbose = options[:debug]
       @source = options[:source]
-      @destination = (options[:destination] || options[:source]).gsub /\.(less|lss)/, CSS
+      @destination = (options[:destination] || options[:source]).gsub /\.(less|lss)/, '.css'
       @options = options
     end
 
@@ -16,9 +15,9 @@ module Less
 
     # little function which allows us to
     # Ctrl-C exit inside the passed block
-    def watch &block
+    def watch
       begin
-        block.call
+        yield
       rescue Interrupt
         puts
         exit 0
@@ -26,10 +25,10 @@ module Less
     end
 
     def run!
-      compile(true) unless File.exist? @destination
+      parse(true) unless File.exist? @destination
 
       if watch?
-        log "Watching for changes in #@source ...Ctrl-C to abort.\n"
+        log "Watching for changes in #@source... Ctrl-C to abort.\n: "
 
         # Main watch loop
         loop do
@@ -37,55 +36,55 @@ module Less
 
           # File has changed
           if File.stat( @source ).mtime > File.stat( @destination ).mtime
-            log "Change detected... "
+            print "Change detected... "
 
             # Loop until error is fixed
-            until compile
-              log "Press [enter] to continue..."
+            until parse
+              log "Press [return] to continue..."
               watch { $stdin.gets }
             end
           end
         end
       else
-        compile
+        parse
       end
     end
 
-    def compile new = false
+    def parse new = false
       begin
         # Create a new Less object with the contents of a file
-        css = Less::Engine.new( File.read( @source ) ).to_css @options[:inheritance]
+        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
-        puts "#{new ? '* [Created]' : ' [Updated]'} #{@destination.split('/').last}" if watch?
+        print "#{new ? '* [Created]' : '* [Updated]'} #{@destination.split('/').last}\n: " if watch?
       rescue Errno::ENOENT => e
         abort "#{e}"
-      rescue SyntaxError
-        error = debug?? $! : $!.message.split("\n")[1..-1].collect {|e|
-          e.gsub(/\(eval\)\:(\d+)\:\s/, 'line \1: ')
-        } * "\n"
-        err "errors were found in the .less file! \n#{error}\n"
+      rescue SyntaxError => e
+        err "#{e}\n", "Parse"
       rescue MixedUnitsError => e
         err "`#{e}` you're  mixing units together! What do you expect?\n"
-      rescue CompoundOperationError => e
-        err "`#{e}` operations in compound declarations aren't allowed, sorry!\n"
       rescue PathError => e
-        err "`#{e}` was not found.\n"
+        err "`#{e}` was not found.\n", "Path"
+      rescue VariableNameError => e
+        err "`#{e}` is undefined.\n", "Name"
+      rescue MixinNameError => e
+        err "`#{e}` is undefined.\n", "Name"
       else
         true
       end
     end
 
-    # Just a logging function to avoid typing '}'
+    # Just a logging function to avoid typing '*'
     def log s = ''
       print '* ' + s.to_s
     end
 
-    def err s = ''
-      print "!! #{s}"
+    def err s = '', type = ''
+      type = type.strip + ' ' unless type.empty?
+      print "! [#{type}Error] #{s}"
     end
   end
 end

data/lib/less/engine/builder.rb

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

data/lib/less/engine/less.tt

@@ -0,0 +1,379 @@
+grammar Less
+  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, :tree).each do |sel|
+          primary.build sel
+        end
+      end
+    } / ws selectors ';' ws {
+      def build env        
+        log "[mixin]: #{selectors.text_value}"
+        selectors.build(env, :path).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 =~ /\.less$/
+        if File.exist? path
+          log "\nimporting #{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
+    (s select element s)+ {
+      def tree env
+        log "\n% element: #{text_value}\n"
+        elements.inject(env) do |node, e|
+          node << Node::Element.new(e.element.text_value, e.select.text_value)
+          node.last
+        end
+      end
+      
+      def path env
+        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 expression s (';'/ ws &'}') ws {
+      def build env
+        env << (name.text_value =~ /^@/ ? Node::Variable : Node::Property).new(name.text_value)
+        expression.build env
+      end
+    # Empty rule
+    } / ws ident s ':' s ';' ws
+  end
+  
+  #
+  # An operation or compound value
+  #
+  rule expression
+    entity (operator / S) expression <Builder> / entity
+  end
+  
+  #
+  # Entity: Any whitespace delimited token
+  #
+  rule entity
+    function / fonts / keyword / accessor / variable / literal / important
+  end
+  
+  rule fonts
+    font family:(s ',' s font)+ {
+      def build env
+        fonts = ([font] + family.elements.map {|f| f.font }).map do |font|
+          font.build env
+        end
+        env.identifiers.last << Node::FontFamily.new(fonts)
+      end
+    }
+  end
+  
+  rule font
+    [a-zA-Z] [-a-zA-Z0-9]* {
+      def build env
+        Node::Keyword.new(text_value)
+      end
+    } / string {
+      def build env
+        Node::String.new(text_value)
+      end
+    }
+  end
+  
+  #
+  # An identifier
+  #
+  rule ident
+    '-'? [-a-z0-9_]+
+  end
+  
+  rule variable
+    '@' [-a-zA-Z0-9_]+  {
+      def build env
+        env.identifiers.last << env.nearest(text_value)
+      end
+    }
+  end
+  
+  #
+  # div / .class / #id / input[type="text"] / lang(fr)
+  #
+  rule element
+    (class_id / tag) attribute* ('(' ident ')')? / '@media' / '@font-face'
+  end
+  
+  rule class_id
+    tag? class+ / tag? id
+  end
+  
+  #
+  # [type="text"]
+  #
+  rule attribute
+    '[' [a-z]+ ([|~]? '=')? (tag / string) ']'
+  end
+  
+  rule class
+    '.' [_a-z] [-a-zA-Z0-9_]*
+  end
+  
+  rule id
+    '#' [_a-z] [-a-zA-Z0-9_]*
+  end
+  
+  rule tag
+    [a-zA-Z] [-a-zA-Z]* [0-9]? / '*'
+  end
+  
+  rule select
+    (s [:+>] s / S)?
+  end
+  
+  # TODO: Merge this with attribute rule
+  rule accessor
+    ident:(class_id / tag) '[' attr:(string / variable) ']' {
+      def build env
+        env.identifiers.last << env.nearest(ident.text_value)[attr.text_value.delete(%q["'])].evaluate
+      end
+    }
+  end
+  
+  rule operator
+    S op:([-+*/]) S {
+      def build env
+        env.identifiers.last << Node::Operator.new(op.text_value)
+      end
+    } / [-+*/] {
+      def build env
+        env.identifiers.last << Node::Operator.new(text_value)
+      end
+    }
+  end
+  
+  #
+  # Tokens which don't need to be evaluated
+  #
+  rule literal
+    color / (dimension / [-a-z]+) '/' dimension {
+      def build env
+        env.identifiers.last << Node::Anonymous.new(text_value)
+      end
+    } / number unit {
+      def build env
+        env.identifiers.last << Node::Number.new(number.text_value, unit.text_value)
+      end
+    } / string {
+      def build env
+        env.identifiers.last << Node::String.new(text_value)
+      end
+    }
+  end
+  
+  # !important
+  rule important
+    '!important' {
+      def build env
+        env.identifiers.last << Node::Keyword.new(text_value)
+      end
+    }
+  end
+  
+  rule empty
+    "" <Empty>
+  end
+  
+  #
+  # `blue`, `small`, `normal` etc.
+  #
+  rule keyword
+    [a-zA-Z] [-a-zA-Z]* !ns {
+      def build env
+        env.identifiers.last << 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'/'%'/'pt'/'cm'/'mm')?
+  end
+
+  
+  #
+  # Color
+  #
+  rule color
+    '#' hex {
+      def build env
+        env.identifiers.last << Node::Color.new(hex.text_value)
+      end
+    } / fn:(('hsl'/'rgb') 'a'?) '(' arguments ')' {
+      def build env
+        args = arguments.build env
+        env.identifiers.last << Node::Function.new(fn.text_value, args.flatten)
+      end
+    }
+  end
+  
+  rule hex
+    [a-fA-F0-9] [a-fA-F0-9] [a-fA-F0-9]+
+  end
+  
+  #
+  # Functions and arguments
+  #
+  rule function
+    name:([-a-zA-Z_]+) '(' arguments ')' {
+      def build env
+        args = arguments.build env
+        env.identifiers.last << Node::Function.new(name.text_value, [args].flatten)
+      end
+    }
+  end
+  
+  rule arguments
+    argument s ',' s arguments {
+      def build env
+        elements.map do |e|
+          e.build env if e.respond_to? :build
+        end.compact
+      end
+    } / argument
+  end
+  
+  rule argument
+    color {
+      def build env
+        Node::Color.new text_value
+      end
+    } / number unit {
+      def build env
+        Node::Number.new number.text_value, unit.text_value
+      end
+    } / string {
+      def build env
+        Node::String.new text_value
+      end
+    } / [a-zA-Z]+ '=' dimension {
+      def build env
+        Node::Anonymous.new text_value
+      end
+    }
+  end
+  
+  #
+  # Whitespace
+  #
+  rule s
+    [ ]*
+  end
+  
+  rule S
+    [ ]+
+  end
+  
+  rule ws
+    [\n ]*
+  end
+  
+  # Non-space char
+  rule ns
+    ![ ;] .
+  end
+end