less 1.2.21 → 2.0.0

data/CHANGELOG

@@ -1,62 +0,0 @@
-1.1.6
-	- hsl() fix
-1.1.5
-	- rgb() fix
-1.1.4
-	- support for uppercase ids and classes
-	- `ex` support
-	- fixed ruby 1.8 from outputting ascii numbers in the CLI
-1.1.3
-	- fix to Growl messages
-	- better benchmark task output
-1.1.2
-	- full parens support
-	- don't raise an exception if growlnotify wasn't found
-1.1.1
-	- added title to Growl notifications
-1.1.0
-	- added color to command line output
-	- added Growl support
-1.0.16
-	- basic support for parens
-	- support for operations in shorthand properties
-1.0.15
-	- moved to treetop 1.3.0
-	- fixed benchmark task
-1.0.14
-	- support for `*property:` hack
-1.0.13
-	- importing .css files now works
-1.0.12
-	- basic selector grouping for better output
-	- evaluate variables lazily
-	- support for values starting with `-`
-1.0.11
-	- ruby 1.8 compatibility fix
-1.0.10
-	- additional support for css 3
-1.0.9
-	- overhauled color support & operations
-	- better handling of css 3 selectors
-1.0.8
-	- support for rgba
-	- fixed color expansion
-	- fixed new-line error in declarations
-	- fixed attriute selector without element name error
-1.0.6
-	- fixed grammar for .class#id
-	- fixed color padding issue
-1.0.5
-	- added attribute selectors (accessors)
-	- semi-column at end of ruleset now works
-1.0.4
-	- removed dependency on polyglot gem
-	- fixed a moz hack not compiling
-1.0.3
-	- fixed problem with floats repeating unit twice
-1.0.2
-	- added support for url() without quotes
-1.0.1
-	- pulled some patches from jgarber's treetop
-1.0.0
-	- initial release

data/VERSION

@@ -1 +0,0 @@
-1.2.21

data/lib/less/command.rb

@@ -1,110 +0,0 @@
-module Less
-  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
-      @mutter = Mutter.new.clear
-    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!
-      if watch?
-        parse(true) unless File.exist? @destination
-
-        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 Time.now.strftime("%H:%M:%S -- ") if @options[:timestamps]
-            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), @options).to_css
-        css = css.delete " \n" if compress?
-
-        File.open( @destination, "w" ) do |file|
-          file.write css
-        end
-
-        act, file = (new ? 'Created' : 'Updated'), @destination.split('/').last
-        print "#{o("* #{act}", :green)} #{file}\n: " if watch?
-        Growl.notify "#{act} #{file}", :title => 'LESS' if @options[:growl] && @options[:verbose]
-      rescue Errno::ENOENT => e
-        abort "#{e}"
-      rescue SyntaxError => e
-        err "#{e}\n", "Syntax"
-      rescue CompileError => e
-        err "#{e}\n", "Compile"
-      rescue MixedUnitsError => e
-        err "`#{e}` you're  mixing units together! What do you expect?\n", "Mixed Units"
-      rescue PathError => e
-        err "`#{e}` was not found.\n", "Path"
-      rescue VariableNameError => e
-        err "#{o(e, :yellow)} is undefined.\n", "Variable Name"
-      rescue MixinNameError => e
-        err "#{o(e, :yellow)} is undefined.\n", "Mixin 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?
-      $stderr.print "#{o("! #{type}Error", :red)}: #{s}"
-      if @options[:growl]
-        growl = Growl.new
-        growl.title = "LESS"
-        growl.message = "#{type}Error in #@source!"
-        growl.run
-        false
-      end
-    end
-
-  private
-
-    def o ex, *styles
-      @mutter.process(ex.to_s, *(@options[:color] ? styles : []))
-    end
-  end
-end

data/lib/less/engine.rb

@@ -1,52 +0,0 @@
-$:.unshift File.dirname(__FILE__)
-
-require 'engine/nodes'
-
-begin
-  require 'engine/parser'
-rescue LoadError
-  Treetop.load File.join(LESS_GRAMMAR, 'less.tt')
-end
-
-module Less
-  class Engine
-    attr_reader :css, :less
-
-    def initialize obj, options = {}
-      @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
-
-      @options = options
-      @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(@options[:color])
-      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/grammar/common.tt

@@ -1,29 +0,0 @@
-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

@@ -1,144 +0,0 @@
-require 'grammar/common'
-
-module Less
-  module StyleSheet
-    grammar Entity
-      #
-      # Entity: Any whitespace delimited token
-      #
-      rule entity
-        url / alpha / function / accessor / keyword / variable / literal / font
-      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]* !ns {
-          def build
-            Node::Keyword.new(text_value)
-          end
-        } / string {
-          def build
-            Node::Quoted.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::Quoted.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'/'in'/'deg'/'s'/'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
-
-      #
-      # Special case for IE alpha filter
-      #
-      rule alpha
-        "alpha" '(' "opacity=" variable ')' {
-          def build env
-            var = variable.text_value
-            Node::Quoted.new(text_value.sub(var, env.nearest(var).evaluate.to_i.to_s))
-          end
-        }
-      end
-    end
-  end
-end

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

@@ -1,341 +0,0 @@
-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