sass 3.3.0.alpha.382 → 3.3.0.alpha.388

data/REVISION

@@ -1 +1 @@
-bdc463148ed78f460943d6872b3e45109fe894ed
+4c629cf45c1d7ea2712bd73d16dbc5e96deda2a3

data/VERSION

@@ -1 +1 @@
-3.3.0.alpha.382
+3.3.0.alpha.388

data/VERSION_DATE

@@ -1 +1 @@
-11 October 2013 22:12:53 GMT
+11 October 2013 22:21:38 GMT

data/lib/sass/engine.rb

@@ -878,9 +878,17 @@ WARNING
     end
 
     def parse_at_root_directive(parent, line, root, value, offset)
-      at_root_node = Sass::Tree::AtRootNode.new
-      return at_root_node unless value
+      return Sass::Tree::AtRootNode.new unless value
 
+      if value.start_with?('(')
+        parser = Sass::SCSS::Parser.new(value,
+          @options[:filename], @options[:importer],
+          @line, to_parser_offset(@offset))
+        offset = line.offset + line.text.index('at-root').to_i - 1
+        return Tree::AtRootNode.new(parser.parse_at_root_query)
+      end
+
+      at_root_node = Tree::AtRootNode.new
       parsed = parse_interp(value, offset)
       rule_node = Tree::RuleNode.new(parsed, full_line_range(line))
 

data/lib/sass/environment.rb

@@ -57,6 +57,7 @@ module Sass
 
     attr_writer :caller
     attr_writer :content
+    attr_writer :selector
 
     # variable
     # Script::Value
@@ -100,26 +101,7 @@ module Sass
     # @return [Selector::CommaSequence?] The current selector, with any
     #   nesting fully resolved.
     def selector
-      return if @no_selector
-      return @selector if @selector
-      return @caller.selector if @caller
-      return @parent.selector if @parent
-      nil
-    end
-
-    def selector=(value)
-      @selector = value
-      @no_selector = false
-    end
-
-    # Mark this environment as having no selector information. Unlike setting
-    # {#selector} to nil, this indicates that this environment should not
-    # inherit its {#parent}'s or {#caller}'s selector.
-    #
-    # This will be overwritten if {#selector} is set.
-    def no_selector!
-      @selector = nil
-      @no_selector = true
+      @selector || (@caller && @caller.selector) || (@parent && @parent.selector)
     end
 
     # The top-level Environment object.

data/lib/sass/script/functions.rb

@@ -1704,7 +1704,7 @@ module Sass::Script
       index = n.to_i > 0 ? n.to_i - 1 : n.to_i
       new_list = list.to_a.dup
       new_list[index] = value
-      Sass::Script::Value::List.new(new_list, list.separator)
+      list(new_list, list.separator)
     end
     declare :set_nth, [:list, :n, :value]
 
@@ -1892,7 +1892,7 @@ module Sass::Script
     # @raise [ArgumentError] if `$map` is not a map
     def map_get(map, key)
       assert_type map, :Map
-      to_h(map)[key] || Sass::Script::Value::Null.new
+      to_h(map)[key] || null
     end
     declare :map_get, [:map, :key]
 
@@ -1916,7 +1916,7 @@ module Sass::Script
     def map_merge(map1, map2)
       assert_type map1, :Map
       assert_type map2, :Map
-      Sass::Script::Value::Map.new(to_h(map1).merge(to_h(map2)))
+      map(to_h(map1).merge(to_h(map2)))
     end
     declare :map_get, [:map1, :map2]
 
@@ -1930,7 +1930,7 @@ module Sass::Script
     # @raise [ArgumentError] if `$map` is not a map
     def map_keys(map)
       assert_type map, :Map
-      Sass::Script::Value::List.new(to_h(map).keys, :comma)
+      list(to_h(map).keys, :comma)
     end
     declare :map_keys, [:map]
 
@@ -1946,7 +1946,7 @@ module Sass::Script
     # @raise [ArgumentError] if `$map` is not a map
     def map_values(map)
       assert_type map, :Map
