sass 3.2.7 → 3.3.0.rc.1

data/lib/sass/tree/prop_node.rb

@@ -1,14 +1,14 @@
 module Sass::Tree
-  # A static node reprenting a CSS property.
+  # A static node representing a CSS property.
   #
   # @see Sass::Tree
   class PropNode < Node
     # The name of the property,
-    # interspersed with {Sass::Script::Node}s
+    # interspersed with {Sass::Script::Tree::Node}s
     # representing `#{}`-interpolation.
     # Any adjacent strings will be merged together.
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :name
 
     # The name of the property
@@ -20,7 +20,7 @@ module Sass::Tree
 
     # The value of the property.
     #
-    # @return [Sass::Script::Node]
+    # @return [Sass::Script::Tree::Node]
     attr_accessor :value
 
     # The value of the property
@@ -42,8 +42,18 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
-    # @param name [Array<String, Sass::Script::Node>] See \{#name}
-    # @param value [Sass::Script::Node] See \{#value}
+    # The source range in which the property name appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :name_source_range
+
+    # The source range in which the property value appears.
+    #
+    # @return [Sass::Source::Range]
+    attr_accessor :value_source_range
+
+    # @param name [Array<String, Sass::Script::Tree::Node>] See \{#name}
+    # @param value [Sass::Script::Tree::Node] See \{#value}
     # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
     #   `:old` if it uses `:a b`-style syntax
     def initialize(name, value, prop_syntax)
@@ -70,7 +80,13 @@ module Sass::Tree
     #
     # @return [String] The message
     def pseudo_class_selector_message
-      return "" if @prop_syntax == :new || !value.is_a?(Sass::Script::String) || !value.value.empty?
+      if @prop_syntax == :new ||
+          !value.is_a?(Sass::Script::Tree::Literal) ||
+          !value.value.is_a?(Sass::Script::Value::String) ||
+          !value.value.value.empty?
+        return ""
+      end
+
       "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
     end
 
@@ -83,7 +99,8 @@ module Sass::Tree
     def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
       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")
+        raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\"" +
+                                    " hack is not allowed in the Sass indented syntax")
       end
 
       old = opts[:old] && fmt == :sass
@@ -104,7 +121,8 @@ module Sass::Tree
     def check!
       if @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
         raise Sass::SyntaxError.new(
-          "Illegal property syntax: can't use #{@prop_syntax} syntax when :property_syntax => #{@options[:property_syntax].inspect} is set.")
+          "Illegal property syntax: can't use #{@prop_syntax} syntax when " +
+          ":property_syntax => #{@options[:property_syntax].inspect} is set.")
       end
     end
 
