haml 1.8.0 → 2.0.3

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

@@ -4,6 +4,7 @@ module Sass::Constant; class Literal; end; end; # :nodoc:
 require 'sass/constant/string'
 require 'sass/constant/number'
 require 'sass/constant/color'
+require 'sass/constant/nil'
 
 class Sass::Constant::Literal # :nodoc:
   # The regular expression matching numbers.
@@ -13,7 +14,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 +25,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 +37,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/nil.rb

@@ -0,0 +1,9 @@
+require 'sass/constant/literal'
+
+module Sass::Constant # :nodoc:
+  class Nil < Literal # :nodoc:
+    def to_s
+      ''
+    end
+  end
+end

data/lib/sass/constant/number.rb

@@ -8,9 +8,9 @@ module Sass::Constant  # :nodoc:
     def parse(value)
       first, second, unit = value.scan(Literal::NUMBER)[0]
       @value = first.empty? ? second.to_i : "#{first}#{second}".to_f
-      @unit = unit unless unit.empty?
+      @unit = unit.empty? ? nil : unit
     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
@@ -119,95 +119,64 @@ module Sass
                 next
               end
 
-              # Is this a constant?
-              if beginning_of_token && symbol == :const
-                beginning_of_token = true
-                to_return << :const
-                next
-              end
-
               # Are we looking at an operator?
               if symbol && (symbol != :mod || str.empty?)
                 str = reset_str.call
-                beginning_of_token = true
+                beginning_of_token = symbol != :close
                 to_return << symbol
                 next
               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)
+
+      def parenthesize(value, 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])
-            sub, i = parenthesize_helper(i + 1, value, value_len)
-            beginning = i
-            to_return << sub
-          elsif token == :neg
-            if value[i + 1].nil?
-              # This is never actually reached, but we'll leave it in just in case.
-              raise Sass::SyntaxError.new("Unterminated unary minus.")
-            elsif value[i + 1] == :open
-              to_return.push(*value[beginning...i])
-              sub, i = parenthesize_helper(i + 2, value, value_len)
-              beginning = i
-              to_return << [:neg, sub]
-            elsif value[i + 1].is_a?(::Symbol)
-              to_return.push(*value[beginning...i])
-              sub, i = parenthesize_helper(i + 1, value, value_len, true)
-              beginning = i
-              to_return << [:neg, sub]
-            else
-              to_return.push(*value[beginning...i])
-              to_return << [:neg, value[i + 1]]
-              beginning = i = i + 2
-            end
-            return to_return[0], i if return_after_expr
-          elsif token == :const
-            raise Sass::SyntaxError.new("Unterminated constant.") if value[i + 1].nil?
-            raise Sass::SyntaxError.new("Invalid constant.") unless value[i + 1].is_a?(::String)
-
-            to_return.push(*value[beginning...i])
-            to_return << [:const, value[i + 1]]
-            beginning = i = i + 2
-            return to_return[0], i if return_after_expr
+
+        while (token = value.shift) && token != :close
+          case token
+          when :open
+            to_return << parenthesize(value)
+          when :neg
+            # This is never actually reached, but we'll leave it in just in case.
+            raise Sass::SyntaxError.new("Unterminated unary minus.") if value.first.nil?
+            to_return << [:neg, parenthesize(value, true)]
+          when :const
+            raise Sass::SyntaxError.new("Unterminated constant.") if value.first.nil?
+            raise Sass::SyntaxError.new("Invalid constant.") unless value.first.is_a?(::String)
+
+            to_return << [:const, value.first]
+            value.shift
           else
-            i += 1
+            to_return << token
           end
-          
-          token = value[i]
+
+          return to_return.first if return_after_expr
         end
-        to_return.push(*value[beginning...i])
-        return to_return, i + 1
+        return to_return
       end
-      
+
       #--
       # TODO: Don't pass around original value;
       #       have Constant.parse automatically add it to exception.
       #++
       def operationalize(value, constants)
         value = [value] unless value.is_a?(Array)
-        if value.length == 1
+        case value.length
+        when 0
+          Sass::Constant::Nil.new
+        when 1
           value = value[0]
           if value.is_a? Array
             operationalize(value, constants)
@@ -216,7 +185,7 @@ module Sass
           else
             Literal.parse(value)
           end
-        elsif value.length == 2
+        when 2
           if value[0] == :neg
             Operation.new(Sass::Constant::Number.new('0'), operationalize(value[1], constants), :minus)
           elsif value[0] == :const
@@ -224,7 +193,7 @@ module Sass
           else
             raise SyntaxError.new("Constant arithmetic error")
           end
-        elsif value.length == 3
+        when 3
           Operation.new(operationalize(value[0], constants), operationalize(value[2], constants), value[1])
         else
           if SECOND_ORDER.include?(value[1]) && FIRST_ORDER.include?(value[3])
@@ -234,10 +203,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