sass 3.3.0 → 3.4.0

data/lib/sass/source/map.rb

@@ -68,12 +68,6 @@ module Sass::Source
     # it will be inferred from `:css_path` and `:sourcemap_path` using the
     # assumption that the local file system has the same layout as the server.
     #
-    # If any source stylesheets use the default filesystem importer, sourcemap
-    # generation will fail unless the `:sourcemap_path` option is specified.
-    # The layout of the local file system is assumed to be the same as the
-    # layout of the server for the purposes of linking to source stylesheets
-    # that use the filesystem importer.
-    #
     # Regardless of which options are passed to this method, source stylesheets
     # that are imported using a non-default importer will only be linked to in
     # the source map if their importers implement
@@ -85,6 +79,8 @@ module Sass::Source
     #   The local path of the CSS output file.
     # @option options :sourcemap_path [String]
     #   The (eventual) local path of the sourcemap file.
+    # @option options :type [Symbol]
+    #   `:auto` (default),  `:file`, or `:inline`.
     # @return [String] The JSON string.
     # @raise [ArgumentError] If neither `:css_uri` nor `:css_path` and
     #   `:sourcemap_path` are specified.
@@ -97,15 +93,16 @@ module Sass::Source
         raise ArgumentError.new("Sass::Source::Map#to_json requires either " \
           "the :css_uri option or both the :css_path and :soucemap_path options.")
       end
-      css_path &&= Pathname.pwd.join(Sass::Util.pathname(css_path)).cleanpath
-      sourcemap_path &&= Pathname.pwd.join(Sass::Util.pathname(sourcemap_path)).cleanpath
-      css_uri ||= css_path.relative_path_from(sourcemap_path.dirname).to_s
+      css_path &&= Sass::Util.pathname(Sass::Util.absolute_path(css_path))
+      sourcemap_path &&= Sass::Util.pathname(Sass::Util.absolute_path(sourcemap_path))
+      css_uri ||= Sass::Util.file_uri_from_path(css_path.relative_path_from(sourcemap_path.dirname))
 
       result = "{\n"
       write_json_field(result, "version", 3, true)
 
       source_uri_to_id = {}
       id_to_source_uri = {}
+      id_to_contents = {} if options[:type] == :inline
       next_source_id = 0
       line_data = []
       segment_data_for_line = []
@@ -119,9 +116,15 @@ module Sass::Source
 
       @data.each do |m|
         file, importer = m.input.file, m.input.importer
-        source_uri = importer &&
-          importer.public_url(file, sourcemap_path && sourcemap_path.dirname.to_s)
-        next unless source_uri
+
+        if options[:type] == :inline
+          source_uri = file
+        else
+          sourcemap_dir = sourcemap_path && sourcemap_path.dirname.to_s
+          sourcemap_dir = nil if options[:type] == :file
+          source_uri = importer && importer.public_url(file, sourcemap_dir)
+          next unless source_uri
+        end
 
         current_source_id = source_uri_to_id[source_uri]
         unless current_source_id
@@ -130,6 +133,11 @@ module Sass::Source
 
           source_uri_to_id[source_uri] = current_source_id
           id_to_source_uri[current_source_id] = source_uri
