haml 1.8.0 → 2.0.0

data/lib/sass/constant/color.rb

@@ -21,9 +21,9 @@ module Sass::Constant # :nodoc:
       'teal'    => 0x008080,
       'aqua'    => 0x00ffff
     }
-  
+
     REGEXP = /\##{"([0-9a-fA-F]{1,2})" * 3}/
-  
+
     def parse(value)
       if (value =~ REGEXP)
         @value = value.scan(REGEXP)[0].map { |num| num.ljust(2, num).to_i(16) }
@@ -32,7 +32,7 @@ module Sass::Constant # :nodoc:
         @value = (0..2).map{ |n| color >> (n << 3) & 0xff }.reverse
       end
     end
-    
+
     def plus(other)
       if other.is_a? Sass::Constant::String
         Sass::Constant::String.from_value(self.to_s + other.to_s)
@@ -40,7 +40,7 @@ module Sass::Constant # :nodoc:
         piecewise(other, :+)
       end
     end
-    
+
     def minus(other)
       if other.is_a? Sass::Constant::String
         raise NoMethodError.new(nil, :minus)
@@ -48,7 +48,7 @@ module Sass::Constant # :nodoc:
         piecewise(other, :-)
       end
     end
-    
+
     def times(other)
       if other.is_a? Sass::Constant::String
         raise NoMethodError.new(nil, :times)
@@ -56,7 +56,7 @@ module Sass::Constant # :nodoc:
         piecewise(other, :*)
       end
     end
-    
+
     def div(other)
       if other.is_a? Sass::Constant::String
         raise NoMethodError.new(nil, :div)
@@ -64,7 +64,7 @@ module Sass::Constant # :nodoc:
         piecewise(other, :/)
       end
     end
-    
+
     def mod(other)
       if other.is_a? Sass::Constant::String
         raise NoMethodError.new(nil, :mod)
@@ -72,24 +72,24 @@ module Sass::Constant # :nodoc:
         piecewise(other, :%)
       end
     end
-    
+
     def to_s
       red, green, blue = @value.map { |num| num.to_s(16).rjust(2, '0') }
       "##{red}#{green}#{blue}"
     end
-    
+
     protected
-    
+
     def self.filter_value(value)
       value.map { |num| num.to_i }
     end
-    
+
     private
-    
+
     def piecewise(other, operation)
       other_num = other.is_a? Number
       other_val = other.value
-    
+
       rgb = []
       for i in (0...3)
         res = @value[i].send(operation, other_num ? other_val : other_val[i])

data/lib/sass/constant/literal.rb

@@ -13,7 +13,7 @@ class Sass::Constant::Literal # :nodoc:
 
   # The regular expression matching colors.
   COLOR = /^\# (?: [\da-f]{3} | [\da-f]{6} ) | #{html_color_matcher}/ix
-  
+
   def self.parse(value)
     case value
     when NUMBER
@@ -24,11 +24,11 @@ class Sass::Constant::Literal # :nodoc:
       Sass::Constant::String.new(value)
     end
   end
-  
+
   def initialize(value = nil)
     self.parse(value) if value
   end
-  
+
   def perform
     self
   end
@@ -36,15 +36,15 @@ class Sass::Constant::Literal # :nodoc:
   def concat(other)
     Sass::Constant::String.from_value("#{self.to_s} #{other.to_s}")
   end
-  
+
   attr_reader :value
-  
+
   protected
-  
+
   def self.filter_value(value)
     value
   end
-  
+
   def self.from_value(value)
     instance = self.new
     instance.instance_variable_set('@value', self.filter_value(value))

data/lib/sass/constant/number.rb

@@ -10,7 +10,7 @@ module Sass::Constant  # :nodoc:
       @value = first.empty? ? second.to_i : "#{first}#{second}".to_f
       @unit = unit unless unit.empty?
     end
-    
+
     def plus(other)
       if other.is_a? Number
         operate(other, :+)
@@ -20,7 +20,7 @@ module Sass::Constant  # :nodoc:
         Sass::Constant::String.from_value(self.to_s + other.to_s)
       end
     end
-    
+
     def minus(other)
       if other.is_a? Number
         operate(other, :-)
@@ -28,7 +28,7 @@ module Sass::Constant  # :nodoc:
         raise NoMethodError.new(nil, :minus)
       end
     end