-      Sass::Script::Value::List.new(to_h(map).values, :comma)
+      list(to_h(map).values, :comma)
     end
     declare :map_values, [:map]
 
@@ -1962,7 +1962,7 @@ module Sass::Script
     # @raise [ArgumentError] if `$map` is not a map
     def map_has_key(map, key)
       assert_type map, :Map
-      Sass::Script::Value::Bool.new(to_h(map).has_key?(key))
+      bool(to_h(map).has_key?(key))
     end
     declare :map_has_key, [:map, :key]
 
@@ -1982,8 +1982,7 @@ module Sass::Script
     # @raise [ArgumentError] if `$args` isn't a variable argument list
     def keywords(args)
       assert_type args, :ArgList
-      Sass::Script::Value::Map.new(
-        Sass::Util.map_keys(args.keywords) {|k| Sass::Script::String.new(k)})
+      map(Sass::Util.map_keys(args.keywords) {|k| Sass::Script::String.new(k)})
     end
     declare :keywords, [:args]
 
@@ -2078,7 +2077,7 @@ module Sass::Script
     # @overload counters($args...)
     # @return [String]
     def counters(*args)
-      Sass::Script::String.new("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
+      identifier("counters(#{args.map {|a| a.to_s(options)}.join(',')})")
     end
     declare :counters, [], :var_args => true
 
@@ -2096,7 +2095,7 @@ module Sass::Script
     #   the current scope.
     def variable_exists(name)
       assert_type name, :String
-      Sass::Script::Value::Bool.new(environment.caller.var(name.value))
+      bool(environment.caller.var(name.value))
     end
     declare :variable_exists, [:name]
 
@@ -2117,7 +2116,7 @@ module Sass::Script
     #   the global scope.
     def global_variable_exists(name)
       assert_type name, :String
-      Sass::Script::Value::Bool.new(environment.global_env.var(name.value))
+      bool(environment.global_env.var(name.value))
     end
     declare :global_variable_exists, [:name]
 
@@ -2135,7 +2134,7 @@ module Sass::Script
       assert_type name, :String
       exists = Sass::Script::Functions.callable?(name.value.tr("-", "_"))
       exists ||= environment.function(name.value)
-      Sass::Script::Value::Bool.new(exists)
+      bool(exists)
     end
     declare :function_exists, [:name]
 
@@ -2151,7 +2150,7 @@ module Sass::Script
     # @return [Sass::Script::Bool] Whether the mixin is defined.
     def mixin_exists(name)
       assert_type name, :String
-      Sass::Script::Value::Bool.new(environment.mixin(name.value))
+      bool(environment.mixin(name.value))
     end
     declare :mixin_exists, [:name]
 

data/lib/sass/script/value/helpers.rb

@@ -88,6 +88,15 @@ module Sass::Script::Value
       Sass::Script::Value::List.new(elements, separator)
     end
 
+    # Construct a Sass map.
+    #
+    # @param hash [Hash<Sass::Script::Value::Base,
+    #   Sass::Script::Value::Base>] A Ruby map to convert to a Sass map.
+    # @return [Sass::Script::Value::Map] The map.
+    def map(hash)
+      Map.new(hash)
+    end
+
     # Create a sass null value.
     #
     # @return [Sass::Script::Value::Null]

data/lib/sass/scss/parser.rb

@@ -67,6 +67,18 @@ module Sass
         ql
       end
 
+      # Parses an at-root query.
+      #
+      # @return [Array<String, Sass::Script;:Tree::Node>] The interpolated query.
+      # @raise [Sass::SyntaxError] if there's a syntax error in the query,
+      #   or if it doesn't take up the entire input string.
+      def parse_at_root_query
+        init_scanner!
+        query = at_root_query
+        expected("@at-root query list") unless @scanner.eos?
+        query
+      end
+
       # Parses a supports query condition.
       #
       # @return [Sass::Supports::Condition] The parsed condition
@@ -435,7 +447,7 @@ module Sass
         query
       end
 
-      def media_expr
+      def query_expr
         interp = interpolation
         return interp if interp
         return unless tok(/\(/)
@@ -453,6 +465,11 @@ module Sass
         res
       end
 
+      # Aliases allow us to use different descriptions if the same
+      # expression fails in different contexts.
+      alias_method :media_expr, :query_expr
+      alias_method :at_root_query, :query_expr
+
       def charset_directive(start_pos)
         tok! STRING
         name = @scanner[1] || @scanner[2]
@@ -490,6 +507,10 @@ module Sass
       end
 
       def at_root_directive(start_pos)
+        if tok?(/\(/) && (expr = at_root_query)
+          return block(node(Sass::Tree::AtRootNode.new(expr), start_pos), :directive)
+        end
+
         at_root_node = node(Sass::Tree::AtRootNode.new, start_pos)
         rule_node = ruleset
         return block(at_root_node, :stylesheet) unless rule_node
@@ -497,6 +518,17 @@ module Sass
         at_root_node
       end
 
+      def at_root_directive_list
+        return unless (first = tok(IDENT))
+        arr = [first]
+        ss
+        while (e = tok(IDENT))
+          arr << e
+          ss
+        end
+        arr
+      end
+
       # http://www.w3.org/TR/css3-conditional/
       def supports_directive(name, start_pos)
         condition = expr!(:supports_condition)
@@ -1146,6 +1178,8 @@ MESSAGE
         :media_query => "media query (e.g. print, screen, print and screen)",
         :media_query_list => "media query (e.g. print, screen, print and screen)",
         :media_expr => "media expression (e.g. (min-device-width: 800px))",
+        :at_root_query => "@at-root query (e.g. (without: media))",
+        :at_root_directive_list => '* or identifier',
         :pseudo_arg => "expression (e.g. fr, 2n+1)",
         :interp_ident => "identifier",
         :interp_name => "identifier",
@@ -1160,9 +1194,13 @@ MESSAGE
         :supports_condition_in_parens => "@supports condition (e.g. (display: flexbox))",
       }
 
-      TOK_NAMES = Sass::Util.to_hash(
-        Sass::SCSS::RX.constants.map {|c| [Sass::SCSS::RX.const_get(c), c.downcase]}).
-        merge(IDENT => "identifier", /[;}]/ => '";"')
+      TOK_NAMES = Sass::Util.to_hash(Sass::SCSS::RX.constants.map do |c|
+        [Sass::SCSS::RX.const_get(c), c.downcase]
+      end).merge(
+        IDENT => "identifier",
+        /[;}]/ => '";"',
+        /\b(without|with)\b/ => '"with" or "without"'
+      )
 
       def tok?(rx)
         @scanner.match?(rx)