+
+          if options[:type] == :inline
+            id_to_contents[current_source_id] =
+              importer.find(file, {}).instance_variable_get('@template')
+          end
         end
 
         [
@@ -174,6 +182,12 @@ module Sass::Source
       source_names = []
       (0...next_source_id).each {|id| source_names.push(id_to_source_uri[id].to_s)}
       write_json_field(result, "sources", source_names)
+
+      if options[:type] == :inline
+        write_json_field(result, "sourcesContent",
+          (0...next_source_id).map {|id| id_to_contents[id]})
+      end
+
       write_json_field(result, "names", [])
       write_json_field(result, "file", css_uri)
 

data/lib/sass/stack.rb

@@ -107,12 +107,6 @@ module Sass
       end.join("\n")
     end
 
-    def deep_copy
-      stack = Stack.new
-      stack.frames.replace frames
-      stack
-    end
-
     private
 
     def with_frame(filename, line, type, name = nil)

data/lib/sass/supports.rb

@@ -203,8 +203,7 @@ module Sass::Supports
     end
 
     def perform(env)
-      val = value.perform(env)
-      @resolved_value = val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s
+      @resolved_value = value.perform(env).to_s(:quote => :none)
     end
 
     def to_css
@@ -212,7 +211,7 @@ module Sass::Supports
     end
 
     def to_src(options)
-      "\#{#{@value.to_sass(options)}}"
+      @value.to_sass(options)
     end
 
     def deep_copy

data/lib/sass/tree/at_root_node.rb

@@ -70,6 +70,7 @@ module Sass
       # @return [Boolean]
       def exclude_node?(node)
         return exclude?(node.name.gsub(/^@/, '')) if node.is_a?(Sass::Tree::DirectiveNode)
+        return exclude?('keyframes') if node.is_a?(Sass::Tree::KeyframeRuleNode)
         exclude?('rule') && node.is_a?(Sass::Tree::RuleNode)
       end
 

data/lib/sass/tree/charset_node.rb

@@ -1,5 +1,5 @@
 module Sass::Tree
-  # A static node representing an unproccessed Sass `@charset` directive.
+  # A static node representing an unprocessed Sass `@charset` directive.
   #
   # @see Sass::Tree
   class CharsetNode < Node

data/lib/sass/tree/directive_node.rb

@@ -1,5 +1,5 @@
 module Sass::Tree
-  # A static node representing an unproccessed Sass `@`-directive.
+  # A static node representing an unprocessed Sass `@`-directive.
   # Directives known to Sass, like `@for` and `@debug`,
   # are handled by their own nodes;
   # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
@@ -43,7 +43,13 @@ module Sass::Tree
 
     # @return [String] The name of the directive, including `@`.
     def name
-      value.first.gsub(/ .*$/, '')
+      @name ||= value.first.gsub(/ .*$/, '')
+    end
+
+    # Strips out any vendor prefixes and downcases the directive name.
+    # @return [String] The normalized name of the directive.
+    def normalized_name
+      @normalized_name ||= name.gsub(/^(@)(?:-[a-zA-Z0-9]+-)?/, '\1').downcase
     end
 
     def bubbles?

data/lib/sass/tree/error_node.rb

@@ -0,0 +1,18 @@
+module Sass
+  module Tree
+    # A dynamic node representing a Sass `@error` statement.
+    #
+    # @see Sass::Tree
+    class ErrorNode < Node
+      # The expression to print.
+      # @return [Script::Tree::Node]
+      attr_accessor :expr
+
+      # @param expr [Script::Tree::Node] The expression to print
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+    end
+  end
+end

data/lib/sass/tree/extend_node.rb

@@ -1,7 +1,7 @@
 require 'sass/tree/node'
 
 module Sass::Tree
-  # A static node reprenting an `@extend` directive.
+  # A static node representing an `@extend` directive.
   #
   # @see Sass::Tree
   class ExtendNode < Node

data/lib/sass/tree/function_node.rb

@@ -29,6 +29,10 @@ module Sass
         @args = args
         @splat = splat
         super()
+
+        if %w[and or not].include?(name)
+          raise Sass::SyntaxError.new("Invalid function name \"#{name}\".")
+        end
       end
     end
   end

data/lib/sass/tree/keyframe_rule_node.rb

@@ -0,0 +1,15 @@
+module Sass::Tree
+  class KeyframeRuleNode < Node
+    # The text of the directive after any interpolated SassScript has been resolved.
+    # Since this is only a static node, this is the only value property.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    # @param resolved_value [String] See \{#resolved_value}
+    def initialize(resolved_value)
+      @resolved_value = resolved_value
+      super()
+    end
+  end
+end

data/lib/sass/tree/prop_node.rb

@@ -97,7 +97,7 @@ module Sass::Tree
     # @param opts [{Symbol => Object}] The options hash for the tree.
     # @param fmt [Symbol] `:scss` or `:sass`.
     def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
+      name = self.name.map {|n| n.is_a?(String) ? n : n.to_sass(opts)}.join
       if name[0] == ?:
         raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\"" +
                                     " hack is not allowed in the Sass indented syntax")