-    
+
     def times(other)
       if other.is_a? Number
         operate(other, :*)
@@ -38,7 +38,7 @@ module Sass::Constant  # :nodoc:
         raise NoMethodError.new(nil, :times)
       end
     end
-    
+
     def div(other)
       if other.is_a? Number
         operate(other, :/)
@@ -46,7 +46,7 @@ module Sass::Constant  # :nodoc:
         raise NoMethodError.new(nil, :div)
       end
     end
-    
+
     def mod(other)
       if other.is_a? Number
         operate(other, :%)
@@ -54,13 +54,13 @@ module Sass::Constant  # :nodoc:
         raise NoMethodError.new(nil, :mod)
       end
     end
-    
+
     def to_s
       value = @value
       value = value.to_i if value % 1 == 0.0
       "#{value}#{@unit}"
     end
-    
+
     protected
 
     def self.from_value(value, unit=nil)
@@ -68,7 +68,7 @@ module Sass::Constant  # :nodoc:
       instance.instance_variable_set('@unit', unit)
       instance
     end
-    
+
     def operate(other, operation)
       unit = nil
       if other.unit.nil?
@@ -78,7 +78,7 @@ module Sass::Constant  # :nodoc:
       elsif other.unit == self.unit
         unit = self.unit
       else
-        raise Sass::SyntaxError.new("Incompatible units: #{self.unit} and #{other.unit}")
+        raise Sass::SyntaxError.new("Incompatible units: #{self.unit} and #{other.unit}.")
       end
 
       Number.from_value(self.value.send(operation, other.value), unit)

data/lib/sass/constant/operation.rb

@@ -9,13 +9,13 @@ module Sass::Constant # :nodoc:
       @operand2 = operand2
       @operator = operator
     end
-    
+
     def to_s
       self.perform.to_s
     end
-    
+
     protected
-    
+
     def perform
       literal1 = @operand1.perform
       literal2 = @operand2.perform
@@ -23,7 +23,7 @@ module Sass::Constant # :nodoc:
         literal1.send(@operator, literal2)
       rescue NoMethodError => e
         raise e unless e.name.to_s == @operator.to_s
-        raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\"")
+        raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\".")
       end
     end
   end

data/lib/sass/constant/string.rb

@@ -2,11 +2,11 @@ require 'sass/constant/literal'
 
 module Sass::Constant # :nodoc:
   class String < Literal # :nodoc:
-    
+
     def parse(value)
       @value = value
     end
-    
+
     def plus(other)
       Sass::Constant::String.from_value(self.to_s + other.to_s)
     end
@@ -14,7 +14,7 @@ module Sass::Constant # :nodoc:
     def funcall(other)
       Sass::Constant::String.from_value("#{self.to_s}(#{other.to_s})")
     end
-    
+
     def to_s
       @value
     end

data/lib/sass/constant.rb

@@ -8,13 +8,13 @@ module Sass
 
     # Whitespace characters
     WHITESPACE = [?\ , ?\t, ?\n, ?\r]
-  
+
     # The character used to escape values
     ESCAPE_CHAR = ?\\
 
     # The character used to open and close strings
     STRING_CHAR = ?"
-    
+
     # A mapping of syntactically-significant characters
     # to parsed symbols
     SYMBOLS = {
@@ -31,14 +31,14 @@ module Sass
     }
 
     # The regular expression used to parse constants
-    MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }.join}]+)\s*=\s*(.+)/
-    
+    MATCH = /^#{Regexp.escape(CONSTANT_CHAR.chr)}([^\s#{(SYMBOLS.keys + [ ?= ]).map {|c| Regexp.escape("#{c.chr}") }.join}]+)\s*((?:\|\|)?=)\s*(.+)/
+
     # First-order operations
     FIRST_ORDER = [:times, :div, :mod]
-    
+
     # Second-order operations
     SECOND_ORDER = [:plus, :minus]
-  
+
     class << self
       def parse(value, constants, line)
         begin
@@ -46,28 +46,28 @@ module Sass
         rescue Sass::SyntaxError => e
           if e.message == "Constant arithmetic error"
             e.instance_eval do
-              @message += ": #{value.dump}"
+              @message += ": #{value.dump}."
             end
           end
           e.sass_line = line
           raise e
         end
       end
-      
+
       private
