sass 3.3.0 → 3.4.25

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

@@ -123,29 +123,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Registers an extension in the `@extends` subset map.
   def visit_extend(node)
-    node.resolved_selector.members.each do |seq|
-      if seq.members.size > 1
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
-      end
-
-      sseq = seq.members.first
-      if !sseq.is_a?(Sass::Selector::SimpleSequence)
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
-      elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
-        raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend parent selectors")
-      end
-
-      sel = sseq.members
-      parent.resolved_rules.members.each do |member|
-        unless member.members.last.is_a?(Sass::Selector::SimpleSequence)
-          raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
-        end
-
-        parent_directives = @parents.select {|p| p.is_a?(Sass::Tree::DirectiveNode)}
-        @extends[sel] = Extend.new(member, sel, node, parent_directives, :not_found)
-      end
-    end
-
+    parent.resolved_rules.populate_extends(@extends, node.resolved_selector, node,
+      @parents.select {|p| p.is_a?(Sass::Tree::DirectiveNode)})
     []
   end
 
@@ -232,10 +211,22 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     rules
   end
 
+  def visit_keyframerule(node)
+    return node unless node.has_children
+
+    yield
+
+    debubble(node.children, node)
+  end
+
   # Bubbles a directive up through RuleNodes.
   def visit_directive(node)
     return node unless node.has_children
-    return bubble(node) if parent.is_a?(Sass::Tree::RuleNode)
+    if parent.is_a?(Sass::Tree::RuleNode)
+      # @keyframes shouldn't include the rule nodes, so we manually create a
+      # bubble that doesn't have the parent's contents for them.
+      return node.normalized_name == '@keyframes' ? Bubble.new(node) : bubble(node)
+    end
 
     yield
 
@@ -249,7 +240,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
       child.node.resolved_value == node.resolved_value
     end
 
-    if directive_exists
+    # We know empty @keyframes directives do nothing.
+    if directive_exists || node.name == '@keyframes'
       []
     else
       empty_node = node.dup
@@ -315,19 +307,31 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   #   omitted.
   # @return [List<Sass::Tree::Node, Bubble>]
   def debubble(children, parent = nil)
+    # Keep track of the previous parent so that we don't divide `parent`
+    # unnecessarily if the `@at-root` doesn't produce any new nodes (e.g.
+    # `@at-root {@extend %foo}`).
+    previous_parent = nil
+
     Sass::Util.slice_by(children) {|c| c.is_a?(Bubble)}.map do |(is_bubble, slice)|
       unless is_bubble
         next slice unless parent
-        new_parent = parent.dup
-        new_parent.children = slice
-        next new_parent
+        if previous_parent
+          previous_parent.children.push(*slice)
+          next []
+        else
+          previous_parent = new_parent = parent.dup
+          new_parent.children = slice
+          next new_parent
+        end
       end
 
-      next slice.map do |bubble|
+      slice.map do |bubble|
         next unless (node = block_given? ? yield(bubble.node) : bubble.node)
         node.tabs += bubble.tabs
         node.group_end = bubble.group_end
-        [visit(node)].flatten
+        results = [visit(node)].flatten
+        previous_parent = nil unless results.empty?
+        results
       end.compact
     end.flatten
   end

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

@@ -16,6 +16,11 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
     yield
   end
 
+  def visit_error(node)
+    node.expr = node.expr.deep_copy
+    yield
+  end
+
   def visit_each(node)
     node.list = node.list.deep_copy
     yield
@@ -50,7 +55,7 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   def visit_mixin(node)
     node.args = node.args.map {|a| a.deep_copy}
-    node.keywords = Hash[node.keywords.map {|k, v| [k, v.deep_copy]}]
+    node.keywords = Sass::Util::NormalizedMap.new(Hash[node.keywords.map {|k, v| [k, v.deep_copy]}])
     yield
   end
 

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

@@ -44,25 +44,27 @@ class Sass::Tree::Visitors::Extend < Sass::Tree::Visitors::Base
     node.resolved_rules = node.resolved_rules.do_extend(@extends, @parent_directives)
   end
 
-  private
+  class << self
+    private
 