data/lib/sass/tree/rule_node.rb

@@ -1,7 +1,7 @@
 require 'pathname'
 
 module Sass::Tree
-  # A static node reprenting a CSS rule.
+  # A static node representing a CSS rule.
   #
   # @see Sass::Tree
   class RuleNode < Node
@@ -60,15 +60,20 @@ module Sass::Tree
     # @return [String]
     attr_accessor :stack_trace
 
-    # @param rule [Array<String, Sass::Script::Tree::Node>]
+    # @param rule [Array<String, Sass::Script::Tree::Node>, Sass::Selector::CommaSequence]
+    #   The CSS rule, either unparsed or parsed.
     # @param selector_source_range [Sass::Source::Range]
-    #   The CSS rule. See \{#rule}
     def initialize(rule, selector_source_range = nil)
-      merged = Sass::Util.merge_adjacent_strings(rule)
-      @rule = Sass::Util.strip_string_array(merged)
+      if rule.is_a?(Sass::Selector::CommaSequence)
+        @rule = [rule.to_s]
+        @parsed_rules = rule
+      else
+        merged = Sass::Util.merge_adjacent_strings(rule)
+        @rule = Sass::Util.strip_string_array(merged)
+        try_to_parse_non_interpolated_rules
+      end
       @selector_source_range = selector_source_range
       @tabs = 0
-      try_to_parse_non_interpolated_rules
       super()
     end
 
@@ -130,7 +135,7 @@ module Sass::Tree
       if @rule.all? {|t| t.kind_of?(String)}
         # We don't use real filename/line info because we don't have it yet.
         # When we get it, we'll set it on the parsed rules if possible.
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, '', nil, 1)
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
         # rubocop:disable RescueModifier
         @parsed_rules = parser.parse_selector rescue nil
         # rubocop:enable RescueModifier

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

@@ -23,13 +23,34 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   SCRIPT_NODES = [Sass::Tree::ImportNode] + CONTROL_NODES
   def visit_children(parent)
     old_parent = @parent
-    @parent = parent unless is_any_of?(parent, SCRIPT_NODES) ||
-      (parent.bubbles? && !old_parent.is_a?(Sass::Tree::RootNode))
+
+    # When checking a static tree, resolve at-roots to be sure they won't send
+    # nodes where they don't belong.
+    if parent.is_a?(Sass::Tree::AtRootNode) && parent.resolved_value
+      old_parents = @parents
+      @parents = @parents.reject {|p| parent.exclude_node?(p)}
+      @parent = Sass::Util.enum_with_index(@parents.reverse).
+        find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
+
+      begin
+        return super
+      ensure
+        @parents = old_parents
+        @parent = old_parent
+      end
+    end
+
+    unless transparent_parent?(parent, old_parent)
+      @parent = parent
+    end
+
     @parents.push parent
-    super
-  ensure
-    @parent = old_parent
-    @parents.pop
+    begin
+      super
+    ensure
+      @parent = old_parent
+      @parents.pop
+    end
   end
 
   def visit_root(node)
@@ -102,7 +123,7 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   VALID_FUNCTION_CHILDREN = [
     Sass::Tree::CommentNode,  Sass::Tree::DebugNode, Sass::Tree::ReturnNode,
-    Sass::Tree::VariableNode, Sass::Tree::WarnNode
+    Sass::Tree::VariableNode, Sass::Tree::WarnNode, Sass::Tree::ErrorNode
   ] + CONTROL_NODES
   def invalid_function_child?(parent, child)
     unless is_any_of?(child, VALID_FUNCTION_CHILDREN)