data/lib/sass/scss/static_parser.rb

@@ -24,6 +24,23 @@ module Sass
         seq
       end
 
+      # Parses a static at-root query.
+      #
+      # @return [(Symbol, Array<String>)] The type of the query
+      #   (`:with` or `:without`) and the values that are being filtered.
+      # @raise [Sass::SyntaxError] if there's a syntax error in the query,
+      #   or if it doesn't take up the entire input string.
+      def parse_static_at_root_query
+        init_scanner!
+        tok!(/\(/); ss
+        type = tok!(/\b(without|with)\b/).to_sym; ss
+        tok!(/:/); ss
+        directives = expr!(:at_root_directive_list); ss
+        tok!(/\)/)
+        expected("@at-root query list") unless @scanner.eos?
+        return type, directives
+      end
+
       private
 
       def moz_document_function

data/lib/sass/tree/at_root_node.rb

@@ -7,6 +7,73 @@ module Sass
     #
     # @see Sass::Tree
     class AtRootNode < Node
+      # The query for this node (e.g. `(without: media)`),
+      # interspersed with {Sass::Script::Tree::Node}s representing
+      # `#{}`-interpolation. Any adjacent strings will be merged
+      # together.
+      #
+      # This will be nil if the directive didn't have a query. In this
+      # case, {#resolved\_type} will automatically be set to
+      # `:without` and {#resolved\_rule} will automatically be set to `["rule"]`.
+      #
+      # @return [Array<String, Sass::Script::Tree::Node>]
+      attr_accessor :query
+
+      # The resolved type of this directive. `:with` or `:without`.
+      #
+      # @return [Symbol]
+      attr_accessor :resolved_type
+
+      # The resolved value of this directive -- a list of directives
+      # to either include or exclude.
+      #
+      # @return [Array<String>]
+      attr_accessor :resolved_value
+
+      # The number of additional tabs that the contents of this node
+      # should be indented.
+      #
+      # @return [Number]
+      attr_accessor :tabs
+
+      # Whether the last child of this node should be considered the
+      # end of a group.
+      #
+      # @return [Boolean]
+      attr_accessor :group_end
+
+      def initialize(query = nil)
+        super()
+        @query = Sass::Util.strip_string_array(Sass::Util.merge_adjacent_strings(query)) if query
+        @tabs = 0
+      end
+
+      # Returns whether or not the given directive is excluded by this
+      # node. `directive` may be "rule", which indicates whether
+      # normal CSS rules should be excluded.
+      #
+      # @param directive [String]
+      # @return [Boolean]
+      def exclude?(directive)
+        if resolved_type == :with
+          return false if resolved_value.include?('all')
+          !resolved_value.include?(directive)
+        else # resolved_type == :without
+          return true if resolved_value.include?('all')
+          resolved_value.include?(directive)
+        end
+      end
+
+      # Returns whether the given node is excluded by this node.
+      #
+      # @param node [Sass::Tree::Node]
+      # @return [Boolean]
+      def exclude_node?(node)
+        return exclude?(node.name.gsub(/^@/, '')) if node.is_a?(Sass::Tree::DirectiveNode)
+        exclude?(node.class.to_s.gsub(/.*::(.*)Node$/, '\1').downcase)
+      end
+
+      # @see Node#bubbles?
       def bubbles?
         true
       end

