haml 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/sass/script/interpolation.rb

@@ -9,16 +9,16 @@ module Sass::Script
     end
 
     def inspect
-      "(interpolation #{@before.inspect} #{@mid.inspect} #{after.inspect})"
+      "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
     end
 
-    def to_sass
+    def to_sass(opts = {})
       res = ""
-      res << @before.to_sass if @before
+      res << @before.to_sass(opts) if @before
       res << ' ' if @before && @whitespace_before
-      res << '#{' << @mid.to_sass << '}'
+      res << '#{' << @mid.to_sass(opts) << '}'
       res << ' ' if @after && @whitespace_after
-      res << @after.to_sass if @after
+      res << @after.to_sass(opts) if @after
       res
     end
 

data/lib/sass/script/lexer.rb

@@ -111,7 +111,7 @@ module Sass
 
       # A hash of regular expressions that are used for tokenizing strings.
       #
-      # The key is a [Symbol, Boolean] pair.
+      # The key is a `[Symbol, Boolean]` pair.
       # The symbol represents which style of quotation to use,
       # while the boolean represents whether or not the string
       # is following an interpolated segment.
@@ -196,11 +196,12 @@ module Sass
       def read_token
         return if done?
         return unless value = token
+        type, val, size = value
+        size ||= @scanner.matched_size
 
-        value.last.line = @line if value.last.is_a?(Script::Node)
-        Token.new(value.first, value.last, @line,
-          current_position - @scanner.matched_size,
-          @scanner.pos - @scanner.matched_size)
+        val.line = @line if val.is_a?(Script::Node)
+        Token.new(type, val, @line,
+          current_position - size, @scanner.pos - size)
       end
 
       def whitespace
@@ -236,13 +237,13 @@ module Sass
 
       def ident
         return unless s = scan(REGULAR_EXPRESSIONS[:ident])
-        [:ident, s.gsub(/\\(.)/, '\1')]
+        [:ident, s]
       end
 
       def string(re, open)
         return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
         @interpolation_stack << re if @scanner[2].empty? # Started an interpolated section
-        [:string, Script::String.new(@scanner[1].gsub(/\\([^0-9a-f])/, '\1').gsub(/\\([0-9a-f]{1,4})/, "\\\\\\1"), :string)]
+        [:string, Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)]
       end
 
       def number
@@ -272,7 +273,8 @@ module Sass
         @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
         [:special_fun,
           Haml::Util.merge_adjacent_strings(
-            [str1] + Sass::Engine.parse_interp(str2, @line, @options))]
+            [str1] + Sass::Engine.parse_interp(str2, @line, @options)),
+          str1.size + str2.size]
       end
 
       def ident_op

data/lib/sass/script/literal.rb

@@ -120,6 +120,16 @@ MSG
       Sass::Script::String.new("#{self.to_s}, #{other.to_s}")
     end
 
+    # The SassScript `=` operation
+    # (used for proprietary MS syntax like `alpha(opacity=20)`).
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Script::String] A string containing both literals
+    #   separated by `"="`
+    def single_eq(other)
+      Sass::Script::String.new("#{self.to_s}=#{other.to_s}")
+    end
+
     # The SassScript `+` operation.
     #
     # @param other [Literal] The right-hand side of the operator
@@ -208,7 +218,7 @@ MSG
     # as it would be output to the CSS document.
     #
     # @return [String]
-    def to_s
+    def to_s(opts = {})
       raise Sass::SyntaxError.new("[BUG] All subclasses of Sass::Literal must implement #to_s.")
     end
     alias_method :to_sass, :to_s

data/lib/sass/script/node.rb

@@ -74,12 +74,21 @@ module Sass::Script
     # Returns the text of this SassScript expression.
     #
     # @return [String]
-    def to_sass
+    def to_sass(opts = {})
       raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #to_sass.")
     end
 
     protected
 
+    # Converts underscores to dashes if the :dasherize option is set.
+    def dasherize(s, opts)
+      if opts[:dasherize]
+        s.gsub(/_/,'-')
+      else
+        s
+      end
+    end
+
     # Evaluates this node.
     #
     # @param environment [Sass::Environment] The environment in which to evaluate the SassScript

data/lib/sass/script/number.rb

@@ -238,7 +238,7 @@ module Sass::Script
     # as long as there is only one unit.
     #
     # @return [String] The representation
-    def inspect
+    def inspect(opts = {})
       value =
         if self.value.is_a?(Float) && (self.value.infinite? || self.value.nan?)
           self.value
@@ -299,6 +299,30 @@ module Sass::Script
                  end, num_units, den_units)
     end
 
+    # @param other [Number] A number to decide if it can be compared with this number.
+    # @return [Boolean] Whether or not this number can be compared with the other.
+    def comparable_to?(other)
+      begin
+        self.operate(other, :+)
+        true
+      rescue Sass::UnitConversionError
+        false
+      end
+    end
+
+    # Returns a human readable representation of the units in this number.
+    # For complex units this takes the form of:
+    # numerator_unit1 * numerator_unit2 / denominator_unit1 * denominator_unit2
+    # @return [String] a string that represents the units in this number
+    def unit_str
+      rv = numerator_units.sort.join("*")
+      if denominator_units.any?
+        rv << "/"
+        rv << denominator_units.sort.join("*")
+      end
+      rv
+    end
+
     protected
 
     def operate(other, operation)