@@ -117,34 +135,36 @@ module Sass::Tree
       private
 
       def val_to_sass_comma(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
+        return node unless node.is_a?(Sass::Script::Tree::Operation)
         return val_to_sass_concat(node, opts) unless node.operator == :comma
 
-        Sass::Script::Operation.new(
+        Sass::Script::Tree::Operation.new(
           val_to_sass_concat(node.operand1, opts),
           val_to_sass_comma(node.operand2, opts),
           node.operator)
       end
 
       def val_to_sass_concat(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
+        return node unless node.is_a?(Sass::Script::Tree::Operation)
         return val_to_sass_div(node, opts) unless node.operator == :space
 
-        Sass::Script::Operation.new(
+        Sass::Script::Tree::Operation.new(
           val_to_sass_div(node.operand1, opts),
           val_to_sass_concat(node.operand2, opts),
           node.operator)
       end
 
       def val_to_sass_div(node, opts)
-        unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
-            node.operand1.is_a?(Sass::Script::Number) &&
-            node.operand2.is_a?(Sass::Script::Number) &&
-            (!node.operand1.original || !node.operand2.original)
+        unless node.is_a?(Sass::Script::Tree::Operation) && node.operator == :div &&
+            node.operand1.is_a?(Sass::Script::Tree::Literal) &&
+            node.operand1.value.is_a?(Sass::Script::Value::Number) &&
+            node.operand2.is_a?(Sass::Script::Tree::Literal) &&
+            node.operand2.value.is_a?(Sass::Script::Value::Number) &&
+            (!node.operand1.value.original || !node.operand2.value.original)
           return node
         end
 
-        Sass::Script::String.new("(#{node.to_sass(opts)})")
+        Sass::Script::Value::String.new("(#{node.to_sass(opts)})")
       end
 
     end

data/lib/sass/tree/return_node.rb

@@ -5,10 +5,11 @@ module Sass
     # @see Sass::Tree
     class ReturnNode < Node
       # The expression to return.
-      # @type [Script::Node]
+      #
+      # @return [Script::Tree::Node]
       attr_accessor :expr
 
-      # @param expr [Script::Node] The expression to return
+      # @param expr [Script::Tree::Node] The expression to return
       def initialize(expr)
         @expr = expr
         super()

data/lib/sass/tree/root_node.rb

@@ -13,15 +13,31 @@ module Sass
         @template = template
       end
 
-      # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      # @see #to_s
+      # Runs the dynamic Sass code and computes the CSS for the tree.
+      #
+      # @return [String] The compiled CSS.
       def render
+        css_tree.css
+      end
+
+      # Runs the dynamic Sass code and computes the CSS for the tree, along with
+      # the sourcemap.
+      #
+      # @return [(String, Sass::Source::Map)] The compiled CSS, as well as
+      #   the source map. @see #render
+      def render_with_sourcemap
+        css_tree.css_with_sourcemap
+      end
+
+      private
+
+      def css_tree
         Visitors::CheckNesting.visit(self)
         result = Visitors::Perform.visit(self)
         Visitors::CheckNesting.visit(result) # Check again to validate mixins
         result, extends = Visitors::Cssize.visit(result)
         Visitors::Extend.visit(result, extends)
-        result.to_s
+        result
       end
     end
   end

data/lib/sass/tree/rule_node.rb

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'uri'
 
 module Sass::Tree
   # A static node reprenting a CSS rule.
@@ -10,24 +9,24 @@ module Sass::Tree
     PARENT = '&'
 
     # The CSS selector for this rule,
-    # interspersed with {Sass::Script::Node}s
+    # interspersed with {Sass::Script::Tree::Node}s
     # representing `#{}`-interpolation.
     # Any adjacent strings will be merged together.
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :rule
 
-    # The CSS selector for this rule,
-    # without any unresolved interpolation
-    # but with parent references still intact.
-    # It's only set once {Tree::Node#perform} has been called.
+    # The CSS selector for this rule, without any unresolved
+    # interpolation but with parent references still intact. It's only
+    # guaranteed to be set once {Tree::Visitors::Perform} has been
+    # run, but it may be set before then for optimization reasons.
     #
     # @return [Selector::CommaSequence]
     attr_accessor :parsed_rules
 
-    # The CSS selector for this rule,
-    # without any unresolved interpolation or parent references.
-    # It's only set once {Tree::Visitors::Cssize} has been run.
+    # The CSS selector for this rule, without any unresolved
+    # interpolation or parent references. It's only set once
+    # {Tree::Visitors::Perform} has been run.
     #
     # @return [Selector::CommaSequence]
     attr_accessor :resolved_rules
@@ -44,6 +43,10 @@ module Sass::Tree
     # @return [Fixnum]
     attr_accessor :tabs
 
+    # The entire selector source range for this rule.
+    # @return [Sass::Source::Range]
+    attr_accessor :selector_source_range
+
     # Whether or not this rule is the last rule in a nested group.
     # This is only set in a CSS tree.
     #
@@ -54,14 +57,16 @@ module Sass::Tree
     # This is only readable in a CSS tree as it is written during the perform step
     # and only when the :trace_selectors option is set.
     #
-    # @return [Array<String>]
+    # @return [String]
     attr_accessor :stack_trace
 
-    # @param rule [Array<String, Sass::Script::Node>]
+    # @param rule [Array<String, Sass::Script::Tree::Node>]
+    # @param selector_source_range [Sass::Source::Range]
     #   The CSS rule. See \{#rule}
-    def initialize(rule)
+    def initialize(rule, selector_source_range = nil)
       merged = Sass::Util.merge_adjacent_strings(rule)
       @rule = Sass::Util.strip_string_array(merged)
+      @selector_source_range = selector_source_range
       @tabs = 0
       try_to_parse_non_interpolated_rules
       super()
@@ -105,12 +110,13 @@ module Sass::Tree
 
     # A hash that will be associated with this rule in the CSS document
     # if the {file:SASS_REFERENCE.md#debug_info-option `:debug_info` option} is enabled.
-    # This data is used by e.g. [the FireSass Firebug extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
+    # This data is used by e.g. [the FireSass Firebug
+    # extension](https://addons.mozilla.org/en-US/firefox/addon/103988).
     #
     # @return [{#to_s => #to_s}]
     def debug_info
-      {:filename => filename && ("file://" + URI.escape(File.expand_path(filename))),
-       :line => self.line}
+      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
+       :line => line}
     end
 
     # A rule node is invisible if it has only placeholder selectors.
@@ -124,8 +130,10 @@ 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, '', 1)
+        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, '', nil, 1)
+        # rubocop:disable RescueModifier
         @parsed_rules = parser.parse_selector rescue nil
+        # rubocop:enable RescueModifier
       end
     end
   end

data/lib/sass/tree/supports_node.rb

@@ -1,8 +1,5 @@
 module Sass::Tree
   # A static node representing a `@supports` rule.
-  # `@supports` rules behave differently from other directives
-  # in that when they're nested within rules,
-  # they bubble up to top-level.
   #
   # @see Sass::Tree
   class SupportsNode < DirectiveNode
@@ -16,17 +13,10 @@ module Sass::Tree
     # @return [Sass::Supports::Condition]
     attr_accessor :condition
 
-    # @see RuleNode#tabs
-    attr_accessor :tabs
-
-    # @see RuleNode#group_end
-    attr_accessor :group_end
-
     # @param condition [Sass::Supports::Condition] See \{#condition}
     def initialize(name, condition)
       @name = name
       @condition = condition
-      @tabs = 0
       super('')
     end
 
@@ -44,8 +34,5 @@ module Sass::Tree
     def invisible?
       children.all? {|c| c.invisible?}
     end
-
-    # @see Node#bubbles?
-    def bubbles?; true; end
   end
 end

data/lib/sass/tree/trace_node.rb

@@ -7,6 +7,7 @@ module Sass::Tree
   # @see Sass::Tree
   class TraceNode < Node
     # The name of the trace entry to add.
+    #
     # @return [String]
     attr_reader :name
 
@@ -19,7 +20,7 @@ module Sass::Tree
 
     # Initializes this node from an existing node.
     # @param name [String] The name of the trace entry to add.
-    # @param mixin [Node] The node to copy information from.
+    # @param node [Node] The node to copy information from.
     # @return [TraceNode]
     def self.from_node(name, node)
       trace = new(name)

data/lib/sass/tree/variable_node.rb

@@ -9,20 +9,26 @@ module Sass
       attr_reader :name
 
       # The parse tree for the variable value.
-      # @return [Script::Node]
+      # @return [Script::Tree::Node]
       attr_accessor :expr
 
       # Whether this is a guarded variable assignment (`!default`).
       # @return [Boolean]
       attr_reader :guarded
 
+      # Whether this is a global variable assignment (`!global`).
+      # @return [Boolean]
+      attr_reader :global
+
       # @param name [String] The name of the variable
-      # @param expr [Script::Node] See \{#expr}
+      # @param expr [Script::Tree::Node] See \{#expr}
       # @param guarded [Boolean] See \{#guarded}
-      def initialize(name, expr, guarded)
+      # @param global [Boolean] See \{#global}
+      def initialize(name, expr, guarded, global)
         @name = name
         @expr = expr
         @guarded = guarded
+        @global = global
         super()
       end
     end

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

@@ -32,9 +32,9 @@ module Sass::Tree::Visitors
     # @param node [Tree::Node] The node to visit.
     # @return [Object] The return value of the `visit_*` method for this node.
     def visit(node)
-      method = "visit_#{node_name node}"
-      if self.respond_to?(method, true)
-        self.send(method, node) {visit_children(node)}
+      method = "visit_#{self.class.node_name node}"
+      if respond_to?(method, true)
+        send(method, node) {visit_children(node)}
       else
         visit_children(node)
       end
@@ -59,9 +59,9 @@ module Sass::Tree::Visitors
     #
     # @param [Tree::Node] node The node.
     # @return [String] The name.
-    def node_name(node)
-      @@node_names ||= {}
-      @@node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
+    def self.node_name(node)
+      @node_names ||= {}
+      @node_names[node.class.name] ||= node.class.name.gsub(NODE_NAME_RE, '\\1').downcase
     end
 
     # `yield`s, then runs the visitor on the `@else` clause if the node has one.

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

@@ -1,5 +1,6 @@
 # A visitor for checking that all nodes are properly nested.
 class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
+
   protected
 
   def initialize
@@ -7,9 +8,9 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   end
 
   def visit(node)
-    if error = @parent && (
-        try_send("invalid_#{node_name @parent}_child?", @parent, node) ||
-        try_send("invalid_#{node_name node}_parent?", @parent, node))
+    if (error = @parent && (
+        try_send("invalid_#{self.class.node_name @parent}_child?", @parent, node) ||
+        try_send("invalid_#{self.class.node_name node}_parent?", @parent, node)))
       raise Sass::SyntaxError.new(error)
     end
     super
@@ -19,7 +20,7 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   end
 
   CONTROL_NODES = [Sass::Tree::EachNode, Sass::Tree::ForNode, Sass::Tree::IfNode,
-    Sass::Tree::WhileNode, Sass::Tree::TraceNode]
+                   Sass::Tree::WhileNode, Sass::Tree::TraceNode]
   SCRIPT_NODES = [Sass::Tree::ImportNode] + CONTROL_NODES
   def visit_children(parent)
     old_parent = @parent