data/lib/sass/tree/directive_node.rb

@@ -20,9 +20,16 @@ module Sass::Tree
     # @return [String]
     attr_accessor :resolved_value
 
+    # @see RuleNode#tabs
+    attr_accessor :tabs
+
+    # @see RuleNode#group_end
+    attr_accessor :group_end
+
     # @param value [Array<String, Sass::Script::Tree::Node>] See \{#value}
     def initialize(value)
       @value = value
+      @tabs = 0
       super()
     end
 
@@ -38,5 +45,9 @@ module Sass::Tree
     def name
       value.first.gsub(/ .*$/, '')
     end
+
+    def bubbles?
+      has_children
+    end
   end
 end

data/lib/sass/tree/media_node.rb

@@ -21,16 +21,9 @@ module Sass::Tree
     # @return [Sass::Media::QueryList]
     attr_accessor :resolved_query
 
-    # @see RuleNode#tabs
-    attr_accessor :tabs
-
-    # @see RuleNode#group_end
-    attr_accessor :group_end
-
     # @param query [Array<String, Sass::Script::Tree::Node>] See \{#query}
     def initialize(query)
       @query = query
-      @tabs = 0
       super('')
     end
 
@@ -51,8 +44,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/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/visitors/convert.rb

@@ -156,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)
@@ -265,7 +265,9 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   end
 
   def visit_atroot(node)
-    if node.children.length == 1 && node.children.first.is_a?(Sass::Tree::RuleNode)
+    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
@@ -283,8 +285,8 @@ 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]

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

@@ -27,11 +27,20 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # Keeps track of the current parent node.
   def visit_children(parent)
     with_parent parent do
-      parent.children = super.flatten
+      parent.children = visit_children_without_parent(parent)
       parent
     end
   end
 
+  # Like {#visit\_children}, but doesn't set {#parent}.
+  #
+  # @param node [Sass::Tree::Node]
+  # @return [Array<Sass::Tree::Node>] the flattened results of
+  #   visiting all the children of `node`
+  def visit_children_without_parent(node)
+    node.children.map {|c| visit(c)}.flatten
+  end
+
   MERGEABLE_DIRECTIVES = [Sass::Tree::MediaNode]
 
   # Runs a block of code with the current parent node
