sass 3.2.0.alpha.96 → 3.2.0.alpha.99

data/lib/sass/tree/media_node.rb

@@ -38,5 +38,8 @@ module Sass::Tree
     def invisible?
       children.all? {|c| c.invisible?}
     end
+
+    # @see Node#bubbles?
+    def bubbles?; true; end
   end
 end

data/lib/sass/tree/node.rb

@@ -188,6 +188,13 @@ module Sass
         Sass::Tree::Visitors::DeepCopy.visit(self)
       end
 
+      # Whether or not this node bubbles up through RuleNodes.
+      #
+      # @return [Boolean]
+      def bubbles?
+        false
+      end
+
       protected
 
       # @see Sass::Shared.balance

data/lib/sass/tree/supports_node.rb

@@ -0,0 +1,51 @@
+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
+    # The name, which may include a browser prefix.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The supports condition.
+    #
+    # @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
+
+    # @see DirectiveNode#value
+    def value; raise NotImplementedError; end
+
+    # @see DirectiveNode#resolved_value
+    def resolved_value
+      @resolved_value ||= "@#{name} #{condition.to_css}"
+    end
+
+    # True when the directive has no visible children.
+    #
+    # @return [Boolean]
+    def invisible?
+      children.all? {|c| c.invisible?}
+    end
+
+    # @see Node#bubbles?
+    def bubbles?; true; end
+  end
+end

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

@@ -150,6 +150,10 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
     "#{tab_str}@media #{node.query.to_src(@options)}#{yield}"
   end
 
+  def visit_supports(node)
+    "#{tab_str}@#{node.name} #{node.condition.to_src(@options)}#{yield}"
+  end
+
   def visit_cssimport(node)
     if node.uri.is_a?(Sass::Script::Node)
       str = "#{tab_str}@import #{node.uri.to_sass(@options)}"

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

@@ -121,23 +121,19 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   # Bubbles the `@media` directive up through RuleNodes
   # and merges it with other `@media` directives.
   def visit_media(node)
-    if parent.is_a?(Sass::Tree::RuleNode)
-      new_rule = parent.dup
-      new_rule.children = node.children
-      node.children = with_parent(node) {Array(visit(new_rule))}
-      # If the last child is actually the end of the group,
-      # the parent's cssize will set it properly
-      node.children.last.group_end = false unless node.children.empty?
-    else
-      yield
-    end
-
+    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.query = n.query.merge(node.query)}
     (node.children.empty? ? [] : [node]) + media
   end
 
+  # Bubbles the `@supports` directive up through RuleNodes.
+  def visit_supports(node)
+    yield unless bubble(node)
+    node
+  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.
@@ -176,8 +172,8 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
     yield
 
-    rules = node.children.select {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode)}
-    props = node.children.reject {|c| c.is_a?(Sass::Tree::RuleNode) || c.is_a?(Sass::Tree::MediaNode) || c.invisible?}
+    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?}
 
     unless props.empty?
       node.children = props
@@ -189,4 +185,17 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
 
     rules
   end
+
+  private
+
+  def bubble(node)
+    return unless parent.is_a?(Sass::Tree::RuleNode)
+    new_rule = parent.dup
+    new_rule.children = node.children
+    node.children = with_parent(node) {Array(visit(new_rule))}
+    # If the last child is actually the end of the group,
+    # the parent's cssize will set it properly
+    node.children.last.group_end = false unless node.children.empty?
+    true
+  end
 end

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

@@ -94,4 +94,9 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
     node.query = node.query.deep_copy
     yield
   end
+
+  def visit_supports(node)
+    node.condition = node.condition.deep_copy
+    yield
+  end
 end

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

@@ -302,6 +302,12 @@ END
     yield
   end
 
+  def visit_supports(node)
+    node.condition = node.condition.deep_copy
+    node.condition.perform(@environment)
+    yield
+  end
+
   def visit_cssimport(node)
     node.resolved_uri = run_interp([node.uri])
     if node.query

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

@@ -104,4 +104,9 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
     node.query.options = @options
     yield
   end
+
+  def visit_supports(node)
+    node.condition.options = @options
+    yield
+  end
 end

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

@@ -113,6 +113,10 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     str
   end
 
+  def visit_supports(node)
+    visit_media(node)
+  end
+
   def visit_cssimport(node)
     visit_directive(node)
   end

data/test/sass/conversion_test.rb

@@ -1184,6 +1184,28 @@ $val: 20;
 SCSS
   end
 
