sass 3.3.0 → 3.4.25

data/test/sass/exec_test.rb

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
+require 'fileutils'
 require 'sass/util/test'
 require 'tmpdir'
 
-class ExecTest < Test::Unit::TestCase
+class ExecTest < MiniTest::Test
   include Sass::Util::Test
 
   def setup
@@ -19,7 +20,7 @@ class ExecTest < Test::Unit::TestCase
     src = get_path("src.scss")
     dest = get_path("dest.css")
     write(src, ".ruleset { margin: 0 }")
-    assert(exec(*%w[scss -t expanded --unix-newlines].push(src, dest)))
+    assert(exec(*%w[scss --sourcemap=none -t expanded --unix-newlines].push(src, dest)))
     assert_equal(".ruleset {\n  margin: 0;\n}\n", read(dest))
   end
 
@@ -64,6 +65,14 @@ class ExecTest < Test::Unit::TestCase
     assert_equal(".ruleset\r\n  margin: 0\r\n", read(src))
   end
 
+  def test_sass_convert_R
+    Dir.chdir(@dir) do
+      src = get_path("styles/src.css")
+      write(src, ".ruleset { margin: 0 }")
+      assert(exec(*%w[sass-convert -Rq --from css --to scss --trace styles]))
+    end
+  end
+
   private
 
   def get_path(name)
@@ -75,6 +84,7 @@ class ExecTest < Test::Unit::TestCase
   end
 
   def write(file, content)
+    FileUtils.mkdir_p(File.dirname(file))
     open(file, 'wb') {|f| f.write(content)}
   end
 