@@ -343,15 +367,6 @@ module Sass::Script
       end
     end
 
-    def unit_str
-      rv = numerator_units.join("*")
-      if denominator_units.any?
-        rv << "/"
-        rv << denominator_units.join("*")
-      end
-      rv
-    end
-
     def normalize!
       return if unitless?
       @numerator_units, @denominator_units = sans_common_units(numerator_units, denominator_units)

data/lib/sass/script/operation.rb

@@ -5,6 +5,7 @@ require 'sass/script/color'
 require 'sass/script/functions'
 require 'sass/script/unary_operation'
 require 'sass/script/interpolation'
+require 'sass/script/string_interpolation'
 
 module Sass::Script
   # A SassScript parse node representing a binary operation,
@@ -33,10 +34,10 @@ module Sass::Script
     end
 
     # @see Node#to_sass
-    def to_sass
+    def to_sass(opts = {})
       pred = Sass::Script::Parser.precedence_of(@operator)
-      o1 = operand_to_sass pred, @operand1
-      o2 = operand_to_sass pred, @operand2
+      o1 = operand_to_sass pred, @operand1, opts
+      o2 = operand_to_sass pred, @operand2, opts
       sep =
         case @operator
         when :comma; ", "
@@ -82,10 +83,10 @@ module Sass::Script
 
     private
 
-    def operand_to_sass(pred, op)
-      return "(#{op.to_sass})" if op.is_a?(Operation) &&
+    def operand_to_sass(pred, op, opts = {})
+      return "(#{op.to_sass(opts)})" if op.is_a?(Operation) &&
         Sass::Script::Parser.precedence_of(op.operator) < pred
-      op.to_sass
+      op.to_sass(opts)
     end
   end
 end

data/lib/sass/script/parser.rb

@@ -97,12 +97,7 @@ module Sass
       # @return [Array<Script::Node>] The root nodes of the arguments.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_mixin_definition_arglist
-        args = []
-
-        if try_tok(:lparen)
-          args = defn_arglist(false) || args
-          assert_tok(:rparen)
-        end
+        args = defn_arglist!(false)
         assert_done
 
         args.each do |k, v|
