sass 3.2.0.alpha.57 → 3.2.0.alpha.59

data/lib/sass/script/parser.rb

@@ -130,6 +130,27 @@ module Sass
         raise e
       end
 
+      # Parse a single string value, possibly containing interpolation.
+      # Doesn't assert that the scanner is finished after parsing.
+      #
+      # @return [Script::Node] The root node of the parse tree.
+      # @raise [Sass::SyntaxError] if the string isn't valid SassScript
+      def parse_string
+        unless (peek = @lexer.peek) &&
+            (peek.type == :string ||
+            (peek.type == :funcall && peek.value.downcase == 'url'))
+          lexer.expected!("string")
+        end
+
+        expr = assert_expr :funcall
+        expr.options = @options
+        @lexer.unpeek!
+        expr
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace :line => @lexer.line, :filename => @options[:filename]
+        raise e
+      end
+
       # Parses a SassScript expression.
       #
       # @overload parse(str, line, offset, filename = nil)

data/lib/sass/scss/css_parser.rb

@@ -7,22 +7,11 @@ module Sass
     # parent references, nested selectors, and so forth.
     # It does support all the same CSS hacks as the SCSS parser, though.
     class CssParser < StaticParser
-      # Parse a selector, and return its value as a string.
-      #
-      # @return [String, nil] The parsed selector, or nil if no selector was parsed
-      # @raise [Sass::SyntaxError] if there's a syntax error in the selector
-      def parse_selector_string
-        init_scanner!
-        str {return unless selector}
-      end
-
       private
 
       def placeholder_selector; nil; end
       def parent_selector; nil; end
       def interpolation; nil; end
-      def interp_string; tok(STRING); end
-      def interp_ident(ident = IDENT); tok(ident); end
       def use_css_import?; true; end
 
       def block_child(context)

data/lib/sass/scss/parser.rb

@@ -40,6 +40,18 @@ module Sass
         interp_ident
       end
 
+      # Parses a media query list.
+      #
+      # @return [Sass::Media::QueryList] The parsed query list
+      # @raise [Sass::SyntaxError] if there's a syntax error in the query list,
+      #   or if it doesn't take up the entire input string.
+      def parse_media_query_list
+        init_scanner!
+        ql = media_query_list
+        expected("media query list") unless @scanner.eos?
+        ql
+      end
+
       private
 
       include Sass::SCSS::RX
@@ -122,10 +134,11 @@ module Sass
         end
 
         # Most at-rules take expressions (e.g. @import),