data/test/sass/extend_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 
-class ExtendTest < Test::Unit::TestCase
+class ExtendTest < MiniTest::Test
   def test_basic
     assert_equal <<CSS, render(<<SCSS)
 .foo, .bar {
@@ -145,8 +145,8 @@ SCSS
   end
 
   def test_class_unification
-    assert_unification '.foo.bar', '.baz {@extend .foo}', '.foo.bar, .bar.baz' 
-    assert_unification '.foo.baz', '.baz {@extend .foo}', '.baz' 
+    assert_unification '.foo.bar', '.baz {@extend .foo}', '.foo.bar, .bar.baz'
+    assert_unification '.foo.baz', '.baz {@extend .foo}', '.baz'
   end
 
   def test_id_unification
@@ -167,42 +167,52 @@ SCSS
   end
 
   def test_universal_unification_with_namespaceless_universal_target
+    assert_extend_doesnt_match('ns|*', '.foo', :failed_to_unify, 2) do
+      render_unification '*.foo', 'ns|* {@extend .foo}'
+    end
+
     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_unification 'ns|*.foo', '* {@extend .foo}', 'ns|*'
-    assert_unification 'ns|*.foo', '*|* {@extend .foo}', 'ns|*'
+    assert_extend_doesnt_match('*', '.foo', :failed_to_unify, 2) do
+      render_unification 'ns|*.foo', '* {@extend .foo}'
+    end
 
     assert_extend_doesnt_match('ns2|*', '.foo', :failed_to_unify, 2) do
       render_unification 'ns1|*.foo', 'ns2|* {@extend .foo}'
     end
 
+    assert_unification 'ns|*.foo', '*|* {@extend .foo}', 'ns|*'
     assert_unification 'ns|*.foo', 'ns|* {@extend .foo}', 'ns|*'
   end
 
   def test_universal_unification_with_namespaceless_element_target
+    assert_extend_doesnt_match('ns|*', '.foo', :failed_to_unify, 2) do
+      render_unification 'a.foo', 'ns|* {@extend .foo}'
+    end
+
     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_unification 'ns|a.foo', '* {@extend .foo}', 'ns|a'
-    assert_unification 'ns|a.foo', '*|* {@extend .foo}', 'ns|a'
+    assert_extend_doesnt_match('*', '.foo', :failed_to_unify, 2) do
+      render_unification 'ns|a.foo', '* {@extend .foo}'
+    end
 
     assert_extend_doesnt_match('ns2|*', '.foo', :failed_to_unify, 2) do
       render_unification 'ns1|a.foo', 'ns2|* {@extend .foo}'
     end
 
+    assert_unification 'ns|a.foo', '*|* {@extend .foo}', 'ns|a'
     assert_unification 'ns|a.foo', 'ns|* {@extend .foo}', 'ns|a'
   end
 
@@ -214,46 +224,56 @@ SCSS
   end
 
   def test_element_unification_with_namespaceless_universal_target
+    assert_extend_doesnt_match('ns|a', '.foo', :failed_to_unify, 2) do
+      render_unification '*.foo', 'ns|a {@extend .foo}'
+    end
+
     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_unification 'ns|*.foo', 'a {@extend .foo}', 'ns|*.foo, ns|a'
-    assert_unification 'ns|*.foo', '*|a {@extend .foo}', 'ns|*.foo, ns|a'
+    assert_extend_doesnt_match('a', '.foo', :failed_to_unify, 2) do
+      render_unification 'ns|*.foo', 'a {@extend .foo}'
+    end
 
     assert_extend_doesnt_match('ns2|a', '.foo', :failed_to_unify, 2) do
       render_unification 'ns1|*.foo', 'ns2|a {@extend .foo}'
     end
 
+    assert_unification 'ns|*.foo', '*|a {@extend .foo}', 'ns|*.foo, ns|a'
     assert_unification 'ns|*.foo', 'ns|a {@extend .foo}', 'ns|*.foo, ns|a'
   end
 
   def test_element_unification_with_namespaceless_element_target
+    assert_extend_doesnt_match('ns|a', '.foo', :failed_to_unify, 2) do
+      render_unification 'a.foo', 'ns|a {@extend .foo}'
+    end
+
+    assert_extend_doesnt_match('h1', '.foo', :failed_to_unify, 2) do
+      render_unification 'a.foo', 'h1 {@extend .foo}'
+    end
+
     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_extend_doesnt_match('h1', '.foo', :failed_to_unify, 2) do
-      render_unification 'a.foo', 'h1 {@extend .foo}'
-    end
   end
 
   def test_element_unification_with_namespaced_element_target
-    assert_unification 'ns|a.foo', 'a {@extend .foo}', 'ns|a'
-    assert_unification 'ns|a.foo', '*|a {@extend .foo}', 'ns|a'
+    assert_extend_doesnt_match('a', '.foo', :failed_to_unify, 2) do
+      render_unification 'ns|a.foo', 'a {@extend .foo}'
+    end
 
     assert_extend_doesnt_match('ns2|a', '.foo', :failed_to_unify, 2) do
       render_unification 'ns1|a.foo', 'ns2|a {@extend .foo}'
     end
 
+    assert_unification 'ns|a.foo', '*|a {@extend .foo}', 'ns|a'
     assert_unification 'ns|a.foo', 'ns|a {@extend .foo}', 'ns|a'
   end
 
@@ -310,9 +330,207 @@ SCSS
   end
 
   def test_negation_unification
-    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])'
+    assert_extends ':not(.foo).baz', ':not(.bar) {@extend .baz}', ':not(.foo).baz, :not(.foo):not(.bar)'
+    # Unifying to :not(.foo) here would reduce the specificity of the original selector.
+    assert_extends ':not(.foo).baz', ':not(.foo) {@extend .baz}', ':not(.foo).baz, :not(.foo)'
+  end
+
+  def test_prefixed_pseudoclass_unification
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n of .foo) {@extend .baz}',
+      ':nth-child(2n+1 of .foo).baz, :nth-child(2n+1 of .foo):nth-child(2n of .foo)')
+
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n+1 of .bar) {@extend .baz}',
+      ':nth-child(2n+1 of .foo).baz, :nth-child(2n+1 of .foo):nth-child(2n+1 of .bar)')
+
+    assert_unification(
+      ':nth-child(2n+1 of .foo).baz',
+      ':nth-child(2n+1 of .foo) {@extend .baz}',
+      ':nth-child(2n+1 of .foo)')
+  end
+
+  def test_extend_into_not
+    assert_extends(':not(.foo)', '.x {@extend .foo}', ':not(.foo):not(.x)')
+    assert_extends(':not(.foo.bar)', '.x {@extend .bar}', ':not(.foo.bar):not(.foo.x)')
+    assert_extends(
+      ':not(.foo.bar, .baz.bar)',
+      '.x {@extend .bar}',
+      ':not(.foo.bar, .foo.x, .baz.bar, .baz.x)')
+  end
+
+  def test_extend_into_mergeable_pseudoclasses
+    assert_extends(':matches(.foo)', '.x {@extend .foo}', ':matches(.foo, .x)')
+    assert_extends(':matches(.foo.bar)', '.x {@extend .bar}', ':matches(.foo.bar, .foo.x)')
+    assert_extends(
+      ':matches(.foo.bar, .baz.bar)',
+      '.x {@extend .bar}',
+      ':matches(.foo.bar, .foo.x, .baz.bar, .baz.x)')
+
+    assert_extends(':-moz-any(.foo)', '.x {@extend .foo}', ':-moz-any(.foo, .x)')
+    assert_extends(':current(.foo)', '.x {@extend .foo}', ':current(.foo, .x)')
+    assert_extends(':has(.foo)', '.x {@extend .foo}', ':has(.foo, .x)')
+    assert_extends(':host(.foo)', '.x {@extend .foo}', ':host(.foo, .x)')
+    assert_extends(':host-context(.foo)', '.x {@extend .foo}', ':host-context(.foo, .x)')
+    assert_extends(':nth-child(n of .foo)', '.x {@extend .foo}', ':nth-child(n of .foo, .x)')
+    assert_extends(
+      ':nth-last-child(n of .foo)',
+      '.x {@extend .foo}',
+      ':nth-last-child(n of .foo, .x)')
+  end
+
+  def test_complex_extend_into_pseudoclass
+    # Unlike other selectors, we don't allow complex selectors to be
+    # added to `:not` if they weren't there before. At time of
+    # writing, most browsers don't support that and will throw away
+    # the entire selector if it exists.
+    #assert_extends(':not(.bar)', '.x .y {@extend .bar}', ':not(.bar)')
+
+    # If the `:not()` already has a complex selector, we won't break
+    # anything by adding a new one.
+    assert_extends(':not(.baz .bar)', '.x .y {@extend .bar}',
+      ':not(.baz .bar):not(.baz .x .y):not(.x .baz .y)')
+
+    # If the `:not()` would only contain complex selectors, there's no
+    # harm in letting it continue to exist.
+    assert_extends(':not(%bar)', '.x .y {@extend %bar}', ':not(.x .y)')
+
+    assert_extends(':matches(.bar)', '.x .y {@extend .bar}', ':matches(.bar, .x .y)')
+    assert_extends(':current(.bar)', '.x .y {@extend .bar}', ':current(.bar, .x .y)')
+    assert_extends(':has(.bar)', '.x .y {@extend .bar}', ':has(.bar, .x .y)')
+    assert_extends(':host(.bar)', '.x .y {@extend .bar}', ':host(.bar, .x .y)')
+    assert_extends(':host-context(.bar)', '.x .y {@extend .bar}', ':host-context(.bar, .x .y)')
+    assert_extends(
+      ':-moz-any(.bar)',
+      '.x .y {@extend .bar}',
+      ':-moz-any(.bar, .x .y)')
+    assert_extends(
+      ':nth-child(n of .bar)',
+      '.x .y {@extend .bar}',
+      ':nth-child(n of .bar, .x .y)')
+    assert_extends(
+      ':nth-last-child(n of .bar)',
+      '.x .y {@extend .bar}',
+      ':nth-last-child(n of .bar, .x .y)')
+  end
+
+  def test_extend_over_selector_pseudoclass
+    assert_extends(':not(.foo)', '.x {@extend :not(.foo)}', ':not(.foo), .x')
+    assert_extends(
+      ':matches(.foo, .bar)',
+      '.x {@extend :matches(.foo, .bar)}',
+      ':matches(.foo, .bar), .x')
+  end
+
+  def test_matches_within_not
+    assert_extends(
+      ':not(.foo, .bar)',
+      ':matches(.x, .y) {@extend .foo}',
+      ':not(.foo, .x, .y, .bar)')
+  end
+
+  def test_pseudoclasses_merge
+    assert_extends(':matches(.foo)', ':matches(.bar) {@extend .foo}', ':matches(.foo, .bar)')
+    assert_extends(':-moz-any(.foo)', ':-moz-any(.bar) {@extend .foo}', ':-moz-any(.foo, .bar)')
+    assert_extends(':current(.foo)', ':current(.bar) {@extend .foo}', ':current(.foo, .bar)')
+    assert_extends(
+      ':nth-child(n of .foo)',
+      ':nth-child(n of .bar) {@extend .foo}',
+      ':nth-child(n of .foo, .bar)')
+    assert_extends(
+      ':nth-last-child(n of .foo)',
+      ':nth-last-child(n of .bar) {@extend .foo}',
+      ':nth-last-child(n of .foo, .bar)')
+  end
+
+  def test_nesting_pseudoclasses_merge
+    assert_extends(':has(.foo)', ':has(.bar) {@extend .foo}', ':has(.foo, :has(.bar))')
+    assert_extends(':host(.foo)', ':host(.bar) {@extend .foo}', ':host(.foo, :host(.bar))')
+    assert_extends(
+      ':host-context(.foo)',
+      ':host-context(.bar) {@extend .foo}',
+      ':host-context(.foo, :host-context(.bar))')
+  end
+
+  def test_not_unifies_with_unique_values
+    assert_unification('foo', ':not(bar) {@extend foo}', ':not(bar)')
+    assert_unification('#foo', ':not(#bar) {@extend #foo}', ':not(#bar)')
+  end
+
+  def test_not_adds_no_specificity
+    assert_specificity_equals(':not(.foo)', '.foo')
+  end
+
+  def test_matches_has_a_specificity_range
+    # `:matches(.foo, #bar)` has minimum specificity equal to that of `.foo`,
+    # which means `:matches(.foo, #bar) .a` can have less specificity than
+    # `#b.a`. Thus the selector generated by `#b.a` should be preserved.
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.foo, #bar) .a, :matches(.foo, #bar) #b.a {
+  a: b; }
+CSS
+:matches(.foo, #bar) %x {a: b}
+.a {@extend %x}
+#b.a {@extend %x}
+SCSS
+
+    # `:matches(.foo, #bar)` has maximum specificity equal to that of `#bar`,
+    # which means `:matches(.foo, #bar).b` can have greater specificity than `.a
+    # .b`. Thus the selector generated by `:matches(.foo, #bar).b` should be
+    # preserved.
+    assert_equal <<CSS, render(<<SCSS)
+.a .b, .a .b:matches(.foo, #bar) {
+  a: b; }
+CSS
+.a %x {a: b}
+.b {@extend %x}
+.b:matches(.foo, #bar) {@extend %x}
+SCSS
+  end
+
+  def test_extend_into_not_and_normal_extend
+    assert_equal <<CSS, render(<<SCSS)
+.x:not(.y):not(.bar), .foo:not(.y):not(.bar) {
+  a: b; }
+CSS
+.x:not(.y) {a: b}
+.foo {@extend .x}
+.bar {@extend .y}
+SCSS
+  end
+
+  def test_extend_into_matches_and_normal_extend
+    assert_equal <<CSS, render(<<SCSS)
+.x:matches(.y, .bar), .foo:matches(.y, .bar) {
+  a: b; }
+CSS
+.x:matches(.y) {a: b}
+.foo {@extend .x}
+.bar {@extend .y}
+SCSS
+  end
+
+  def test_multilayer_pseudoclass_extend
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.x, .foo, .bar) {
+  a: b; }
+CSS
+:matches(.x) {a: b}
+.foo {@extend .x}
+.bar {@extend .foo}
+SCSS
+  end
+
+  def test_root_only_allowed_at_root
+    assert_extends(':root .foo', '.bar .baz {@extend .foo}',
+      ':root .foo, :root .bar .baz')
+    assert_extends('.foo:root .bar', '.baz:root .bang {@extend .bar}',
+      '.foo:root .bar, .baz.foo:root .bang')
+    assert_extends('html:root .bar', 'xml:root .bang {@extend .bar}', 'html:root .bar')
+    assert_extends('.foo:root > .bar .x', '.baz:root .bang .y {@extend .x}',
+      '.foo:root > .bar .x, .baz.foo:root > .bar .bang .y')
   end
 
   def test_comma_extendee
@@ -340,24 +558,42 @@ CSS
 SCSS
   end
 
+  def test_nested_pseudo_selectors
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar:not(.baz), .bang .bar:not(.baz) {
+  a: b; }
+CSS
+.foo {
+  .bar:not(.baz) {a: b}
+}
+.bang {@extend .foo}
+SCSS
+  end
+
   ## Long Extendees
 
   def test_long_extendee
-    assert_extends '.foo.bar', '.baz {@extend .foo.bar}', '.foo.bar, .baz'
+    assert_warning(<<WARNING) {assert_extends '.foo.bar', '.baz {@extend .foo.bar}', '.foo.bar, .baz'}
+DEPRECATION WARNING on line 2 of test_long_extendee_inline.scss:
+Extending a compound selector, .foo.bar, is deprecated and will not be supported in a future release.
+See https://github.com/sass/sass/issues/1599 for details.
+WARNING
   end
 
   def test_long_extendee_requires_all_selectors
-    assert_extend_doesnt_match('.baz', '.foo.bar', :not_found, 2) do
-      render_extends '.foo', '.baz {@extend .foo.bar}'
+    silence_warnings do
+      assert_extend_doesnt_match('.baz', '.foo.bar', :not_found, 2) do
+        render_extends '.foo', '.baz {@extend .foo.bar}'
+      end
     end
   end
 
   def test_long_extendee_matches_supersets
-    assert_extends '.foo.bar.bap', '.baz {@extend .foo.bar}', '.foo.bar.bap, .bap.baz'
+    silence_warnings {assert_extends '.foo.bar.bap', '.baz {@extend .foo.bar}', '.foo.bar.bap, .bap.baz'}
   end
 
   def test_long_extendee_runs_unification
-    assert_extends 'ns|*.foo.bar', 'a.baz {@extend .foo.bar}', 'ns|*.foo.bar, ns|a.baz'
+    silence_warnings {assert_extends 'ns|*.foo.bar', '*|a.baz {@extend .foo.bar}', 'ns|*.foo.bar, ns|a.baz'}
   end
 
   ## Long Extenders
@@ -367,7 +603,7 @@ SCSS
   end
 
   def test_long_extender_runs_unification
-    assert_extends 'ns|*.foo.bar', 'a.baz {@extend .foo}', 'ns|*.foo.bar, ns|a.bar.baz'
+    assert_extends 'ns|*.foo.bar', '*|a.baz {@extend .foo}', 'ns|*.foo.bar, ns|a.bar.baz'
   end
 
   def test_long_extender_aborts_unification
@@ -453,9 +689,9 @@ SCSS
   end
 
   def test_nested_extender_doesnt_find_common_selectors_around_reference_selector
-    assert_extends 'a /for/ b c .c1', 'a c .c2 {@extend .c1}', 'a /for/ b c .c1, a /for/ b a c .c2, a a /for/ b c .c2'
-    assert_extends 'a /for/ b c .c1', 'a b .c2 {@extend .c1}', 'a /for/ b c .c1, a a /for/ b c .c2'
-    assert_extends 'a /for/ b c .c1', 'b c .c2 {@extend .c1}', 'a /for/ b c .c1, a /for/ b c .c2'
+    silence_warnings {assert_extends 'a /for/ b c .c1', 'a c .c2 {@extend .c1}', 'a /for/ b c .c1, a /for/ b a c .c2, a a /for/ b c .c2'}
+    silence_warnings {assert_extends 'a /for/ b c .c1', 'a b .c2 {@extend .c1}', 'a /for/ b c .c1, a a /for/ b c .c2'}
+    silence_warnings {assert_extends 'a /for/ b c .c1', 'b c .c2 {@extend .c1}', 'a /for/ b c .c1, a /for/ b c .c2'}
   end
 
   def test_nested_extender_with_early_child_selectors_doesnt_subseq_them
@@ -516,7 +752,7 @@ SCSS
   end
 
   def test_nested_extender_with_trailing_child_selector
-    assert_raise(Sass::SyntaxError, "bar > can't extend: invalid selector") do
+    assert_raises(Sass::SyntaxError, "bar > can't extend: invalid selector") do
       render("bar > {@extend .baz}")
     end
   end
@@ -650,10 +886,10 @@ SCSS
 
   def test_basic_extend_loop
     assert_equal <<CSS, render(<<SCSS)
-.bar, .foo {
+.foo, .bar {
   a: b; }
 
-.foo, .bar {
+.bar, .foo {
   c: d; }
 CSS
 .foo {a: b; @extend .bar}
@@ -663,13 +899,13 @@ SCSS
 
   def test_three_level_extend_loop
     assert_equal <<CSS, render(<<SCSS)
-.baz, .bar, .foo {
+.foo, .baz, .bar {
   a: b; }
 
-.foo, .baz, .bar {
+.bar, .foo, .baz {
   c: d; }
 
-.bar, .foo, .baz {
+.baz, .bar, .foo {
   e: f; }
 CSS
 .foo {a: b; @extend .bar}
@@ -692,6 +928,18 @@ CSS
 SCSS
   end
 
+  def test_cross_loop
+    # The first law of extend means the selector should stick around.
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .foo, .bar {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.foo {@extend .bar}
+.bar {@extend .foo}
+SCSS
+  end
+
   def test_multiple_extender_merges_with_superset_selector
     assert_equal <<CSS, render(<<SCSS)
 a.bar.baz, a.foo {
@@ -830,6 +1078,17 @@ $foo: foo;
 SCSS
   end
 
+  def test_placeholder_in_selector_pseudoclass
+    assert_equal <<CSS, render(<<SCSS)
+:matches(.bar, .baz) {
+  color: blue; }
+CSS
+:matches(%foo) {color: blue}
+.bar {@extend %foo}
+.baz {@extend %foo}
+SCSS
+  end
+
   def test_media_in_placeholder_selector
     assert_equal <<CSS, render(<<SCSS)
 .baz {
@@ -1005,7 +1264,7 @@ SCSS
   end
 
   def test_extend_with_subject_transfers_subject_to_extender
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 foo bar! baz, foo .bip .bap! baz, .bip foo .bap! baz {
   a: b; }
 CSS
@@ -1013,7 +1272,7 @@ foo bar! baz {a: b}
 .bip .bap {@extend bar}
 SCSS
 
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 foo.x bar.y! baz.z, foo.x .bip bar.bap! baz.z, .bip foo.x bar.bap! baz.z {
   a: b; }
 CSS
@@ -1023,7 +1282,7 @@ SCSS
   end
 
   def test_extend_with_subject_retains_subject_on_target
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 .foo! .bar, .foo! .bip .bap, .bip .foo! .bap {
   a: b; }
 CSS
@@ -1033,7 +1292,7 @@ SCSS
   end
 
   def test_extend_with_subject_transfers_subject_to_target
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 a.foo .bar, .bip a.bap! .bar {
   a: b; }
 CSS
@@ -1043,7 +1302,7 @@ SCSS
   end
 
   def test_extend_with_subject_retains_subject_on_extender
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 .foo .bar, .foo .bip! .bap, .bip! .foo .bap {
   a: b; }
 CSS
@@ -1053,7 +1312,7 @@ SCSS
   end
 
   def test_extend_with_subject_fails_with_conflicting_subject
-    assert_equal(<<CSS, render(<<SCSS))
+    silence_warnings {assert_equal(<<CSS, render(<<SCSS))}
 x! .bar {
   a: b; }
 CSS
@@ -1115,6 +1374,16 @@ SCSS
 
   # Regression Tests
 
+  def test_extend_with_middle_pseudo
+    assert_equal(<<CSS, render(<<SCSS))
+.btn:active.focus, :active.focus:before {
+  a: b; }
+CSS
+.btn:active.focus {a: b}
+:before {@extend .btn}
+SCSS
+  end
+
   def test_extend_parent_selector_suffix
     assert_equal <<CSS, render(<<SCSS)
 .a-b, .c {
@@ -1408,7 +1677,7 @@ Use "@extend #{target} !optional" if the extend should be able to fail.
 ERR
   end
 
-  def assert_unification(selector, extension, unified)
+  def assert_unification(selector, extension, unified, nested = true)
     # Do some trickery so the first law of extend doesn't get in our way.
     assert_extends(
       "%-a #{selector}",
@@ -1416,6 +1685,22 @@ ERR
       unified.split(', ').map {|s| "-a #{s}"}.join(', '))
   end
 
+  def assert_specificity_equals(sel1, sel2)
+    assert_specificity_gte(sel1, sel2)
+    assert_specificity_gte(sel2, sel1)
+  end
+
+  def assert_specificity_gte(sel1, sel2)
+    assert_equal <<CSS, render(<<SCSS)
+#{sel1} .a {
+  a: b; }
+CSS
+#{sel1} %-a {a: b}
+.a {@extend %-a}
+#{sel2}.a {@extend %-a}
+SCSS
+  end
+
   def render_unification(selector, extension)
     render_extends(
       "%-a #{selector}",
@@ -1429,6 +1714,10 @@ ERR
 CSS
   end
 
+  def assert_extends_to_nothing(selector, extension)
+    assert_equal '', render_extends(selector, extension)
+  end
+
   def render_extends(selector, extension)
     render(<<SCSS)
 #{selector} {a: b}