-  def self.check_extends_fired!(extends)
-    extends.each_value do |ex|
-      next if ex.result == :succeeded || ex.node.optional?
-      message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
-      reason =
-        if ex.result == :not_found
-          "The selector \"#{ex.target.join}\" was not found."
-        else
-          "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
-        end
+    def check_extends_fired!(extends)
+      extends.each_value do |ex|
+        next if ex.result == :succeeded || ex.node.optional?
+        message = "\"#{ex.extender}\" failed to @extend \"#{ex.target.join}\"."
+        reason =
+          if ex.result == :not_found
+            "The selector \"#{ex.target.join}\" was not found."
+          else
+            "No selectors matching \"#{ex.target.join}\" could be unified with \"#{ex.extender}\"."
+          end
 
-      # TODO(nweiz): this should use the Sass stack trace of the extend node.
-      raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
+        # TODO(nweiz): this should use the Sass stack trace of the extend node.
+        raise Sass::SyntaxError.new(<<MESSAGE, :filename => ex.node.filename, :line => ex.node.line)
 #{message}
 #{reason}
 Use "@extend #{ex.target.join} !optional" if the extend should be able to fail.
 MESSAGE
+      end
     end
   end
 end

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

@@ -1,5 +1,7 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
+  @@function_name_deprecation = Sass::Deprecation.new
+
   class << self
     # @param root [Tree::Node] The root node of the tree to visit.
     # @param environment [Sass::Environment] The lexical environment.
@@ -11,7 +13,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     # @api private
     # @comment
     #   rubocop:disable MethodLength
-    def perform_arguments(callable, args, splat)
+    def perform_arguments(callable, args, splat, environment)
       desc = "#{callable.type.capitalize} #{callable.name}"
       downcase_desc = "#{callable.type} #{callable.name}"
 
@@ -41,20 +43,26 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       # raising happens in the ensure clause at the end of this function.
       return if keyword_exception && !callable.splat
 
-      if args.size > callable.args.size && !callable.splat
-        takes = callable.args.size
-        passed = args.size
-        raise Sass::SyntaxError.new(
-          "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
-          "but #{passed} #{passed == 1 ? 'was' : 'were'} passed.")
-      end
-
       splat_sep = :comma
       if splat
         args += splat.to_a
         splat_sep = splat.separator
       end
 
+      if args.size > callable.args.size && !callable.splat
+        extra_args_because_of_splat = splat && args.size - splat.to_a.size <= callable.args.size
+
+        takes = callable.args.size
+        passed = args.size
+        message = "#{desc} takes #{takes} argument#{'s' unless takes == 1} " +
+          "but #{passed} #{passed == 1 ? 'was' : 'were'} passed."
+        raise Sass::SyntaxError.new(message) unless extra_args_because_of_splat
+        # TODO: when the deprecation period is over, make this an error.
+        Sass::Util.sass_warn("WARNING: #{message}\n" +
+          environment.stack.to_s.gsub(/^/m, " " * 8) + "\n" +
+          "This will be an error in future versions of Sass.")
+      end
+
       env = Sass::Environment.new(callable.environment)
       callable.args.zip(args[0...callable.args.length]) do |(var, default), value|
         if value && keywords.has_key?(var.name)
@@ -144,6 +152,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
   def initialize(env)
     @environment = env
+    @in_keyframes = false
+    @at_root_without_rule = false
   end
 
   # If an exception is raised, this adds proper metadata to the backtrace.
@@ -207,11 +217,22 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     []
   end
 
+  # Throws the expression as an error.
+  def visit_error(node)
+    res = node.expr.perform(@environment)
+    if res.is_a?(Sass::Script::Value::String)
+      res = res.value
+    else
+      res = res.to_sass
+    end
+    raise Sass::SyntaxError.new(res)
+  end
+
   # Runs the child nodes once for each value in the list.
   def visit_each(node)
     list = node.list.perform(@environment)
 
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       list.to_a.map do |value|
         if node.vars.length == 1
           @environment.set_local_var(node.vars.first, value)