-        # but some (e.g. @page) take selector-like arguments
-        val = str {break unless expr}
-        val ||= CssParser.new(@scanner, @line).parse_selector_string
-        node = node(Sass::Tree::DirectiveNode.new("@#{name} #{val}".strip))
+        # but some (e.g. @page) take selector-like arguments.
+        # Some take no arguments at all.
+        val = expr || selector
+        val = val ? ["@#{name} "] + Sass::Util.strip_string_array(val) : ["@#{name}"]
+        node = node(Sass::Tree::DirectiveNode.new(val))
 
         if tok(/\{/)
           node.has_children = true
@@ -277,14 +290,21 @@ module Sass
       end
 
       def import_arg
-        return unless arg = tok(STRING) || (uri = tok!(URI))
-        path = @scanner[1] || @scanner[2] || @scanner[3]
+        return unless (str = tok(STRING)) || (uri = tok?(/url\(/i))
+        if uri
+          str = sass_script(:parse_string)
+          media = str {media_query_list}.strip
+          media = " #{media}" unless media.empty?
+          ss
+          return node(Tree::DirectiveNode.new(["@import ", str, media]))
+        end
+
+        path = @scanner[1] || @scanner[2]
         ss
 
         media = str {media_query_list}.strip
-
-        if uri || path =~ /^http:\/\// || !media.strip.empty? || use_css_import?
-          return node(Sass::Tree::DirectiveNode.new("@import #{arg} #{media}".strip))
+        if path =~ /^http:\/\// || !media.empty? || use_css_import?
+          return node(Sass::Tree::DirectiveNode.new(["@import #{str} #{media}"]))
         end
 
         node(Sass::Tree::ImportNode.new(path.strip))
@@ -298,52 +318,66 @@ module Sass
 
       # http://www.w3.org/TR/css3-mediaqueries/#syntax
       def media_query_list
-        has_q = false
-        q = str {has_q = media_query}
-
-        return unless has_q
-        queries = [q.strip]
+        return unless query = media_query
+        queries = [query]
 
         ss
         while tok(/,/)
-          ss; queries << str {expr!(:media_query)}.strip; ss
+          ss; queries << expr!(:media_query)
         end
+        ss
 
-        queries
+        Sass::Media::QueryList.new(queries)
       end
 
       def media_query
-        if tok(/only|not/i)
+        if ident1 = interp_ident_or_var
           ss
-          @expected = "media type (e.g. print, screen)"
-          tok!(IDENT)
+          ident2 = interp_ident_or_var
           ss
-        elsif !tok(IDENT) && !media_expr
-          return
+          if ident2 && ident2.length == 1 && ident2[0].is_a?(String) && ident2[0].downcase == 'and'
+            query = Sass::Media::Query.new([], ident1, [])
+          else
+            if ident2
+              query = Sass::Media::Query.new(ident1, ident2, [])
+            else
+              query = Sass::Media::Query.new([], ident1, [])
+            end
+            return query unless tok(/and/i)
+            ss
+          end
+        end
+
+        if query
+          expr = expr!(:media_expr)
+        else
+          return unless expr = media_expr
         end
+        query ||= Sass::Media::Query.new([], [], [])
+        query.expressions << expr
 
         ss
         while tok(/and/i)
-          ss; expr!(:media_expr); ss
+          ss; query.expressions << expr!(:media_expr)
         end
 
-        true
+        query
       end
 
       def media_expr
         return unless tok(/\(/)
         ss
         @expected = "media feature (e.g. min-device-width, color)"
-        tok!(IDENT)
+        name = expr!(:interp_ident_or_var)
         ss
 
         if tok(/:/)
-          ss; expr!(:expr)
+          ss; value = expr!(:expr)
         end
         tok!(/\)/)
         ss
 
-        true
+        Sass::Media::Expression.new(name, value || [])
       end
 
       def charset_directive
@@ -371,10 +405,6 @@ module Sass
         str {ss if tok(/[\/,:.=]/)}
       end
 
-      def unary_operator
-        tok(/[+-]/)
-      end
-
       def ruleset
         return unless rules = selector_sequence
         block(node(Sass::Tree::RuleNode.new(rules.flatten.compact)), :ruleset)
@@ -507,9 +537,9 @@ module Sass
 
       def simple_selector_sequence
         # This allows for stuff like http://www.w3.org/TR/css3-animations/#keyframes-
-        return expr unless e = element_name || id_selector || class_selector ||
-          placeholder_selector || attrib || negation || pseudo || parent_selector ||
-          interpolation_selector
+        return expr(!:allow_var) unless e = element_name || id_selector ||
+          class_selector || placeholder_selector || attrib || negation ||
+          pseudo || parent_selector || interpolation_selector
         res = [e]
 
         # The tok(/\*/) allows the "E*" hack
@@ -698,17 +728,6 @@ module Sass
         return space, sass_script(:parse)
       end
 
-      def plain_value
-        return unless tok(/:/)
-        space = !str {ss}.empty?
-        @use_property_exception ||= space || !tok?(IDENT)
-
-        expression = expr
-        expression << tok(IMPORTANT) if expression
-        # expression, space, value
-        return expression, space, expression || [""]
-      end
-
       def nested_properties!(node, space)
         err(<<MESSAGE) unless space
 Invalid CSS: a space is required between a property and its definition
@@ -720,43 +739,53 @@ MESSAGE
         block(node, :property)
       end
 
-      def expr
-        return unless t = term
+      def expr(allow_var = true)
+        return unless t = term(allow_var)
         res = [t, str{ss}]
 
-        while (o = operator) && (t = term)
+        while (o = operator) && (t = term(allow_var))
           res << o << t << str{ss}
         end
 
-        res
+        res.flatten
       end
 
-      def term
-        unless e = tok(NUMBER) ||
+      def term(allow_var)
+        if e = tok(NUMBER) ||
             tok(URI) ||
-            function ||
+            function(allow_var) ||
             tok(STRING) ||
             tok(UNICODERANGE) ||
-            tok(IDENT) ||
-            tok(HEXCOLOR)
-
-          return unless op = unary_operator
-          @expected = "number or function"
-          return [op, tok(NUMBER) || expr!(:function)]
+            interp_ident ||
+            tok(HEXCOLOR) ||
+            (allow_var && var_expr)
+          return e
         end
-        e
+
+        return unless op = tok(/[+-]/)
+        @expected = "number or function"
+        return [op, tok(NUMBER) || function(allow_var) ||
+          (allow_var && var_expr) || expr!(:interpolation)]
       end
 
-      def function
+      def function(allow_var)
         return unless name = tok(FUNCTION)
         if name == "expression(" || name == "calc("
           str, _ = Sass::Shared.balance(@scanner, ?(, ?), 1)
           [name, str]
         else
-          [name, str{ss}, expr, tok!(/\)/)]
+          [name, str{ss}, expr(allow_var), tok!(/\)/)]
         end
       end
 
+      def var_expr
+        return unless tok(/\$/)
+        line = @line
+        var = Sass::Script::Variable.new(tok!(IDENT))
+        var.line = line
+        var
+      end
+
       def interpolation
         return unless tok(INTERP_START)
         sass_script(:parse_interpolated)
@@ -789,6 +818,11 @@ MESSAGE
         res
       end
 
+      def interp_ident_or_var
+        (id = interp_ident) and return id
+        (var = var_expr) and return [var]
+      end
+
       def interp_name
         interp_ident NAME
       end