-      
+
       def tokenize(value)
         escaped = false
         is_string = false
         beginning_of_token = true
         str = ''
         to_return = []
-        
+
         reset_str = Proc.new do
           to_return << str unless str.empty?
           ''
         end
-        
+
         value.each_byte do |byte|
           unless escaped
             if byte == ESCAPE_CHAR
@@ -97,7 +97,7 @@ module Sass
                 str = reset_str.call
                 next
               end
-            
+
               symbol = SYMBOLS[byte]
 
               # Adjacent values without an operator should be concatenated
@@ -135,28 +135,28 @@ module Sass
               end
             end
           end
-          
+
           escaped = false
           beginning_of_token = false
           str << byte.chr
         end
-        
+
         if is_string
-          raise Sass::SyntaxError.new("Unterminated string: #{value.dump}")
+          raise Sass::SyntaxError.new("Unterminated string: #{value.dump}.")
         end
         str = reset_str.call
         to_return
       end
-      
+
       def parenthesize(value)
         parenthesize_helper(0, value, value.length)[0]
       end
-      
+
       def parenthesize_helper(i, value, value_len, return_after_expr = false)
         to_return = []
         beginning = i
         token = value[i]
-        
+
         while i < value_len && token != :close
           if token == :open
             to_return.push(*value[beginning...i])
@@ -194,13 +194,13 @@ module Sass
           else
             i += 1
           end
-          
+
           token = value[i]
         end
         to_return.push(*value[beginning...i])
         return to_return, i + 1
       end
-      
+
       #--
       # TODO: Don't pass around original value;
       #       have Constant.parse automatically add it to exception.
@@ -234,10 +234,10 @@ module Sass
           end
         end
       end
-      
+
       def get_constant(value, constants)
         to_return = constants[value]
-        raise SyntaxError.new("Undefined constant: \"!#{value}\"") unless to_return
+        raise SyntaxError.new("Undefined constant: \"!#{value}\".") unless to_return
         to_return
       end
     end

data/lib/sass/css.rb

@@ -6,11 +6,11 @@ module Sass
   # :stopdoc:
   module Tree
     class Node
-      def to_sass
+      def to_sass(opts = {})
         result = ''
 
         children.each do |child|
-          result << "#{child.to_sass(0)}\n"
+          result << "#{child.to_sass(0, opts)}\n"
         end
 
         result
@@ -24,11 +24,11 @@ module Sass
     end
 
     class RuleNode
-      def to_sass(tabs)
-        str = "#{'  ' * tabs}#{rule}\n"
+      def to_sass(tabs, opts = {})
+        str = "\n#{'  ' * tabs}#{rule}#{children.any? { |c| c.is_a? AttrNode } ? "\n" : ''}"
 
         children.each do |child|
-          str << "#{child.to_sass(tabs + 1)}"
+          str << "#{child.to_sass(tabs + 1, opts)}"
         end
 
         str
@@ -36,8 +36,8 @@ module Sass
     end
 
     class AttrNode
-      def to_sass(tabs)
-        "#{'  ' * tabs}:#{name} #{value}\n"
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{opts[:alternate] ? '' : ':'}#{name}#{opts[:alternate] ? ':' : ''} #{value}\n"
       end
     end
   end
@@ -46,25 +46,40 @@ module Sass
   # It keeps the semantics and most of the efficiency of normal hashes
   # while also keeping track of the order in which elements were set.
   class OrderedHash
-    Node = Struct.new('Node', :key, :value, :next)
+    Node = Struct.new(:key, :value, :next, :prev)
     include Enumerable
 
     def initialize
       @hash = {}
     end
 
+    def initialize_copy(other)
+      @hash = other.instance_variable_get('@hash').clone
+    end
+
     def [](key)
       @hash[key] && @hash[key].value
     end
 
     def []=(key, value)
-      node = Node.new(key, value, nil)
+      node = Node.new(key, value)
+
+      if old = @hash[key]
+        if old.prev
+          old.prev.next = old.next
+        else # old is @first and @last
+          @first = @last = nil
+        end
+      end
+
       if @first.nil?
         @first = @last = node
       else
+        node.prev = @last
         @last.next = node
         @last = node
       end
+
       @hash[key] = node
       value
     end
@@ -90,11 +105,12 @@ module Sass
 
     # Creates a new instance of Sass::CSS that will compile the given document
     # to a Sass string when +render+ is called.