@@ -245,7 +266,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     direction = from.to_i > to.to_i ? -1 : 1
     range = Range.new(direction * from.to_i, direction * to.to_i, node.exclusive)
 
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       range.map do |i|
         @environment.set_local_var(node.var,
           Sass::Script::Value::Number.new(direction * i,
@@ -258,9 +279,18 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Loads the function into the environment.
   def visit_function(node)
     env = Sass::Environment.new(@environment, node.options)
+
+    if node.normalized_name == 'calc' || node.normalized_name == 'element' ||
+        node.name == 'expression' || node.name == 'url'
+      @@function_name_deprecation.warn(node.filename, node.line, <<WARNING)
+Naming a function "#{node.name}" is disallowed and will be an error in future versions of Sass.
+This name conflicts with an existing CSS function with special parse rules.
+WARNING
+    end
+
     @environment.set_local_function(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, !:has_content, "function"))
+                         node.children, false, "function"))
     []
   end
 
@@ -268,8 +298,9 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # otherwise, tries the else nodes.
   def visit_if(node)
     if node.expr.nil? || node.expr.perform(@environment).to_bool
-      yield
-      node.children
+      with_environment Sass::SemiGlobalEnvironment.new(@environment) do
+        node.children.map {|c| visit(c)}
+      end.flatten
     elsif node.else
       visit(node.else)
     else
@@ -282,6 +313,7 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_import(node)
     if (path = node.css_import?)
       resolved_node = Sass::Tree::CssImportNode.resolved("url(#{path})")
+      resolved_node.options = node.options
       resolved_node.source_range = node.source_range
       return resolved_node
     end
@@ -320,14 +352,14 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
       raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin
 
       if node.children.any? && !mixin.has_content
-        raise Sass::SyntaxError.new(%Q{Mixin "#{node.name}" does not accept a content block.})
+        raise Sass::SyntaxError.new(%(Mixin "#{node.name}" does not accept a content block.))
       end
 
       args = node.args.map {|a| a.perform(@environment)}
       keywords = Sass::Util.map_vals(node.keywords) {|v| v.perform(@environment)}
       splat = self.class.perform_splat(node.splat, keywords, node.kwarg_splat, @environment)
 
-      self.class.perform_arguments(mixin, args, splat) do |env|
+      self.class.perform_arguments(mixin, args, splat, @environment) do |env|
         env.caller = Sass::Environment.new(@environment)
         env.content = [node.children, @environment] if node.has_children
 
@@ -377,18 +409,32 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
-    old_at_root_without_rule, @at_root_without_rule = @at_root_without_rule, false
+    old_at_root_without_rule = @at_root_without_rule
     parser = Sass::SCSS::StaticParser.new(run_interp(node.rule),
       node.filename, node.options[:importer], node.line)
-    node.parsed_rules ||= parser.parse_selector
-    node.resolved_rules = node.parsed_rules.resolve_parent_refs(
-      @environment.selector, !old_at_root_without_rule)
-    node.stack_trace = @environment.stack.to_s if node.options[:trace_selectors]
-    with_environment Sass::Environment.new(@environment, node.options) do
-      @environment.selector = node.resolved_rules
-      node.children = node.children.map {|c| visit(c)}.flatten
+    if @in_keyframes
+      keyframe_rule_node = Sass::Tree::KeyframeRuleNode.new(parser.parse_keyframes_selector)
+      keyframe_rule_node.options = node.options
+      keyframe_rule_node.line = node.line
+      keyframe_rule_node.filename = node.filename
+      keyframe_rule_node.source_range = node.source_range
+      keyframe_rule_node.has_children = node.has_children
+      with_environment Sass::Environment.new(@environment, node.options) do
+        keyframe_rule_node.children = node.children.map {|c| visit(c)}.flatten
+      end
+      keyframe_rule_node
+    else
+      @at_root_without_rule = false
+      node.parsed_rules ||= parser.parse_selector
+      node.resolved_rules = node.parsed_rules.resolve_parent_refs(
+        @environment.selector, !old_at_root_without_rule)
+      node.stack_trace = @environment.stack.to_s if node.options[:trace_selectors]
+      with_environment Sass::Environment.new(@environment, node.options) do
+        @environment.selector = node.resolved_rules
+        node.children = node.children.map {|c| visit(c)}.flatten
+      end
+      node
     end
-    node
   ensure
     @at_root_without_rule = old_at_root_without_rule
   end
@@ -405,36 +451,24 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     end
 
     old_at_root_without_rule = @at_root_without_rule
+    old_in_keyframes = @in_keyframes
     @at_root_without_rule = true if node.exclude?('rule')