@@ -138,8 +147,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
   # Modifies exception backtraces to include the imported file.
   def visit_import(node)
-    # Don't use #visit_children to avoid adding the import node to the list of parents.
-    node.children.map {|c| visit(c)}.flatten
+    visit_children_without_parent(node)
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:filename => node.children.first.filename)
     e.add_backtrace(:filename => node.filename, :line => node.line)
@@ -150,28 +158,46 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # and merges it with other `@media` directives.
   def visit_media(node)
     yield unless bubble(node)
-    media = node.children.select {|c| c.is_a?(Sass::Tree::MediaNode)}
-    node.children.reject! {|c| c.is_a?(Sass::Tree::MediaNode)}
-    media = media.select {|n| n.resolved_query = n.resolved_query.merge(node.resolved_query)}
-    (node.children.empty? ? [] : [node]) + media
+
+    bubbled = node.children.select do |n|
+      n.is_a?(Sass::Tree::AtRootNode) || n.is_a?(Sass::Tree::MediaNode)
+    end
+    node.children -= bubbled
+
+    bubbled = bubbled.map do |n|
+      next visit(n) if n.is_a?(Sass::Tree::AtRootNode)
+      # Otherwise, n should be a MediaNode.
+      next [] unless n.resolved_query = n.resolved_query.merge(node.resolved_query)
+      n
+    end.flatten
+
+    (node.children.empty? ? [] : [node]) + bubbled
   end
 
   # Bubbles the `@supports` directive up through RuleNodes.
   def visit_supports(node)
-    yield unless bubble(node)
-    node
+    visit_directive(node) {yield}
   end
 
   # Asserts that all the traced children are valid in their new location.
   def visit_trace(node)
-    # Don't use #visit_children to avoid adding the trace node to the list of parents.
-    node.children.map {|c| visit(c)}.flatten
+    visit_children_without_parent(node)
   rescue Sass::SyntaxError => e
     e.modify_backtrace(:mixin => node.name, :filename => node.filename, :line => node.line)
     e.add_backtrace(:filename => node.filename, :line => node.line)
     raise e
   end
 
+  # Bubbles a directive up through RuleNodes.
+  def visit_directive(node)
+    return yield unless node.has_children
+    yield unless (bubbled = bubble(node))
+    at_roots = node.children.select {|n| n.is_a?(Sass::Tree::AtRootNode)}
+    node.children -= at_roots
+    at_roots.map! {|n| visit(n)}.flatten
+    (bubbled && node.children.empty? ? [] : [node]) + at_roots
+  end
+
   # Converts nested properties into flat properties
   # and updates the indentation of the prop node based on the nesting level.
   def visit_prop(node)
@@ -199,6 +225,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles?}
     props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.bubbles? || c.invisible?}
 
+    rules.map {|c| c.is_a?(Sass::Tree::AtRootNode) ? visit(c) : c}.flatten
+
     unless props.empty?
       node.children = props
       rules.each {|r| r.tabs += 1} if node.style == :nested
@@ -211,7 +239,19 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   end
 
   def visit_atroot(node)
-    yield.children
+    if @parent_directives.any? {|n| node.exclude_node?(n)}
+      return node if node.exclude_node?(parent)
+
+      new_rule = parent.dup
+      new_rule.children = node.children
+      node.children = [new_rule]
+      return node
+    end
+
+    results = visit_children_without_parent(node)
+    results.each {|n| n.tabs += node.tabs}
+    results.last.group_end = node.group_end unless results.empty?
+    results
   end
 
   private

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

@@ -380,11 +380,12 @@ 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, @at_root = @at_root, false
+    old_at_root_without_rule, @at_root_without_rule = @at_root_without_rule, false
     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)
+    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
@@ -392,16 +393,25 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
     end
     node
   ensure
-    @at_root = old_at_root
+    @at_root_without_rule = old_at_root_without_rule
   end
 
   # Sets a variable that indicates that the first level of rule nodes
   # shouldn't include the parent selector by default.
   def visit_atroot(node)