+  def test_supports_with_expressions
+    assert_renders <<SASS, <<SCSS
+$query: "(feature1: val)"
+$feature: feature2
+$val: val
+
+@supports \#{$query} and ($feature: $val) or (not ($feature + 3: $val + 4))
+  foo
+    a: b
+SASS
+$query: "(feature1: val)";
+$feature: feature2;
+$val: val;
+
+@supports \#{$query} and ($feature: $val) or (not ($feature + 3: $val + 4)) {
+  foo {
+    a: b;
+  }
+}
+SCSS
+  end
+
   # Hacks
 
   def test_declaration_hacks

data/test/sass/extend_test.rb

@@ -181,591 +181,115 @@ SCSS
   end
 
   def test_class_unification
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, .bar.baz {
-  a: b; }
-CSS
-.foo.bar {a: b}
-.baz {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.baz {
-  a: b; }
-CSS
-.foo.baz {a: b}
-.baz {@extend .foo}
-SCSS
+    assert_unification '.foo.bar', '.baz {@extend .foo}', '.foo.bar, .bar.baz' 
+    assert_unification '.foo.baz', '.baz {@extend .foo}', '.baz' 
   end
 
   def test_id_unification
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, .bar#baz {
-  a: b; }
-CSS
-.foo.bar {a: b}
-#baz {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-#baz {
-  a: b; }
-CSS
-.foo#baz {a: b}
-#baz {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo#baz {
-  a: b; }
-CSS
-.foo#baz {a: b}
-#bar {@extend .foo}
-SCSS
+    assert_unification '.foo.bar', '#baz {@extend .foo}', '.foo.bar, .bar#baz'
+    assert_unification '.foo#baz', '#baz {@extend .foo}', '#baz'
+    assert_unification '.foo#baz', '#bar {@extend .foo}', '.foo#baz'
   end
 
   def test_universal_unification_with_simple_target
-    assert_equal <<CSS, render(<<SCSS)
-.foo, * {
-  a: b; }
-CSS
-.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo, *|* {
-  a: b; }
-CSS
-.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, ns|*.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-ns|* {@extend .foo}
-SCSS
+    assert_unification '.foo', '* {@extend .foo}', '.foo, *'
+    assert_unification '.foo', '*|* {@extend .foo}', '.foo, *|*'
+    assert_unification '.foo.bar', '* {@extend .foo}', '.bar'
+    assert_unification '.foo.bar', '*|* {@extend .foo}', '.bar'
+    assert_unification '.foo.bar', 'ns|* {@extend .foo}', '.foo.bar, ns|*.bar'
   end
 
   def test_universal_unification_with_namespaceless_universal_target
-    assert_equal <<CSS, render(<<SCSS)
-* {
-  a: b; }
-CSS
-*.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-* {
-  a: b; }
-CSS
-*.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|*.foo, * {
-  a: b; }
-CSS
-*|*.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|* {
-  a: b; }
-CSS
-*|*.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*.foo, ns|* {
-  a: b; }
-CSS
-*.foo {a: b}
-ns|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|*.foo, ns|* {
-  a: b; }
-CSS
-*|*.foo {a: b}
-ns|* {@extend .foo}
-SCSS
+    assert_unification '*.foo', '* {@extend .foo}', '*'
+    assert_unification '*.foo', '*|* {@extend .foo}', '*'
+    assert_unification '*|*.foo', '* {@extend .foo}', '*|*.foo, *'
+    assert_unification '*|*.foo', '*|* {@extend .foo}', '*|*'
+    assert_unification '*.foo', 'ns|* {@extend .foo}', '*.foo, ns|*'
+    assert_unification '*|*.foo', 'ns|* {@extend .foo}', '*|*.foo, ns|*'
   end
 
   def test_universal_unification_with_namespaced_universal_target