@@ -110,7 +111,9 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     end
   end
 
-  VALID_PROP_CHILDREN = [Sass::Tree::CommentNode, Sass::Tree::PropNode, Sass::Tree::MixinNode] + CONTROL_NODES
+  VALID_PROP_CHILDREN =  CONTROL_NODES + [Sass::Tree::CommentNode,
+                                          Sass::Tree::PropNode,
+                                          Sass::Tree::MixinNode]
   def invalid_prop_child?(parent, child)
     unless is_any_of?(child, VALID_PROP_CHILDREN)
       "Illegal nesting: Only properties may be nested beneath properties."
@@ -122,7 +125,8 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
                         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." + child.pseudo_class_selector_message
+      "Properties are only allowed within rules, directives, mixin includes, or other properties." +
+        child.pseudo_class_selector_message
     end
   end
 
@@ -133,10 +137,10 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
   private
 
   def is_any_of?(val, classes)
-    for c in classes
+    classes.each do |c|
       return true if val.is_a?(c)
     end
-    return false
+    false
   end
 
   def try_send(method, *args)
@@ -144,4 +148,3 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     send(method, *args)
   end
 end
-

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

@@ -23,7 +23,11 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_children(parent)
     @tabs += 1
     return @format == :sass ? "\n" : " {}\n" if parent.children.empty?