@@ -127,7 +122,7 @@ module Sass
 
       # @private
       PRECEDENCE = [
-        :comma, :concat, :or, :and,
+        :comma, :single_eq, :concat, :or, :and,
         [:eq, :neq],
         [:gt, :gte, :lt, :lte],
         [:plus, :minus],
@@ -186,6 +181,7 @@ RUBY
       def lexer_class; Lexer; end
 
       production :expr, :interpolation, :comma
+      production :equals, :interpolation, :single_eq
 
       def interpolation
         e = concat
@@ -232,32 +228,45 @@ RUBY
           end
           node(Script::String.new(name.value, :identifier))
         else
-          args = arglist || []
+          args = fn_arglist || []
           assert_tok(:rparen)
           node(Script::Funcall.new(name.value, args))
         end
       end
 
-      def defn_arglist(must_have_default)
-        line = @lexer.line
-        offset = @lexer.offset + 1
-        return unless c = try_tok(:const)
-        var = Script::Variable.new(c.value)
-        if tok = (try_tok(:colon) || try_tok(:single_eq))
-          val = assert_expr(:concat)
-
-          if tok.type == :single_eq
-            val.context = :equals
-            val.options = @options
-            Script.equals_warning("mixin argument defaults", "$#{c.value}",
-              val.to_sass, false, line, offset, @options[:filename])
+      def defn_arglist!(must_have_default)
+        return [] unless try_tok(:lparen)
+        return [] if try_tok(:rparen)
+        res = []
+        loop do
+          line = @lexer.line
+          offset = @lexer.offset + 1
+          c = assert_tok(:const)
+          var = Script::Variable.new(c.value)
+          if tok = (try_tok(:colon) || try_tok(:single_eq))
+            val = assert_expr(:concat)
+
+            if tok.type == :single_eq
+              val.context = :equals
+              val.options = @options
+              Script.equals_warning("mixin argument defaults", "$#{c.value}",
+                val.to_sass, false, line, offset, @options[:filename])
+            end
+            must_have_default = true
+          elsif must_have_default
+            raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.")
           end
-        elsif must_have_default
-          raise SyntaxError.new("Required argument #{var.inspect} must come before any optional arguments.")
+          res << [var, val]
+          break unless try_tok(:comma)
         end
+        assert_tok(:rparen)
+        res
+      end
 
-        return [[var, val]] unless try_tok(:comma)
-        [[var, val], *defn_arglist(val)]
+      def fn_arglist
+        return unless e = equals
+        return [e] unless try_tok(:comma)
+        [e, *fn_arglist]
       end
 
       def arglist
@@ -303,9 +312,9 @@ RUBY
         line = @lexer.line
         mid = parse_interpolated
         last = assert_expr(:string)
-        op = Operation.new(first.value, node(Operation.new(mid, last, :plus)), :plus)
-        op.line = line
-        op
+        interp = StringInterpolation.new(first.value, mid, last)
+        interp.line = line
+        interp
       end
 
       def number

data/lib/sass/script/string.rb

@@ -35,23 +35,28 @@ module Sass::Script
     end
 
     # @see Node#to_s
-    def to_s
-      to_sass
+    def to_s(opts = {})
+      to_sass(opts)
     end
 
-    # @param type [Symbol] The type of string to render this as.
-    #   `:string`s have double quotes, `:identifier`s do not.
+    # @param opts [{Symbol => Object}]
+    #   `opts[:type]` -- The type of string to render this as.
+    #     `:string`s have double quotes, `:identifier`s do not.
+    #     Defaults to `:identifier`.
     # @see Node#to_sass
-    def to_sass(type = self.type)
+    def to_sass(opts = {})
+      type = opts[:type] || self.type
       if type == :identifier
         if context == :equals && Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
           return "unquote(#{Sass::Script::String.new(self.value, :string).to_sass})"
+        elsif context == :equals && self.value.size == 0
+          return %q{""}
         end
         return self.value
       end
 
-      # Replace single backslashes with double. Really.
-      value = self.value.gsub("\\", "\\\\\\\\")
+      return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}
+      return "'#{value.gsub("'", "\\'")}'" if opts[:quote] == %q{'}
       return "\"#{value}\"" unless value.include?('"')
       return "'#{value}'" unless value.include?("'")
       "\"#{value.gsub('"', "\\\"")}\"" #'

data/lib/sass/script/string_interpolation.rb

@@ -0,0 +1,70 @@
+module Sass::Script
+  class StringInterpolation < Node
+    def initialize(before, mid, after)
+      @before = before
+      @mid = mid
+      @after = after
+    end
+
+    def inspect
+      "(string_interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
+    end
+
+    def to_sass(opts = {})
+      # We can get rid of all of this when we remove the deprecated :equals context
+      before_unquote, before_quote_char, before_str = parse_str(@before.to_sass(opts))
+      after_unquote, after_quote_char, after_str = parse_str(@after.to_sass(opts))
+      unquote = before_unquote || after_unquote ||
+        (before_quote_char && !after_quote_char && !after_str.empty?) ||
+        (!before_quote_char && after_quote_char && !before_str.empty?)
+      quote_char =
+        if before_quote_char && after_quote_char && before_quote_char != after_quote_char
+          before_str.gsub!("\\'", "'")
+          before_str.gsub!('"', "\\\"")
+          after_str.gsub!("\\'", "'")
+          after_str.gsub!('"', "\\\"")
+          '"'
+        else
+          before_quote_char || after_quote_char
+        end
+
+      res = ""
+      res << 'unquote(' if unquote
+      res << quote_char if quote_char
+      res << before_str
+      res << '#{' << @mid.to_sass(opts) << '}'
+      res << after_str
+      res << quote_char if quote_char
+      res << ')' if unquote
+      res
+    end
+
+    def children
+      [@before, @mid, @after].compact
+    end
+
+    protected
+
+    def _perform(environment)
+      res = ""
+      res << @before.perform(environment).value
+      val = @mid.perform(environment)
+      res << (val.is_a?(Sass::Script::String) ? val.value : val.to_s)
+      res << @after.perform(environment).value
+      Sass::Script::String.new(res, :string)
+    end
+
+    def parse_str(str)
+      case str
+      when /^unquote\((["'])(.*)\1\)$/
+        return true, $1, $2
+      when '""'
+        return false, nil, ""
+      when /^(["'])(.*)\1$/
+        return false, $1, $2
+      else
+        return false, nil, str
+      end
+    end
+  end
+end

data/lib/sass/script/unary_operation.rb

@@ -19,12 +19,12 @@ module Sass::Script
     end
 
     # @see Node#to_sass
-    def to_sass
-      operand = @operand.to_sass
+    def to_sass(opts = {})
+      operand = @operand.to_sass(opts)
       if @operand.is_a?(Operation) ||
           (@operator == :minus &&
            (operand =~ Sass::SCSS::RX::IDENT) == 0)
-        operand = "(#{@operand.to_sass})"
+        operand = "(#{@operand.to_sass(opts)})"
       end
       op = Lexer::OPERATORS_REVERSE[@operator]
       op + (op =~ /[a-z]/ ? " " : "") + operand

data/lib/sass/script/variable.rb

@@ -14,9 +14,9 @@ module Sass
       end
 
       # @return [String] A string representation of the variable
-      def inspect
+      def inspect(opts = {})
         return "!important" if name == "important"
-        "$#{name}"
+        "$#{dasherize(name, opts)}"
       end
       alias_method :to_sass, :inspect