-    assert_equal <<CSS, render(<<SCSS)
-ns|* {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|* {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns1|*.foo {
-  a: b; }
-CSS
-ns1|*.foo {a: b}
-ns2|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|* {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-ns|* {@extend .foo}
-SCSS
+    assert_unification 'ns|*.foo', '* {@extend .foo}', 'ns|*'
+    assert_unification 'ns|*.foo', '*|* {@extend .foo}', 'ns|*'
+    assert_unification 'ns1|*.foo', 'ns2|* {@extend .foo}', 'ns1|*.foo'
+    assert_unification 'ns|*.foo', 'ns|* {@extend .foo}', 'ns|*'
   end
 
   def test_universal_unification_with_namespaceless_element_target
-    assert_equal <<CSS, render(<<SCSS)
-a {
-  a: b; }
-CSS
-a.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a {
-  a: b; }
-CSS
-a.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a.foo, a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.foo, ns|a {
-  a: b; }
-CSS
-a.foo {a: b}
-ns|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a.foo, ns|a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-ns|* {@extend .foo}
-SCSS
+    assert_unification 'a.foo', '* {@extend .foo}', 'a'
+    assert_unification 'a.foo', '*|* {@extend .foo}', 'a'
+    assert_unification '*|a.foo', '* {@extend .foo}', '*|a.foo, a'
+    assert_unification '*|a.foo', '*|* {@extend .foo}', '*|a'
+    assert_unification 'a.foo', 'ns|* {@extend .foo}', 'a.foo, ns|a'
+    assert_unification '*|a.foo', 'ns|* {@extend .foo}', '*|a.foo, ns|a'
   end
 
   def test_universal_unification_with_namespaced_element_target
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-*|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns1|a.foo {
-  a: b; }
-CSS
-ns1|a.foo {a: b}
-ns2|* {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-ns|* {@extend .foo}
-SCSS
+    assert_unification 'ns|a.foo', '* {@extend .foo}', 'ns|a'
+    assert_unification 'ns|a.foo', '*|* {@extend .foo}', 'ns|a'
+    assert_unification 'ns1|a.foo', 'ns2|* {@extend .foo}', 'ns1|a.foo'
+    assert_unification 'ns|a.foo', 'ns|* {@extend .foo}', 'ns|a'
   end
 
   def test_element_unification_with_simple_target
-    assert_equal <<CSS, render(<<SCSS)
-.foo, a {
-  a: b; }
-CSS
-.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, a.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, *|a.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo.bar, ns|a.bar {
-  a: b; }
-CSS
-.foo.bar {a: b}
-ns|a {@extend .foo}
-SCSS
+    assert_unification '.foo', 'a {@extend .foo}', '.foo, a'
+    assert_unification '.foo.bar', 'a {@extend .foo}', '.foo.bar, a.bar'
+    assert_unification '.foo.bar', '*|a {@extend .foo}', '.foo.bar, *|a.bar'
+    assert_unification '.foo.bar', 'ns|a {@extend .foo}', '.foo.bar, ns|a.bar'
   end
 
   def test_element_unification_with_namespaceless_universal_target
-    assert_equal <<CSS, render(<<SCSS)
-*.foo, a {
-  a: b; }
-CSS
-*.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*.foo, a {
-  a: b; }
-CSS
-*.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|*.foo, a {
-  a: b; }
-CSS
-*|*.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|*.foo, *|a {
-  a: b; }
-CSS
-*|*.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*.foo, ns|a {
-  a: b; }
-CSS
-*.foo {a: b}
-ns|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|*.foo, ns|a {
-  a: b; }
-CSS
-*|*.foo {a: b}
-ns|a {@extend .foo}
-SCSS
+    assert_unification '*.foo', 'a {@extend .foo}', '*.foo, a'
+    assert_unification '*.foo', '*|a {@extend .foo}', '*.foo, a'
+    assert_unification '*|*.foo', 'a {@extend .foo}', '*|*.foo, a'
+    assert_unification '*|*.foo', '*|a {@extend .foo}', '*|*.foo, *|a'
+    assert_unification '*.foo', 'ns|a {@extend .foo}', '*.foo, ns|a'
+    assert_unification '*|*.foo', 'ns|a {@extend .foo}', '*|*.foo, ns|a'
   end
 
   def test_element_unification_with_namespaced_universal_target
-    assert_equal <<CSS, render(<<SCSS)
-ns|*.foo, ns|a {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|*.foo, ns|a {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns1|*.foo {
-  a: b; }
-CSS
-ns1|*.foo {a: b}
-ns2|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|*.foo, ns|a {
-  a: b; }
-CSS
-ns|*.foo {a: b}
-ns|a {@extend .foo}
-SCSS
+    assert_unification 'ns|*.foo', 'a {@extend .foo}', 'ns|*.foo, ns|a'
+    assert_unification 'ns|*.foo', '*|a {@extend .foo}', 'ns|*.foo, ns|a'
+    assert_unification 'ns1|*.foo', 'ns2|a {@extend .foo}', 'ns1|*.foo'
+    assert_unification 'ns|*.foo', 'ns|a {@extend .foo}', 'ns|*.foo, ns|a'
   end
 
   def test_element_unification_with_namespaceless_element_target
-    assert_equal <<CSS, render(<<SCSS)
-a {
-  a: b; }
-CSS
-a.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a {
-  a: b; }
-CSS
-a.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a.foo, a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.foo, ns|a {
-  a: b; }
-CSS
-a.foo {a: b}
-ns|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-*|a.foo, ns|a {
-  a: b; }
-CSS
-*|a.foo {a: b}
-ns|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.foo {
-  a: b; }
-CSS
-a.foo {a: b}
-h1 {@extend .foo}
-SCSS
+    assert_unification 'a.foo', 'a {@extend .foo}', 'a'
+    assert_unification 'a.foo', '*|a {@extend .foo}', 'a'
+    assert_unification '*|a.foo', 'a {@extend .foo}', '*|a.foo, a'
+    assert_unification '*|a.foo', '*|a {@extend .foo}', '*|a'
+    assert_unification 'a.foo', 'ns|a {@extend .foo}', 'a.foo, ns|a'
+    assert_unification '*|a.foo', 'ns|a {@extend .foo}', '*|a.foo, ns|a'
+    assert_unification 'a.foo', 'h1 {@extend .foo}', 'a.foo'
   end
 
   def test_element_unification_with_namespaced_element_target
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-*|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns1|a.foo {
-  a: b; }
-CSS
-ns1|a.foo {a: b}
-ns2|a {@extend .foo}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-ns|a {
-  a: b; }
-CSS
-ns|a.foo {a: b}
-ns|a {@extend .foo}
-SCSS
+    assert_unification 'ns|a.foo', 'a {@extend .foo}', 'ns|a'
+    assert_unification 'ns|a.foo', '*|a {@extend .foo}', 'ns|a'
+    assert_unification 'ns1|a.foo', 'ns2|a {@extend .foo}', 'ns1|a.foo'
+    assert_unification 'ns|a.foo', 'ns|a {@extend .foo}', 'ns|a'
   end
 
   def test_attribute_unification
-    assert_equal <<CSS, render(<<SCSS)
-[foo=bar].baz, [foo=bar][foo=baz] {
-  a: b; }
-CSS
-[foo=bar].baz {a: b}
-[foo=baz] {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-[foo=bar].baz, [foo=bar][foo^=bar] {
-  a: b; }
-CSS
-[foo=bar].baz {a: b}
-[foo^=bar] {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-[foo=bar].baz, [foo=bar][foot=bar] {
-  a: b; }
-CSS
-[foo=bar].baz {a: b}
-[foot=bar] {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-[foo=bar].baz, [foo=bar][ns|foo=bar] {
-  a: b; }
-CSS
-[foo=bar].baz {a: b}
-[ns|foo=bar] {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-[foo=bar] {
-  a: b; }
-CSS
-[foo=bar].baz {a: b}
-[foo=bar] {@extend .baz}
-SCSS
+    assert_unification '[foo=bar].baz', '[foo=baz] {@extend .baz}', '[foo=bar].baz, [foo=bar][foo=baz]'
+    assert_unification '[foo=bar].baz', '[foo^=bar] {@extend .baz}', '[foo=bar].baz, [foo=bar][foo^=bar]'
+    assert_unification '[foo=bar].baz', '[foot=bar] {@extend .baz}', '[foo=bar].baz, [foo=bar][foot=bar]'
+    assert_unification '[foo=bar].baz', '[ns|foo=bar] {@extend .baz}', '[foo=bar].baz, [foo=bar][ns|foo=bar]'
+    assert_unification '%-a [foo=bar].bar', '[foo=bar] {@extend .bar}', '-a [foo=bar]'
   end
 
   def test_pseudo_unification
-    assert_equal <<CSS, render(<<SCSS)
-:foo.baz, :foo:foo(2n+1) {
-  a: b; }
-CSS
-:foo.baz {a: b}
-:foo(2n+1) {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-:foo.baz, :foo::foo {
-  a: b; }
-CSS
-:foo.baz {a: b}
-::foo {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-::foo.baz {
-  a: b; }
-CSS
-::foo.baz {a: b}
-::bar {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-::foo.baz {
-  a: b; }
-CSS
-::foo.baz {a: b}
-::foo(2n+1) {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-::foo {
-  a: b; }
-CSS
-::foo.baz {a: b}
-::foo {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-::foo(2n+1) {
-  a: b; }
-CSS
-::foo(2n+1).baz {a: b}
-::foo(2n+1) {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-:foo.baz, :foo:bar {
-  a: b; }
-CSS
-:foo.baz {a: b}
-:bar {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.baz:foo, :foo:after {
-  a: b; }
-CSS
-.baz:foo {a: b}
-:after {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.baz:after, :foo:after {
-  a: b; }
-CSS
-.baz:after {a: b}
-:foo {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-:foo {
-  a: b; }
-CSS
-:foo.baz {a: b}
-:foo {@extend .baz}
-SCSS
+    assert_unification ':foo.baz', ':foo(2n+1) {@extend .baz}', ':foo.baz, :foo:foo(2n+1)'
+    assert_unification ':foo.baz', '::foo {@extend .baz}', ':foo.baz, :foo::foo'
+    assert_unification '::foo.baz', '::bar {@extend .baz}', '::foo.baz'
+    assert_unification '::foo.baz', '::foo(2n+1) {@extend .baz}', '::foo.baz'
+    assert_unification '::foo.baz', '::foo {@extend .baz}', '::foo'
+    assert_unification '::foo(2n+1).baz', '::foo(2n+1) {@extend .baz}', '::foo(2n+1)'
+    assert_unification ':foo.baz', ':bar {@extend .baz}', ':foo.baz, :foo:bar'
+    assert_unification '.baz:foo', ':after {@extend .baz}', '.baz:foo, :foo:after'
+    assert_unification '.baz:after', ':foo {@extend .baz}', '.baz:after, :foo:after'
+    assert_unification ':foo.baz', ':foo {@extend .baz}', ':foo'
   end
 
   def test_pseudoelement_remains_at_end_of_selector
@@ -851,29 +375,9 @@ SCSS
   end
 
   def test_negation_unification
-    assert_equal <<CSS, render(<<SCSS)
-:not(.foo).baz, :not(.foo):not(.bar) {
-  a: b; }
-CSS
-:not(.foo).baz {a: b}
-:not(.bar) {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-:not(.foo) {
-  a: b; }
-CSS
-:not(.foo).baz {a: b}
-:not(.foo) {@extend .baz}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-:not([a=b]) {
-  a: b; }
-CSS
-:not([a=b]).baz {a: b}
-:not([a = b]) {@extend .baz}
-SCSS
+    assert_unification ':not(.foo).baz', ':not(.bar) {@extend .baz}', ':not(.foo).baz, :not(.foo):not(.bar)'
+    assert_unification ':not(.foo).baz', ':not(.foo) {@extend .baz}', ':not(.foo)'
+    assert_unification ':not([a=b]).baz', ':not([a = b]) {@extend .baz}', ':not([a=b])'
   end
 
   def test_comma_extendee
@@ -2023,6 +1527,36 @@ d {@extend a}
 SCSS
   end
 
+  def test_extend_redundancy_elimination_when_it_would_reduce_specificity
+    assert_equal <<CSS, render(<<SCSS)
+a, a.foo {
+  x: y; }
+CSS
+a {x: y}
+a.foo {@extend a}
+SCSS
+  end
+
+  def test_extend_redundancy_elimination_when_it_would_preserve_specificity
+    assert_equal <<CSS, render(<<SCSS)
+.bar a {
+  x: y; }
+CSS
+.bar a {x: y}
+a.foo {@extend a}
+SCSS
+  end
+
+  def test_extend_redundancy_elimination_never_eliminates_base_selector
+    assert_equal <<CSS, render(<<SCSS)
+a.foo, .foo {
+  x: y; }
+CSS
+a.foo {x: y}
+.foo {@extend a}
+SCSS
+  end
+
   def test_extend_cross_branch_redundancy_elimination
     assert_equal <<CSS, render(<<SCSS)
 a c d, b c a d {
@@ -2046,6 +1580,17 @@ SCSS
 
   private
 
+  def assert_unification(selector, extension, unified)
+    assert_equal <<CSS, render(<<SCSS)
+#{unified.split(', ').map {|s| "-a #{s}"}.join(', ')} {
+  a: b; }
+CSS
+%-a #{selector} {a: b}
+#{extension}
+-a {@extend %-a}
+SCSS
+  end
+
   def render(sass, options = {})
     munge_filename options
     Sass::Engine.new(sass, {:syntax => :scss}.merge(options)).render