-    (@format == :sass ? "\n" : " {\n") + super.join.rstrip + (@format == :sass ? "\n" : "\n#{ @tab_chars * (@tabs-1)}}\n")
+    if @format == :sass
+      "\n"  + super.join.rstrip + "\n"
+    else
+      " {\n" + super.join.rstrip + "\n#{ @tab_chars * (@tabs - 1)}}\n"
+    end
   ensure
     @tabs -= 1
   end
@@ -52,7 +56,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_comment(node)
     value = interp_to_src(node.value)
-    content = if @format == :sass
+    if @format == :sass
       content = value.gsub(/\*\/$/, '').rstrip
       if content =~ /\A[ \t]/
         # Re-indent SCSS comments like this:
@@ -63,33 +67,28 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
         content.sub!(/\A([ \t]*)\/\*/, '/*\1')
       end
 
-      content =
-        unless content.include?("\n")
-          content
+      if content.include?("\n")
+        content.gsub!(%r{\n( \*|//)}, "\n  ")
+        spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
+        sep = node.type == :silent ? "\n//" : "\n *"
+        if spaces >= 2
+          content.gsub!(/\n  /, sep)
         else
-          content.gsub!(/\n( \*|\/\/)/, "\n  ")
-          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
-          sep = node.type == :silent ? "\n//" : "\n *"
-          if spaces >= 2
-            content.gsub(/\n  /, sep)
-          else
-            content.gsub(/\n#{' ' * spaces}/, sep)
-          end
+          content.gsub!(/\n#{' ' * spaces}/, sep)
         end
+      end
 
       content.gsub!(/\A\/\*/, '//') if node.type == :silent
       content.gsub!(/^/, tab_str)
-      content.rstrip + "\n"
+      content = content.rstrip + "\n"
     else
       spaces = (@tab_chars * [@tabs - value[/^ */].size, 0].max)
       content = if node.type == :silent
-        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-      else
-        value
-      end.gsub(/^/, spaces) + "\n"
-      content
+                  value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
+                else
+                  value
+                end.gsub(/^/, spaces) + "\n"
     end
-    content.sub!(%r{^\s*(/\*)}, '/*!') if node.type == :loud #'
     content
   end
 
@@ -99,17 +98,19 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_directive(node)
     res = "#{tab_str}#{interp_to_src(node.value)}"
-    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2');
+    res.gsub!(/^@import \#\{(.*)\}([^}]*)$/, '@import \1\2')
     return res + "#{semi}\n" unless node.has_children
     res + yield + "\n"
   end
 
   def visit_each(node)
-    "#{tab_str}@each $#{dasherize(node.var)} in #{node.list.to_sass(@options)}#{yield}"
+    vars = node.vars.map {|var| "$#{dasherize(var)}"}.join(", ")
+    "#{tab_str}@each #{vars} in #{node.list.to_sass(@options)}#{yield}"
   end
 
   def visit_extend(node)
-    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}#{" !optional" if node.optional?}\n"
+    "#{tab_str}@extend #{selector_to_src(node.selector).lstrip}#{semi}" +
+      "#{" !optional" if node.optional?}\n"
   end
 
   def visit_for(node)
@@ -131,9 +132,12 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
   def visit_if(node)
     name =
-      if !@is_else; "if"
-      elsif node.expr; "else if"
-      else; "else"
+      if !@is_else
+        "if"
+      elsif node.expr
+        "else if"
+      else
+        "else"
       end
     @is_else = false
     str = "#{tab_str}@#{name}"
@@ -152,7 +156,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_media(node)
-    "#{tab_str}@media #{media_interp_to_src(node.query)}#{yield}"
+    "#{tab_str}@media #{query_interp_to_src(node.query)}#{yield}"
   end
 
   def visit_supports(node)
@@ -160,7 +164,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_cssimport(node)
-    if node.uri.is_a?(Sass::Script::Node)
+    if node.uri.is_a?(Sass::Script::Tree::Node)
       str = "#{tab_str}@import #{node.uri.to_sass(@options)}"
     else
       str = "#{tab_str}@import #{node.uri}"
@@ -195,17 +199,26 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_mixin(node)
+    arg_to_sass = lambda do |arg|
+      sass = arg.to_sass(@options)
+      sass = "(#{sass})" if arg.is_a?(Sass::Script::Tree::ListLiteral) && arg.separator == :comma
+      sass
+    end
+
     unless node.args.empty? && node.keywords.empty? && node.splat.nil?
-      args = node.args.map {|a| a.to_sass(@options)}.join(", ")
+      args = node.args.map(&arg_to_sass)
       keywords = Sass::Util.hash_to_a(node.keywords).
-        map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
+
       if node.splat
-        splat = (args.empty? && keywords.empty?) ? "" : ", "
-        splat = "#{splat}#{node.splat.to_sass(@options)}..."
+        splat = "#{arg_to_sass[node.splat]}..."
+        kwarg_splat = "#{arg_to_sass[node.kwarg_splat]}..." if node.kwarg_splat
       end
-      arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
+
+      arglist = "(#{[args, splat, keywords, kwarg_splat].flatten.compact.join(', ')})"
     end
-    "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
+    "#{tab_str}#{@format == :sass ? '+' : '@include '}" +
+      "#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"
   end
 
   def visit_content(node)
@@ -239,7 +252,8 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_variable(node)
-    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}#{' !default' if node.guarded}#{semi}\n"
+    "#{tab_str}$#{dasherize(node.name)}: #{node.expr.to_sass(@options)}" +
+      "#{' !global' if node.global}#{' !default' if node.guarded}#{semi}\n"
   end
 
   def visit_warn(node)
@@ -250,6 +264,17 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@while #{node.expr.to_sass(@options)}#{yield}"
   end
 
+  def visit_atroot(node)
+    if node.query
+      "#{tab_str}@at-root #{query_interp_to_src(node.query)}#{yield}"
+    elsif node.children.length == 1 && node.children.first.is_a?(Sass::Tree::RuleNode)
+      rule = node.children.first
+      "#{tab_str}@at-root #{selector_to_src(rule.rule)}#{visit_children(rule)}"
+    else
+      "#{tab_str}@at-root#{yield}"
+    end
+  end
+
   private
 
   def interp_to_src(interp)
@@ -260,11 +285,11 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   # Like interp_to_src, but removes the unnecessary `#{}` around the keys and
-  # values in media expressions.
-  def media_interp_to_src(interp)
+  # 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]
+      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] == ?)))