haml 3.1.0.alpha.19 → 3.1.0.alpha.22

data/vendor/sass/lib/sass/script/node.rb

@@ -32,7 +32,13 @@ module Sass::Script
     # @param options [{Symbol => Object}] The options
     def options=(options)
       @options = options
-      children.each {|c| c.options = options}
+      children.each do |c|
+        if c.is_a? Hash
+          c.values.each {|v| v.options = options }
+        else
+          c.options = options
+        end
+      end
     end
 
     # Sets the context for this node,

data/vendor/sass/lib/sass/script/number.rb

@@ -41,10 +41,13 @@ module Sass::Script
     # @api public
     PRECISION = 1000.0
 
+    # Used so we don't allocate two new arrays for each new number.
+    NO_UNITS  = []
+
     # @param value [Numeric] The value of the number
     # @param numerator_units [Array<String>] See \{#numerator\_units}
     # @param denominator_units [Array<String>] See \{#denominator\_units}
-    def initialize(value, numerator_units = [], denominator_units = [])
+    def initialize(value, numerator_units = NO_UNITS, denominator_units = NO_UNITS)
       super(value)
       @numerator_units = numerator_units
       @denominator_units = denominator_units
@@ -107,7 +110,7 @@ module Sass::Script
     #
     # @return [Number] The negative value of this number
     def unary_minus
-      Number.new(-value, numerator_units, denominator_units)
+      Number.new(-value, @numerator_units, @denominator_units)
     end
 
     # The SassScript `*` operation.
@@ -183,7 +186,7 @@ module Sass::Script
         if unitless?
           this = this.coerce(other.numerator_units, other.denominator_units)
         else
-          other = other.coerce(numerator_units, denominator_units)
+          other = other.coerce(@numerator_units, @denominator_units)
         end
       rescue Sass::UnitConversionError
         return Sass::Script::Bool.new(false)
@@ -248,7 +251,8 @@ module Sass::Script
     #
     # @return [String] The representation
     def inspect(opts = {})
-      "#{self.class.round(self.value)}#{unit_str}"
+      value = self.class.round(self.value)
+      unitless? ? value.to_s : "#{value}#{unit_str}"
     end
     alias_method :to_sass, :inspect
 
@@ -266,13 +270,13 @@ module Sass::Script
 
     # @return [Boolean] Whether or not this number has no units.
     def unitless?
-      numerator_units.empty? && denominator_units.empty?
+      @numerator_units.empty? && @denominator_units.empty?
     end
 
     # @return [Boolean] Whether or not this number has units that can be represented in CSS
     #   (that is, zero or one \{#numerator\_units}).
     def legal_units?
-      (numerator_units.empty? || numerator_units.size == 1) && denominator_units.empty?
+      (@numerator_units.empty? || @numerator_units.size == 1) && @denominator_units.empty?
     end
 
     # Returns this number converted to other units.
@@ -295,8 +299,8 @@ module Sass::Script
       Number.new(if unitless?
                    self.value
                  else
-                   self.value * coercion_factor(self.numerator_units, num_units) /
-                     coercion_factor(self.denominator_units, den_units)
+                   self.value * coercion_factor(@numerator_units, num_units) /
+                     coercion_factor(@denominator_units, den_units)
                  end, num_units, den_units)
     end
 
@@ -316,10 +320,10 @@ module Sass::Script
     # 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 = @numerator_units.sort.join("*")
+      if @denominator_units.any?
         rv << "/"
-        rv << denominator_units.sort.join("*")
+        rv << @denominator_units.sort.join("*")
       end
       rv
     end
@@ -337,13 +341,15 @@ module Sass::Script
       end
     end
 
+    OPERATIONS = [:+, :-, :<=, :<, :>, :>=]
+
     def operate(other, operation)
       this = self
-      if [:+, :-, :<=, :<, :>, :>=].include?(operation)
+      if OPERATIONS.include?(operation)
         if unitless?
           this = this.coerce(other.numerator_units, other.denominator_units)
         else