-    def initialize(template)
+    def initialize(template, options = {})
       if template.is_a? IO
         template = template.read
       end
 
+      @options = options
       @template = StringScanner.new(template)
     end
 
@@ -102,10 +118,10 @@ module Sass
     # containing the CSS template.
     def render
       begin
-        build_tree.to_sass
+        build_tree.to_sass(@options).lstrip
       rescue Exception => err
         line = @template.string[0...@template.pos].split("\n").size
-        
+
         err.backtrace.unshift "(css):#{line}"
         raise err
       end
@@ -116,12 +132,13 @@ module Sass
     def build_tree
       root = Tree::Node.new(nil)
       whitespace
-      directives    root
-      rules         root
-      expand_commas root
-      nest_rules    root
-      flatten_rules root
-      fold_commas   root
+      directives         root
+      rules              root
+      expand_commas      root
+      parent_ref_rules   root
+      remove_parent_refs root
+      flatten_rules      root
+      fold_commas        root
       root
     end
 
@@ -164,12 +181,12 @@ module Sass
         whitespace
 
         assert_match /:/
-        
+
         value = ''
         while @template.scan(/[^;\s\}]+/)
           value << @template[0] << whitespace
         end
-        
+
         assert_match /(;|(?=\}))/
         rule << Tree::AttrNode.new(name, value, nil)
       end
@@ -191,7 +208,10 @@ module Sass
 
     def assert_match(re)
       if !@template.scan(re)
-        raise Exception.new("Invalid CSS!")
+        line = @template.string[0..@template.pos].count "\n"
+        # Display basic regexps as plain old strings
+        expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect
+        raise Exception.new("Invalid CSS on line #{line}: expected #{expected}")
       end
       whitespace
     end
@@ -224,7 +244,22 @@ module Sass
       root.children.flatten!
     end
 
-    # Nest rules so that
+    # Make rules use parent refs so that
+    #
+    #   foo
+    #     color: green
+    #   foo.bar
+    #     color: blue
+    #
+    # becomes
+    #
+    #   foo
+    #     color: green
+    #     &.bar
+    #       color: blue
+    #
+    # This has the side effect of nesting rules,
+    # so that
     #
     #   foo
     #     color: green
@@ -237,29 +272,50 @@ module Sass
     #
     #   foo
     #     color: green
-    #     bar
+    #     & bar
     #       color: red
-    #     baz
+    #     & baz
     #       color: blue
-    # 
-    def nest_rules(root)
+    #
+    def parent_ref_rules(root)
       rules = OrderedHash.new
       root.children.select { |c| Tree::RuleNode === c }.each do |child|
         root.children.delete child
-        first, rest = child.rule.split(' ', 2)
+        first, rest = child.rule.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
         rules[first] ||= Tree::RuleNode.new(first, nil)
         if rest
-          child.rule = rest
+          child.rule = "&" + rest
           rules[first] << child
         else
           rules[first].children += child.children
         end
       end
 
-      rules.values.each { |v| nest_rules(v) }
+      rules.values.each { |v| parent_ref_rules(v) }
       root.children += rules.values
     end
 
+    # Remove useless parent refs so that
+    #
+    #   foo
+    #     & bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #   foo
+    #     bar
+    #       color: blue
+    #
+    def remove_parent_refs(root)
+      root.children.each do |child|
+        if child.is_a?(Tree::RuleNode)
+          child.rule.gsub! /^& /, ''
+          remove_parent_refs child
+        end
+      end
+    end
+
     # Flatten rules so that
     #
     #   foo
@@ -271,7 +327,18 @@ module Sass
     #
     #   foo bar baz
     #     color: red
-    # 
+    #
+    # and
+    #
+    #   foo
+    #     &.bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #   foo.bar
+    #     color: blue
+    #
     def flatten_rules(root)
       root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
     end
@@ -279,7 +346,13 @@ module Sass
     def flatten_rule(rule)
       while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
         child = rule.children.first
-        rule.rule = "#{rule.rule} #{child.rule}"
+
+        if child.rule[0] == ?&
+          rule.rule = child.rule.gsub /^&/, rule.rule
+        else
+          rule.rule = "#{rule.rule} #{child.rule}"
+        end
+
         rule.children = child.children
       end