+    @in_keyframes = false if node.exclude?('keyframes')
     yield
   ensure
+    @in_keyframes = old_in_keyframes
     @at_root_without_rule = old_at_root_without_rule
   end
 
   # Loads the new variable value into the environment.
   def visit_variable(node)
     env = @environment
-    identifier = [node.name, node.filename, node.line]
-    if node.global
-      env = env.global_env
-    elsif env.parent && env.is_var_global?(node.name) &&
-        !env.global_env.global_warning_given.include?(identifier)
-      env.global_env.global_warning_given.add(identifier)
-      var_expr = "$#{node.name}: #{node.expr.to_sass(env.options)} !global"
-      var_expr << " !default" if node.guarded
-      location = "on line #{node.line}"
-      location << " of #{node.filename}" if node.filename
-      Sass::Util.sass_warn <<WARNING
-DEPRECATION WARNING #{location}:
-Assigning to global variable "$#{node.name}" by default is deprecated.
-In future versions of Sass, this will create a new local variable.
-If you want to assign to the global variable, use "#{var_expr}" instead.
-Note that this will be incompatible with Sass 3.2.
-WARNING
+    env = env.global_env if node.global
+    if node.guarded
+      var = env.var(node.name)
+      return [] if var && !var.null?
     end
 
-    var = env.var(node.name)
-    return [] if node.guarded && var && !var.null?
     val = node.expr.perform(@environment)
     if node.expr.source_range
       val.source_range = node.expr.source_range
@@ -458,7 +492,7 @@ WARNING
   # Runs the child nodes until the continuation expression becomes false.
   def visit_while(node)
     children = []
-    with_environment Sass::Environment.new(@environment) do
+    with_environment Sass::SemiGlobalEnvironment.new(@environment) do
       children += node.children.map {|c| visit(c)} while node.expr.perform(@environment).to_bool
     end
     children.flatten
@@ -466,10 +500,13 @@ WARNING
 
   def visit_directive(node)
     node.resolved_value = run_interp(node.value)
+    old_in_keyframes, @in_keyframes = @in_keyframes, node.normalized_name == "@keyframes"
     with_environment Sass::Environment.new(@environment) do
       node.children = node.children.map {|c| visit(c)}.flatten
       node
     end
+  ensure
+    @in_keyframes = old_in_keyframes
   end
 
   def visit_media(node)
@@ -487,11 +524,14 @@ WARNING
 
   def visit_cssimport(node)
     node.resolved_uri = run_interp([node.uri])
-    if node.query
+    if node.query && !node.query.empty?
       parser = Sass::SCSS::StaticParser.new(run_interp(node.query),
         node.filename, node.options[:importer], node.line)
       node.resolved_query ||= parser.parse_media_query_list
     end
+    if node.supports_condition
+      node.supports_condition.perform(@environment)
+    end
     yield
   end
 
@@ -500,10 +540,7 @@ WARNING
   def run_interp_no_strip(text)
     text.map do |r|
       next r if r.is_a?(String)
-      val = r.perform(@environment)
-      # Interpolated strings should never render with quotes
-      next val.value if val.is_a?(Sass::Script::Value::String)
-      val.to_s
+      r.perform(@environment).to_s(:quote => :none)
     end.join
   end
 

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

@@ -15,11 +15,21 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
     super
   end
 
+  def visit_comment(node)
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
+    yield
+  end
+
   def visit_debug(node)
     node.expr.options = @options
     yield
   end
 
+  def visit_error(node)
+    node.expr.options = @options
+    yield
+  end
+
   def visit_each(node)
     node.list.options = @options
     yield
@@ -41,6 +51,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
       k.options = @options
       v.options = @options if v
     end
+    node.splat.options = @options if node.splat
     yield
   end
 
@@ -63,12 +74,15 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
       k.options = @options
       v.options = @options if v
     end
+    node.splat.options = @options if node.splat
     yield
   end
 
   def visit_mixin(node)
     node.args.each {|a| a.options = @options}
-    node.keywords.each {|k, v| v.options = @options}
+    node.keywords.each {|_k, v| v.options = @options}
+    node.splat.options = @options if node.splat
+    node.kwarg_splat.options = @options if node.kwarg_splat
     yield
   end