haml 3.1.0.alpha.33 → 3.1.0.alpha.36

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

@@ -92,7 +92,7 @@ module Sass
         :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
         :color => HEXCOLOR,
         :bool => /(true|false)\b/,
-        :ident_op => %r{(#{Regexp.union(*IDENT_OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|$)")})})},
+        :ident_op => %r{(#{Regexp.union(*IDENT_OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")})})},
         :op => %r{(#{Regexp.union(*OP_NAMES)})},
       }
 

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

@@ -0,0 +1,76 @@
+module Sass::Script
+  # A SassScript object representing a CSS list.
+  # This includes both comma-separated lists and space-separated lists.
+  class List < Literal
+    # The Ruby array containing the contents of the list.
+    #
+    # @return [Array<Literal>]
+    attr_reader :value
+    alias_method :children, :value
+    alias_method :to_a, :value
+
+    # The operator separating the values of the list.
+    # Either `:comma` or `:space`.
+    #
+    # @return [Symbol]
+    attr_reader :separator
+
+    # Creates a new list.
+    #
+    # @param value [Array<Literal>] See \{#value}
+    # @param separator [String] See \{#separator}
+    def initialize(value, separator)
+      super(value)
+      @separator = separator
+    end
+
+    # @see Node#eq
+    def eq(other)
+      Sass::Script::Bool.new(
+        self.class == other.class && self.value == other.value &&
+        self.separator == other.separator)
+    end
+
+    # @see Node#to_s
+    def to_s(opts = {})
+      return value.map {|e| e.to_s(opts)}.join(sep_str)
+    end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      precedence = Sass::Script::Parser.precedence_of(separator)
+      value.map do |v|
+        if v.is_a?(List) && Sass::Script::Parser.precedence_of(v.separator) <= precedence
+          "(#{v.to_sass(opts)})"
+        else
+          v.to_sass(opts)
+        end
+      end.join(sep_str(nil))
+    end
+
+    # @see Node#inspect
+    def inspect
+      "(#{to_sass})"
+    end
+
+    protected
+
+    # @see Node#_perform
+    def _perform(environment)
+      list = Sass::Script::List.new(
+        value.map {|e| e.perform(environment)},
+        separator)
+      list.options = self.options
+      list.context = self.context
+      list
+    end
+
+    private
+
+    def sep_str(opts = self.options)
+      return ' ' if separator == :space
+      return ',' if opts && opts[:style] == :compressed
+      return ', '
+    end
+  end
+end

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

@@ -9,6 +9,7 @@ module Sass::Script
     require 'sass/script/number'
     require 'sass/script/color'
     require 'sass/script/bool'
+    require 'sass/script/list'
 
     # Returns the Ruby value of the literal.
     # The type of this value varies based on the subclass.
@@ -107,7 +108,7 @@ MSG
     # @param other [Literal] The right-hand side of the operator
     # @return [Script::String] A string containing both literals
     #   separated by a space
-    def concat(other)
+    def space(other)
       Sass::Script::String.new("#{self.to_s} #{other.to_s}")
     end
 
@@ -214,6 +215,14 @@ MSG
     # @raise [Sass::SyntaxError] if this literal isn't an integer
     def assert_int!; to_i; end
 
+    # Returns the value of this literal as a list.
+    # Single literals are considered the same as single-element lists.
+    #
+    # @return [Array<Literal>] The of this literal as a list
+    def to_a
+      [self]
+    end
+
     # Returns the string representation of this literal
     # as it would be output to the CSS document.
     #

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

@@ -238,7 +238,7 @@ module Sass::Script
     # @return [String] The CSS representation of this number
     # @raise [Sass::SyntaxError] if this number has units that can't be used in CSS
     #   (e.g. `px*in`)
-    def to_s
+    def to_s(opts = {})
       return original if original
       raise Sass::SyntaxError.new("#{inspect} isn't a valid CSS value.") unless legal_units?
       inspect

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

@@ -41,7 +41,7 @@ module Sass::Script
       sep =
         case @operator
         when :comma; ", "
-        when :concat; " "
+        when :space; " "
         else; " #{Lexer::OPERATORS_REVERSE[@operator]} "
         end
       "#{o1}#{sep}#{o2}"
@@ -66,7 +66,7 @@ module Sass::Script
       literal1 = @operand1.perform(environment)
       literal2 = @operand2.perform(environment)
 
-      if @operator == :concat && context == :equals
+      if @operator == :space && context == :equals
         literal1 = Sass::Script::String.new(literal1.value) if literal1.is_a?(Sass::Script::String)
         literal2 = Sass::Script::String.new(literal2.value) if literal2.is_a?(Sass::Script::String)
       end
@@ -82,6 +82,7 @@ module Sass::Script
     private
 
     def operand_to_sass(op, side, opts)
+      return "(#{op.to_sass(opts)})" if op.is_a?(List)
       return op.to_sass(opts) unless op.is_a?(Operation)
 
       pred = Sass::Script::Parser.precedence_of(@operator)

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

@@ -123,14 +123,14 @@ module Sass
       end
 
       PRECEDENCE = [
-        :comma, :single_eq, :concat, :or, :and,
+        :comma, :single_eq, :space, :or, :and,
         [:eq, :neq],
         [:gt, :gte, :lt, :lte],
         [:plus, :minus],
         [:times, :div, :mod],
       ]
 
-      ASSOCIATIVE = [:comma, :concat, :plus, :times]
+      ASSOCIATIVE = [:plus, :times]
 
       class << self
         # Returns an integer representing the precedence
@@ -193,7 +193,18 @@ RUBY
       # @private
       def lexer_class; Lexer; end
 
-      production :expr, :interpolation, :comma
+      def expr
+        interp = try_ops_after_interp([:comma], :expr) and return interp
+        line = @lexer.line
+        return unless e = interpolation
+        arr = [e]
+        while tok = try_tok(:comma)
+          interp = try_op_before_interp(tok, e) and return interp
+          arr << assert_expr(:interpolation)
+        end
+        arr.size == 1 ? arr.first : node(List.new(arr, :comma), line)
+      end
+
       production :equals, :interpolation, :single_eq
 
       def try_op_before_interp(op, prev = nil)
@@ -219,25 +230,27 @@ RUBY
         return interp
       end
 
-      def interpolation(first = concat)
+      def interpolation(first = space)
         e = first
         while interp = try_tok(:begin_interpolation)
           wb = @lexer.whitespace?(interp)
           line = @lexer.line
           mid = parse_interpolated
           wa = @lexer.whitespace?
-          e = Script::Interpolation.new(e, mid, concat, wb, wa)
+          e = Script::Interpolation.new(e, mid, space, wb, wa)
           e.line = line
         end
         e
       end
 
-      def concat
+      def space
+        line = @lexer.line
         return unless e = or_expr
-        while sub = or_expr
-          e = node(Operation.new(e, sub, :concat))
+        arr = [e]
+        while e = or_expr
+          arr << e
         end
-        e
+        arr.size == 1 ? arr.first : node(List.new(arr, :space), line)
       end
 
       production :or_expr, :and_expr, :or
@@ -280,7 +293,7 @@ RUBY
           c = assert_tok(:const)
           var = Script::Variable.new(c.value)
           if tok = (try_tok(:colon) || try_tok(:single_eq))
-            val = assert_expr(:concat)
+            val = assert_expr(:space)
 
             if tok.type == :single_eq
               val.context = :equals
@@ -427,8 +440,8 @@ RUBY
         @lexer.expected!(EXPR_NAMES[:default])
       end
 
-      def node(node)
-        node.line = @lexer.line
+      def node(node, line = @lexer.line)
+        node.line = line
         node
       end
     end

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

@@ -24,11 +24,6 @@ module Sass
       def interp_ident(ident = IDENT); tok(ident); end
       def use_css_import?; true; end
 
-      def special_directive(name)
-        return unless name == 'media' || name == 'import'
-        super
-      end
-
       def block_child(context)
         case context
         when :ruleset

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

@@ -98,7 +98,8 @@ module Sass
         node << comment
       end
 
-      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :while, :if, :extend, :import, :media]
+      DIRECTIVES = Set[:mixin, :include, :debug, :warn, :for, :each, :while, :if,
+        :else, :extend, :import, :media, :charset]
 
       def directive
         return unless tok(/@/)
@@ -168,6 +169,18 @@ module Sass
         block(node(Sass::Tree::ForNode.new(var, from, to, exclusive)), :directive)
       end
 
+      def each_directive
+        tok!(/\$/)
+        var = tok! IDENT
+        ss
+
+        tok!(/in/)
+        list = sass_script(:parse)
+        ss
+
+        block(node(Sass::Tree::EachNode.new(var, list)), :directive)
+      end
+
       def while_directive
         expr = sass_script(:parse)
         ss
@@ -179,12 +192,14 @@ module Sass
         ss
         node = block(node(Sass::Tree::IfNode.new(expr)), :directive)
         pos = @scanner.pos
+        line = @line
         ss
 
         else_block(node) ||
           begin
             # Backtrack in case there are any comments we want to parse
             @scanner.pos = pos
+            @line = line
             node
           end
       end
@@ -197,16 +212,23 @@ module Sass
           :directive)
         node.add_else(else_node)
         pos = @scanner.pos
+        line = @line
         ss
 
         else_block(node) ||
           begin
             # Backtrack in case there are any comments we want to parse
             @scanner.pos = pos
+            @line = line
             node
           end
       end
 
+      def else_directive
+        raise Sass::SyntaxError.new(
+          "Invalid CSS: @else must come after @if", :line => @line)
+      end
+
       def extend_directive
         node(Sass::Tree::ExtendNode.new(expr!(:selector)))
       end
@@ -240,7 +262,7 @@ module Sass
 
       def media_directive
         val = str {media_query_list}.strip
-        block(node(Sass::Tree::DirectiveNode.new("@media #{val}")), :directive)
+        block(node(Sass::Tree::MediaNode.new(val)), :directive)
       end
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
@@ -289,6 +311,13 @@ module Sass
         true
       end
 
+      def charset_directive
+        tok! STRING
+        name = @scanner[1] || @scanner[2]
+        ss
+        node(Sass::Tree::CharsetNode.new(name))
+      end
+
       def variable
         return unless tok(/\$/)
         name = tok!(IDENT)
@@ -398,9 +427,14 @@ module Sass
         return unless v = selector
         rules.concat v
 
+        ws = ''
         while tok(/,/)
-          rules << ',' << str {ss}
-          rules.concat expr!(:selector)
+          ws << str {ss}
+          if v = selector
+            rules << ',' << ws
+            rules.concat v
+            ws = ''
+          end
         end
         rules
       end
@@ -413,10 +447,14 @@ module Sass
       def selector_comma_sequence
         return unless sel = _selector
         selectors = [sel]
+        ws = ''
         while tok(/,/)
-          ws = str{ss}
-          selectors << expr!(:_selector)
-          selectors[-1] = Selector::Sequence.new(["\n"] + selectors.last.members) if ws.include?("\n")
+          ws << str{ss}
+          if sel = _selector
+            selectors << sel
+            selectors[-1] = Selector::Sequence.new(["\n"] + selectors.last.members) if ws.include?("\n")
+            ws = ''
+          end
         end
         Selector::CommaSequence.new(selectors)
       end
@@ -761,6 +799,7 @@ MESSAGE
         :interp_ident => "identifier",
         :interp_name => "identifier",
         :expr => "expression (e.g. 1px, bold)",
+        :_selector => "selector",
         :selector_comma_sequence => "selector",
         :simple_selector_sequence => "selector",
         :import_arg => "file to import (string or url())",

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

@@ -32,7 +32,7 @@ module Sass
       def use_css_import?; true; end
 
       def special_directive(name)
-        return unless name == 'media' || name == 'import'
+        return unless  %w[media import charset].include?(name)
         super
       end
     end

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

@@ -0,0 +1,37 @@
+module Sass::Tree
+  # A static node representing an unproccessed Sass `@charset` directive.
+  #
+  # @see Sass::Tree
+  class CharsetNode < Node
+    # The name of the charset.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # @param name [String] see \{#name}
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    # @see Node#invisible?
+    def invisible?
+      !Sass::Util.ruby1_8?
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@charset \"#{name}\"#{semi fmt}\n"
+    end
+
+    # Computes the CSS for the directive.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @return [String] The resulting CSS
+    def _to_s(tabs)
+      "@charset \"#{name}\";"
+    end
+  end
+end

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

@@ -4,8 +4,8 @@ module Sass::Tree
   # are handled by their own nodes;
   # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
   #
-  # `@import` is a bit of a weird case;
-  # it becomes an {ImportNode}.
+  # `@import` and `@charset` are special cases;
+  # they become {ImportNode}s and {CharsetNode}s, respectively.
   #
   # @see Sass::Tree
   class DirectiveNode < Node

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

@@ -0,0 +1,54 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@each` loop.
+  #
+  # @see Sass::Tree
+  class EachNode < Node
+    # @param var [String] The name of the loop variable
+    # @param list [Script::Node] The parse tree for the list
+    def initialize(var, list)
+      @var = var
+      @list = list
+      super()
+    end
+
+    protected
+
+    # @see Node#to_src
+    def to_src(tabs, opts, fmt)
+      "#{'  ' * tabs}@each $#{dasherize(@var, opts)} in #{@list.to_sass(opts)}" +
+        children_to_src(tabs, opts, fmt)
+    end
+
+    # Runs the child nodes once for each value in the list.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      list = @list.perform(environment)
+
+      children = []
+      environment = Sass::Environment.new(environment)
+      list.to_a.each do |v|
+        environment.set_local_var(@var, v)
+        children += perform_children(environment)
+      end
+      children
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {ExtendNode}s are valid within {EachNode}s.
+    #
+    # @param child [Tree::Node] A potential child node.
+    # @return [Boolean, String] Whether or not the child node is valid,
+    #   as well as the error message to display if it is invalid
+    def invalid_child?(child)
+      super unless child.is_a?(ExtendNode)
+    end
+  end
+end