@@ -119,9 +140,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     end
   end
 
-  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::PropNode,
-                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode,
-                        Sass::Tree::MixinNode]
+  VALID_PROP_PARENTS = [Sass::Tree::RuleNode, Sass::Tree::KeyframeRuleNode, Sass::Tree::PropNode,
+                        Sass::Tree::MixinDefNode, Sass::Tree::DirectiveNode, Sass::Tree::MixinNode]
   def invalid_prop_parent?(parent, child)
     unless is_any_of?(parent, VALID_PROP_PARENTS)
       "Properties are only allowed within rules, directives, mixin includes, or other properties." +
@@ -135,6 +155,14 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
 
   private
 
+  # Whether `parent` should be assigned to `@parent`.
+  def transparent_parent?(parent, grandparent)
+    is_any_of?(parent, SCRIPT_NODES) ||
+      (parent.bubbles? &&
+       !grandparent.is_a?(Sass::Tree::RootNode) &&
+       !grandparent.is_a?(Sass::Tree::AtRootNode))
+  end
+
   def is_any_of?(val, classes)
     classes.each do |c|
       return true if val.is_a?(c)

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

@@ -96,6 +96,10 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@debug #{node.expr.to_sass(@options)}#{semi}\n"
   end
 
+  def visit_error(node)
+    "#{tab_str}@error #{node.expr.to_sass(@options)}#{semi}\n"
+  end
+
   def visit_directive(node)
     res = "#{tab_str}#{interp_to_src(node.value)}"
     res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2')
@@ -236,12 +240,13 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_rule(node)
+    rule = node.parsed_rules ? [node.parsed_rules.to_s] : node.rule
     if @format == :sass
-      name = selector_to_sass(node.rule)
+      name = selector_to_sass(rule)
       name = "\\" + name if name[0] == ?:
       name.gsub(/^/, tab_str) + yield
     elsif @format == :scss
-      name = selector_to_scss(node.rule)
+      name = selector_to_scss(rule)
       res = name + yield
       if node.children.last.is_a?(Sass::Tree::CommentNode) && node.children.last.type == :silent
         res.slice!(-3..-1)
@@ -278,26 +283,19 @@ 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
+    interp.map {|r| r.is_a?(String) ? r : r.to_sass(@options)}.join
   end
 
   # Like interp_to_src, but removes the unnecessary `#{}` around the keys and
   # values in query expressions.
   def query_interp_to_src(interp)
-    Sass::Util.enum_with_index(interp).map do |r, i|
-      next r if r.is_a?(String)
-      before, after = interp[i - 1], interp[i + 1]
-      if before.is_a?(String) && after.is_a?(String) &&
-          ((before[-1] == ?( && after[0] == ?:) ||
-           (before =~ /:\s*/ && after[0] == ?)))
-        r.to_sass(@options)
-      else
-        "\#{#{r.to_sass(@options)}}"
-      end
-    end.join
+    interp = interp.map do |e|
+      next e unless e.is_a?(Sass::Script::Tree::Literal)
+      next e unless e.value.is_a?(Sass::Script::Value::String)
+      e.value.value
+    end
+
+    interp_to_src(interp)
   end
 
   def selector_to_src(sel)
@@ -309,7 +307,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
       if r.is_a?(String)
         r.gsub(/(,)?([ \t]*)\n\s*/) {$1 ? "#{$1}#{$2}\n" : " "}
       else
-        "\#{#{r.to_sass(@options)}}"
+        r.to_sass(@options)
       end
     end.join
   end

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,6 +211,14 @@ 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
@@ -249,7 +236,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 +303,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

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

@@ -207,6 +207,17 @@ 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)
@@ -377,18 +388,31 @@ 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
+      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 +429,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
@@ -466,10 +478,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,7 +502,7 @@ 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
@@ -500,10 +515,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