@@ -841,7 +875,7 @@ MESSAGE
 
       EXPR_NAMES = {
         :media_query => "media query (e.g. print, screen, print and screen)",
-        :media_expr => "media expression (e.g. (min-device-width: 800px)))",
+        :media_expr => "media expression (e.g. (min-device-width: 800px))",
         :pseudo_expr => "expression (e.g. fr, 2n+1)",
         :interp_ident => "identifier",
         :interp_name => "identifier",

data/lib/sass/scss/static_parser.rb

@@ -27,6 +27,7 @@ module Sass
       def variable; nil; end
       def script_value; nil; end
       def interpolation; nil; end
+      def var_expr; nil; end
       def interp_string; s = tok(STRING) and [s]; end
       def interp_ident(ident = IDENT); s = tok(ident) and [s]; end
       def use_css_import?; true; end

data/lib/sass/selector.rb

@@ -379,7 +379,7 @@ module Sass
       attr_reader :selector
 
       # @param [String] The name of the pseudoclass
-      # @param [Selector::Sequence] The selector argument
+      # @param [Selector::CommaSequence] The selector argument
       def initialize(name, selector)
         @name = name
         @selector = selector

data/lib/sass/tree/directive_node.rb

@@ -9,15 +9,29 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class DirectiveNode < Node
-    # The text of the directive, `@` and all.
+    # The text of the directive, `@` and all, with interpolation included.
     #
-    # @return [String]
+    # @return [Array<String, Sass::Script::Node>]
     attr_accessor :value
 
-    # @param value [String] See \{#value}
+    # The text of the directive after any interpolated SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @param value [Array<String, Sass::Script::Node>] See \{#value}
     def initialize(value)
       @value = value
       super()
     end
+
+    # @param value [String] See \{#resolved_value}
+    # @return [DirectiveNode]
+    def self.resolved(value)
+      node = new([value])
+      node.resolved_value = value
+      node
+    end
   end
 end

data/lib/sass/tree/media_node.rb

@@ -6,9 +6,9 @@ module Sass::Tree
   #
   # @see Sass::Tree
   class MediaNode < DirectiveNode
-    # The media query. A list of comma-separated queries (e.g. `print` or `screen`).
+    # The media query.
     #
-    # @return [Array<String>]
+    # @return [Sass::Media::Query]
     attr_accessor :query
 
     # @see RuleNode#tabs
@@ -17,7 +17,7 @@ module Sass::Tree
     # @see RuleNode#group_end
     attr_accessor :group_end
 
-    # @param query [Array<String>] See \{#query}
+    # @param query [Sass::Media::Query] See \{#query}
     def initialize(query)
       @query = query
       @tabs = 0
@@ -25,8 +25,11 @@ module Sass::Tree
     end
 
     # @see DirectiveNode#value
-    def value
-      "@media #{query.join(', ')}"
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||= "@media #{query.to_css}"
     end
   end
 end

data/lib/sass/tree/visitors/convert.rb

@@ -49,11 +49,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_comment(node)
-    value = node.value.map do |r|
-      next r if r.is_a?(String)
-      "\#{#{r.to_sass(@options)}}"
-    end.join
-
+    value = interp_to_src(node.value)
     content = if @format == :sass
       content = value.gsub(/\*\/$/, '').rstrip
       if content =~ /\A[ \t]/
@@ -91,7 +87,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       end.gsub(/^/, spaces) + "\n"
       content
     end
-    content.sub!(%r{^\s*(/\*)}, '/*!') if node.type == :loud
+    content.sub!(%r{^\s*(/\*)}, '/*!') if node.type == :loud #'
     content
   end
 
@@ -100,7 +96,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_directive(node)
-    res = "#{tab_str}#{node.value}"
+    res = "#{tab_str}#{interp_to_src(node.value)}"
+    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2');
     return res + "#{semi}\n" unless node.has_children
     res + yield + "\n"
   end
@@ -148,7 +145,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_media(node)
-    "#{tab_str}@media #{node.query.join(', ')}#{yield}"
+    "#{tab_str}@media #{node.query.to_src(@options)}#{yield}"
   end
 
   def visit_mixindef(node)
@@ -171,7 +168,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_mixin(node)
     unless node.args.empty? && node.keywords.empty?
       args = node.args.map {|a| a.to_sass(@options)}.join(", ")
-      keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+      keywords = Sass::Util.hash_to_a(node.keywords).
+        map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
@@ -221,6 +219,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   private
 
+  def interp_to_src(interp)
+    interp.map do |r|
+      next r if r.is_a?(String)
+      "\#{#{r.to_sass(@options)}}"
+    end.join
+  end
+
   def selector_to_src(sel)
     @format == :sass ? selector_to_sass(sel) : selector_to_scss(sel)
   end
@@ -236,8 +241,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def selector_to_scss(sel)
-    sel.map {|r| r.is_a?(String) ? r : "\#{#{r.to_sass(@options)}}"}.
-      join.gsub(/^[ \t]*/, tab_str).gsub(/[ \t]*$/, '')
+    interp_to_src(sel).gsub(/^[ \t]*/, tab_str).gsub(/[ \t]*$/, '')
   end
 
   def semi