-    old_at_root, @at_root = @at_root, true
-    yield.children
+    if node.query
+      parser = Sass::SCSS::StaticParser.new(run_interp(node.query),
+        node.filename, node.options[:importer], node.line)
+      node.resolved_type, node.resolved_value = parser.parse_static_at_root_query
+    else
+      node.resolved_type, node.resolved_value = :without, ['rule']
+    end
+
+    old_at_root_without_rule = @at_root_without_rule
+    @at_root_without_rule = true if node.exclude?('rule')
+    yield
   ensure
-    @at_root = old_at_root
+    @at_root_without_rule = old_at_root_without_rule
   end
 
   # Loads the new variable value into the environment.
@@ -440,7 +450,6 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
   def visit_directive(node)
     node.resolved_value = run_interp(node.value)
     with_environment Sass::Environment.new(@environment) do
-      @environment.no_selector!
       node.children = node.children.map {|c| visit(c)}.flatten
       node
     end

data/test/sass/conversion_test.rb

@@ -1726,6 +1726,34 @@ SASS
 SCSS
   end
 
+  def test_at_root_without
+    assert_scss_to_sass <<SASS, <<SCSS
+.foo
+  @at-root (without: media rule)
+    a: b
+SASS
+.foo {
+  @at-root (without: media rule) {
+    a: b;
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with
+    assert_scss_to_sass <<SASS, <<SCSS
+.foo
+  @at-root (with: media rule)
+    a: b
+SASS
+.foo {
+  @at-root (with: media rule) {
+    a: b;
+  }
+}
+SCSS
+  end
+
   def test_function_var_kwargs_with_list
     assert_scss_to_sass <<SASS, <<SCSS
 @function foo($a: b, $c: d)

data/test/sass/engine_test.rb

@@ -2476,6 +2476,19 @@ CSS
 SASS
   end
 
+  def test_at_root_with_query
+    assert_equal <<CSS, render(<<SASS)
+.foo .bar {
+  a: b; }
+CSS
+.foo
+  @media screen
+    @at-root (without: media)
+      .bar
+        a: b
+SASS
+  end
+
   # Regression tests
 
   def test_list_separator_with_arg_list

data/test/sass/extend_test.rb

@@ -939,7 +939,6 @@ SCSS
 @flooblehoof {
   .foo, .bar {
     a: b; } }
-
 @flooblehoof {}
 CSS
 @flooblehoof {.foo {a: b}}

data/test/sass/scss/css_test.rb

@@ -566,7 +566,6 @@ SCSS
     assert_parses <<SCSS
 @foo bar {
   a: b; }
-
 @bar baz {
   c: d; }
 SCSS
@@ -586,7 +585,6 @@ SCSS
     assert_equal <<CSS, render(<<SCSS)
 @foo {
   a: b; }
-
 @bar {
   a: b; }
 CSS

data/test/sass/scss/scss_test.rb

@@ -563,6 +563,20 @@ foo bar {
 SCSS
   end
 
+  def test_unknown_directive_bubbling
+    assert_equal(<<CSS, render(<<SCSS, :style => :nested))
+@fblthp {
+  .foo .bar {
+    a: b; } }
+CSS
+.foo {
+  @fblthp {
+    .bar {a: b}
+  }
+}
+SCSS
+  end
+
   ## Namespace Properties
 
   def test_namespace_properties
@@ -2153,21 +2167,6 @@ CSS
 SCSS
   end
 
-  def test_at_root_in_nested_unknown_directive
-    assert_equal <<CSS, render(<<SCSS)
-.foo {
-  @fblthp {
-    .bar {
-      a: b; } } }
-CSS
-.foo {
-  @fblthp {
-    @at-root .bar {a: b}
-  }
-}
-SCSS
-  end
-
   def test_at_root_with_parent_ref
     assert_equal <<CSS, render(<<SCSS)
 .foo {
@@ -2213,6 +2212,308 @@ CSS
 SCSS
   end
 
+  ## @at-root (...)
+
+  def test_at_root_without_media
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar {
+  a: b; }
+CSS
+.foo {
+  @media screen {
+    @at-root (without: media) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_without_supports
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar {
+  a: b; }
+CSS
+.foo {
+  @supports (foo: bar) {
+    @at-root (without: supports) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_without_rule
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @at-root (without: rule) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_without_unknown_directive
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar {
+  a: b; }
+CSS
+.foo {
+  @fblthp {
+    @at-root (without: fblthp) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_without_multiple
+    assert_equal <<CSS, render(<<SCSS)
+@supports (foo: bar) {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @supports (foo: bar) {
+      @at-root (without: media rule) {
+        .bar {
+          a: b;
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_without_all
+    assert_equal <<CSS, render(<<SCSS)
+.bar {
+  a: b; }
+CSS
+.foo {
+  @supports (foo: bar) {
+    @fblthp {
+      @at-root (without: all) {
+        .bar {
+          a: b;
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_media
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: media) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_rule
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar {
+  a: b; }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: rule) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_supports
+    assert_equal <<CSS, render(<<SCSS)
+@supports (foo: bar) {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: supports) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_unknown_directive
+    assert_equal <<CSS, render(<<SCSS)
+@fblthp {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: fblthp) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_multiple
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  .foo .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: media rule) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_with_all
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  @fblthp {
+    @supports (foo: bar) {
+      .foo .bar {
+        a: b; } } } }
+CSS
+.foo {
+  @media screen {
+    @fblthp {
+      @supports (foo: bar) {
+        @at-root (with: all) {
+          .bar {
+            a: b;
+          }
+        }
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_dynamic_values
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  .bar {
+    a: b; } }
+CSS
+$key: with;
+$value: media;
+.foo {
+  @media screen {
+    @at-root ($key: $value) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_interpolated_query
+    assert_equal <<CSS, render(<<SCSS)
+@media screen {
+  .bar {
+    a: b; } }
+CSS
+.foo {
+  @media screen {
+    @at-root (\#{"with: media"}) {
+      .bar {
+        a: b;
+      }
+    }
+  }
+}
+SCSS
+  end
+
+  def test_at_root_plus_extend
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar {
+  a: b; }
+CSS
+%base {
+  a: b;
+}
+
+.foo {
+  @media screen {
+    @at-root (without: media) {
+      .bar {
+        @extend %base;
+      }
+    }
+  }
+}
+SCSS
+  end
+
   ## Selector Script
 
   def test_selector_script
@@ -2602,57 +2903,6 @@ SCSS
 
   # Regression
 
-  def test_nested_unknown_directive
-    assert_equal(<<CSS, render(<<SCSS, :style => :nested))
-.foo {
-  @fblthp {
-    .bar {
-      a: b; } } }
-CSS
-.foo {
-  @fblthp {
-    .bar {a: b}
-  }
-}
-SCSS
-
-    assert_equal(<<CSS, render(<<SCSS, :style => :compressed))
-.foo{@fblthp{.bar{a:b}}}
-CSS
-.foo {
-  @fblthp {
-    .bar {a: b}
-  }
-}
-SCSS
-
-    assert_equal(<<CSS, render(<<SCSS, :style => :compact))
-.foo { @fblthp { .bar { a: b; } } }
-CSS
-.foo {
-  @fblthp {
-    .bar {a: b}
-  }
-}
-SCSS
-
-    assert_equal(<<CSS, render(<<SCSS, :style => :expanded))
-.foo {
-  @fblthp {
-    .bar {
-      a: b;
-    }
-  }
-}
-CSS
-.foo {
-  @fblthp {
-    .bar {a: b}
-  }
-}
-SCSS
-  end
-
   def test_loud_comment_in_compressed_mode
     assert_equal(<<CSS, render(<<SCSS))
 /*! foo */

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302577
+  hash: 592302085
   prerelease: 6
   segments: 
   - 3
   - 3
   - 0
   - alpha
-  - 382
-  version: 3.3.0.alpha.382
+  - 388
+  version: 3.3.0.alpha.388
 platform: ruby
 authors: 
 - Nathan Weizenbaum