-          other = other.coerce(numerator_units, denominator_units)
+          other = other.coerce(@numerator_units, @denominator_units)
         end
       end
       # avoid integer division
@@ -381,7 +387,7 @@ module Sass::Script
 
     def normalize!
       return if unitless?
-      @numerator_units, @denominator_units = sans_common_units(numerator_units, denominator_units)
+      @numerator_units, @denominator_units = sans_common_units(@numerator_units, @denominator_units)
 
       @denominator_units.each_with_index do |d, i|
         if convertable?(d) && (u = @numerator_units.detect(&method(:convertable?)))
@@ -407,7 +413,7 @@ module Sass::Script
     end
 
     def convertable?(units)
-      Array(units).all?(&CONVERTABLE_UNITS.method(:include?))
+      Array(units).all? {|u| CONVERTABLE_UNITS.include?(u)}
     end
 
     def sans_common_units(units1, units2)

data/vendor/sass/lib/sass/script/operation.rb

@@ -36,8 +36,8 @@ module Sass::Script
     # @see Node#to_sass
     def to_sass(opts = {})
       pred = Sass::Script::Parser.precedence_of(@operator)
-      o1 = operand_to_sass pred, @operand1, opts
-      o2 = operand_to_sass pred, @operand2, opts
+      o1 = operand_to_sass @operand1, :left, opts
+      o2 = operand_to_sass @operand2, :right, opts
       sep =
         case @operator
         when :comma; ", "
@@ -81,9 +81,14 @@ module Sass::Script
 
     private
 
-    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
+    def operand_to_sass(op, side, opts)
+      return op.to_sass(opts) unless op.is_a?(Operation)
+
+      pred = Sass::Script::Parser.precedence_of(@operator)
+      sub_pred = Sass::Script::Parser.precedence_of(op.operator)
+      assoc = Sass::Script::Parser.associative?(@operator)
+      return "(#{op.to_sass(opts)})" if sub_pred < pred ||
+        (side == :right && sub_pred == pred && !assoc)
       op.to_sass(opts)
     end
   end

data/vendor/sass/lib/sass/script/parser.rb

@@ -74,19 +74,21 @@ module Sass
 
       # Parses the argument list for a mixin include.
       #
-      # @return [Array<Script::Node>] The root nodes of the arguments.
+      # @return [(Array<Script::Node>, {String => Script::Note})]
+      #   The root nodes of the arguments.
+      #   Keyword arguments are in a hash from names to values.
       # @raise [Sass::SyntaxError] if the argument list isn't valid SassScript
       def parse_mixin_include_arglist
-        args = []
-
+        args, keywords = [], {}
         if try_tok(:lparen)
-          args = arglist || args
+          args, keywords = mixin_arglist || [[], {}]
           assert_tok(:rparen)
         end
         assert_done
 
         args.each {|a| a.options = @options}
-        args
+        keywords.each {|k, v| v.options = @options}
+        return args, keywords
       rescue Sass::SyntaxError => e
         e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
         raise e
@@ -128,6 +130,8 @@ module Sass
         [:times, :div, :mod],
       ]
 
+      ASSOCIATIVE = [:comma, :concat, :plus, :times]
+
       class << self
         # Returns an integer representing the precedence
         # of the given operator.
@@ -141,6 +145,13 @@ module Sass
           raise "[BUG] Unknown operator #{op}"
         end
 
+        # Returns whether or not the given operation is associative.
+        #
+        # @private
+        def associative?(op)
+          ASSOCIATIVE.include?(op)
+        end
+
         private
 
         # Defines a simple left-associative production.
@@ -254,9 +265,9 @@ RUBY
 
       def funcall
         return raw unless tok = try_tok(:funcall)
-        args = fn_arglist || []
+        args, keywords = fn_arglist || [[], {}]
         assert_tok(:rparen)
-        node(Script::Funcall.new(tok.value, args))
+        node(Script::Funcall.new(tok.value, args, keywords))
       end
 
       def defn_arglist!(must_have_default)
@@ -289,15 +300,48 @@ RUBY
       end
 
       def fn_arglist
-        return unless e = equals
-        return [e] unless try_tok(:comma)
-        [e, *assert_expr(:fn_arglist)]
+        arglist(:fn_arglist, :equals)
+      end
+
+      def mixin_arglist
+        arglist(:mixin_arglist, :interpolation)
       end
 
-      def arglist
-        return unless e = interpolation
-        return [e] unless try_tok(:comma)
-        [e, *assert_expr(:arglist)]
+      def arglist(type, subexpr)
+        return unless e = send(subexpr)
+        if @lexer.peek && @lexer.peek.type == :colon
+          name = e
+          @lexer.expected!("comma") unless name.is_a?(Variable)
+          assert_tok(:colon)
+          keywords = {name.underscored_name => assert_expr(subexpr, EXPR_NAMES[type])}
+        end
+
+        unless try_tok(:comma)
+          return [], keywords if keywords
+          return [e], {}
+        end
+
+        other_args, other_keywords = assert_expr(type)
+        if keywords
+          if other_keywords[name.underscored_name]
+            raise SyntaxError.new("Keyword argument \"#{name.to_sass}\" passed more than once")
+          end
+          return other_args, keywords.merge(other_keywords)
+        else
+          return [e, *other_args], other_keywords
+        end
+      end
+
+      def keyword_arglist
+        return unless var = try_tok(:const)
+        unless try_tok(:colon)
+          return_tok!
+          return
+        end
+        name = var[1]
+        value = interpolation
+        return {name => value} unless try_tok(:comma)
+        {name => value}.merge(assert_expr(:keyword_arglist))
       end
 
       def raw
@@ -359,13 +403,13 @@ RUBY
       EXPR_NAMES = {
         :string => "string",
         :default => "expression (e.g. 1px, bold)",
-        :arglist => "mixin argument",
+        :mixin_arglist => "mixin argument",
         :fn_arglist => "function argument",
       }
 
-      def assert_expr(name)
+      def assert_expr(name, expected = nil)
         (e = send(name)) && (return e)
-        @lexer.expected!(EXPR_NAMES[name] || EXPR_NAMES[:default])
+        @lexer.expected!(expected || EXPR_NAMES[name] || EXPR_NAMES[:default])
       end
 
       def assert_tok(*names)

data/vendor/sass/lib/sass/script/string.rb

@@ -41,9 +41,8 @@ module Sass::Script
 
     # @see Node#to_s
     def to_s(opts = {})
-      if self.type == :identifier
-        return %q{""} if context == :equals && self.value.size == 0
-        return self.value.gsub("\n", " ")
+      if @type == :identifier
+        return @context == :equals && @value.empty? ? %q{""} : @value.tr("\n", " ")
       end
 
       return "\"#{value.gsub('"', "\\\"")}\"" if opts[:quote] == %q{"}

data/vendor/sass/lib/sass/script/variable.rb

@@ -7,9 +7,15 @@ module Sass
       # @return [String]
       attr_reader :name
 
+      # The underscored name of the variable.
+      #
+      # @return [String]
+      attr_reader :underscored_name
+
       # @param name [String] See \{#name}
       def initialize(name)
         @name = name
+        @underscored_name = name.gsub(/-/,"_")
         super()
       end
 

data/vendor/sass/lib/sass/scss/parser.rb

@@ -138,9 +138,9 @@ module Sass
 
       def include_directive
         name = tok! IDENT
-        args = sass_script(:parse_mixin_include_arglist)
+        args, keywords = sass_script(:parse_mixin_include_arglist)
         ss
-        node(Sass::Tree::MixinNode.new(name, args))
+        node(Sass::Tree::MixinNode.new(name, args, keywords))
       end
 
       def debug_directive
@@ -821,17 +821,20 @@ MESSAGE
           :line => line)
       end
 
+      # Avoid allocating lots of new strings for `#tok`.
+      # This is important because `#tok` is called all the time.
+      NEWLINE = "\n"
+
       def tok(rx)
         res = @scanner.scan(rx)
         if res
-          @line += res.count("\n")
+          @line += res.count(NEWLINE)
           @expected = nil
           if !@strs.empty? && rx != COMMENT && rx != SINGLE_LINE_COMMENT
             @strs.each {|s| s << res}
           end
+          res
         end
-
-        res
       end
     end
   end

data/vendor/sass/lib/sass/selector/sequence.rb

@@ -48,12 +48,12 @@ module Sass
       # @raise [Sass::SyntaxError] If a parent selector is invalid
       def resolve_parent_refs(super_seq)
         members = @members
-        members.slice!(0) if nl = (members.first == "\n")
+        nl = (members.first == "\n" && members.shift)
         unless members.any? do |seq_or_op|
             seq_or_op.is_a?(SimpleSequence) && seq_or_op.members.first.is_a?(Parent)
           end
           members = []
-          members << "\n" if nl
+          members << nl if nl
           members << SimpleSequence.new([Parent.new])
           members += @members
         end

data/vendor/sass/lib/sass/tree/mixin_node.rb

@@ -11,13 +11,16 @@ module Sass::Tree
     def options=(opts)
       super
       @args.each {|a| a.context = :equals} if opts[:sass2]
+      @keywords.each {|k, v| v.context = :equals} if opts[:sass2]
     end
 
     # @param name [String] The name of the mixin
     # @param args [Array<Script::Node>] The arguments to the mixin
-    def initialize(name, args)
+    # @param keywords [{String => Script::Node}] A hash from keyword argument names to values
+    def initialize(name, args, keywords)
       @name = name
       @args = args
+      @keywords = keywords
       super()
     end
 
@@ -42,8 +45,12 @@ module Sass::Tree
 
     # @see Node#to_src
     def to_src(tabs, opts, fmt)
-      args = '(' + @args.map {|a| a.to_sass(opts)}.join(", ") + ')' unless @args.empty?
-      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{args}#{semi fmt}\n"
+      unless @args.empty? && @keywords.empty?
+        args = @args.map {|a| a.to_sass(opts)}.join(", ")
+        keywords = @keywords.map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
+        arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
+      end
+      "#{'  ' * tabs}#{fmt == :sass ? '+' : '@include '}#{dasherize(@name, opts)}#{arglist}#{semi fmt}\n"
     end
 
     # @see Node#_cssize
@@ -73,15 +80,28 @@ module Sass::Tree
       original_env.prepare_frame(:mixin => @name)
       raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
 
-      raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
+      passed_args = @args.dup
+      passed_keywords = @keywords.dup
+
+      raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
 Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
  but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
 END
-      environment = mixin.args.zip(@args).
+
+      passed_keywords.each do |name, value|
+        # TODO: Make this fast
+        unless mixin.args.find {|(var, default)| var.underscored_name == name}
+          raise Sass::SyntaxError.new("Mixin #{@name} doesn't have an argument named $#{name}")
+        end
+      end
+
+      environment = mixin.args.zip(passed_args).
         inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
         env.set_local_var(var.name,
           if value
             value.perform(environment)
+          elsif kv = passed_keywords[var.underscored_name]
+            kv.perform(env)
           elsif default
             val = default.perform(env)
             if default.context == :equals && val.is_a?(Sass::Script::String)

data/vendor/sass/lib/sass/tree/node.rb

@@ -148,8 +148,8 @@ module Sass
       # @param args [Array] Passed on to \{#\_to\_s}
       # @return [String, nil] The resulting CSS
       # @see Sass::Tree
-      def to_s(*args)
-        _to_s(*args)
+      def to_s(opts = nil)
+        _to_s(opts)
       rescue Sass::SyntaxError => e
         e.modify_backtrace(:filename => filename, :line => line)
         raise e