haml 3.0.0.beta.3 → 3.0.0.rc.1

data/test/haml/helper_test.rb

@@ -15,7 +15,18 @@ module Haml::Helpers
 end
 
 class HelperTest < Test::Unit::TestCase
-  Post = Struct.new('Post', :body)
+  Post = Struct.new('Post', :body, :error_field, :errors)
+  class PostErrors
+    def on(name)
+      return unless name == 'error_field'
+      ["Really bad error"]
+    end
+    alias_method :full_messages, :on
+
+    def [](name)
+      on(name) || []
+    end
+  end
   
   def setup
     @base = ActionView::Base.new
@@ -26,7 +37,7 @@ class HelperTest < Test::Unit::TestCase
       @base.controller.response = ActionController::Response.new
     end
 
-    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz"))
+    @base.instance_variable_set('@post', Post.new("Foo bar\nbaz", nil, PostErrors.new))
   end
 
   def render(text, options = {})
@@ -153,6 +164,18 @@ HTML
 HAML
   end
 
+  def test_content_tag_error_wrapping
+    def @base.protect_against_forgery?; false; end
+    assert_equal(<<HTML, render(<<HAML, :action_view))
+<form action="" method="post">
+  <div class="fieldWithErrors"><label for="post_error_field">Error field</label></div>
+</form>
+HTML
+#{rails_block_helper_char} form_for #{form_for_calling_convention('post')}, :url => '' do |f|
+  = f.label 'error_field'
+HAML
+  end
+
   def test_haml_tag_name_attribute_with_id
     assert_equal("<p id='some_id'></p>\n", render("- haml_tag 'p#some_id'"))
   end

data/test/haml/template_test.rb

@@ -288,7 +288,7 @@ END
   <input id="article_body" name="article[body]" size="30" type="text" value="World" />
 </form>
 HTML
-- form_for :article, @article, :url => '' do |f|
+- form_for #{form_for_calling_convention(:article)}, :url => '' do |f|
   Title:
   = f.text_field :title
   Body:
@@ -387,7 +387,7 @@ HAML
   <input id="article_body" name="article[body]" size="30" type="text" value="World" />
 </form>
 HTML
-#{rails_block_helper_char} form_for :article, @article, :url => '' do |f|
+#{rails_block_helper_char} form_for #{form_for_calling_convention(:article)}, :url => '' do |f|
   Title:
   = f.text_field :title
   Body:

data/test/haml/templates/helpers.haml

@@ -62,6 +62,19 @@ click
         <input id="article_body" name="article[body]" size="30" type="text" value="World" />
       </form>
     </div>
+- elsif Haml::Util.ap_geq_3_beta_3?
+  %p
+    = form_tag ''
+  %div
+    = form_tag '' do
+      %div= submit_tag 'save'
+      - @foo = 'value one'
+      = test_partial 'partial'
+    = form_for @article, :as => :article, :url => '', :html => {:class => nil, :id => nil} do |f|
+      Title:
+      = f.text_field :title
+      Body:
+      = f.text_field :body
 - elsif Haml::Util.ap_geq_3?
   %p
     = form_tag ''

data/test/haml/util/subset_map_test.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../../test_helper'
+
+class SubsetMapTest < Test::Unit::TestCase
+  def setup
+    @ssm = Haml::Util::SubsetMap.new
+    @ssm[Set[1, 2]] = "Foo"
+    @ssm[Set["fizz", "fazz"]] = "Bar"
+
+    @ssm[Set[:foo, :bar]] = "Baz"
+    @ssm[Set[:foo, :bar, :baz]] = "Bang"
+
+    @ssm[Set[:bip, :bop, :blip]] = "Qux"
+    @ssm[Set[:bip, :bop]] = "Thram"
+  end
+
+  def test_equal_keys
+    assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2])
+    assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz"])
+  end
+
+  def test_subset_keys
+    assert_equal [["Foo", Set[1, 2]]], @ssm.get(Set[1, 2, "fuzz"])
+    assert_equal [["Bar", Set["fizz", "fazz"]]], @ssm.get(Set["fizz", "fazz", 3])
+  end
+
+  def test_superset_keys
+    assert_equal [], @ssm.get(Set[1])
+    assert_equal [], @ssm.get(Set[2])
+    assert_equal [], @ssm.get(Set["fizz"])
+    assert_equal [], @ssm.get(Set["fazz"])
+  end
+
+  def test_disjoint_keys
+    assert_equal [], @ssm.get(Set[3, 4])
+    assert_equal [], @ssm.get(Set["fuzz", "frizz"])
+    assert_equal [], @ssm.get(Set["gran", 15])
+  end
+
+  def test_semi_disjoint_keys
+    assert_equal [], @ssm.get(Set[2, 3])
+    assert_equal [], @ssm.get(Set["fizz", "fuzz"])
+    assert_equal [], @ssm.get(Set[1, "fazz"])
+  end
+
+  def test_empty_key_set
+    assert_raise(ArgumentError) {@ssm[Set[]] = "Fail"}
+  end
+
+  def test_empty_key_get
+    assert_equal [], @ssm.get(Set[])
+  end
+
+  def test_multiple_subsets
+    assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, "fizz", "fazz"])
+    assert_equal [["Foo", Set[1, 2]], ["Bar", Set["fizz", "fazz"]]], @ssm.get(Set[1, 2, 3, "fizz", "fazz", "fuzz"])
+
+    assert_equal [["Baz", Set[:foo, :bar]]], @ssm.get(Set[:foo, :bar])
+    assert_equal [["Baz", Set[:foo, :bar]], ["Bang", Set[:foo, :bar, :baz]]], @ssm.get(Set[:foo, :bar, :baz])
+  end
+
+  def test_bracket_bracket
+    assert_equal ["Foo"], @ssm[Set[1, 2, "fuzz"]]
+    assert_equal ["Baz", "Bang"], @ssm[Set[:foo, :bar, :baz]]
+  end
+
+  def test_order_preserved
+    @ssm[Set[10, 11, 12]] = 1
+    @ssm[Set[10, 11]] = 2
+    @ssm[Set[11]] = 3
+    @ssm[Set[11, 12]] = 4
+    @ssm[Set[9, 10, 11, 12, 13]] = 5
+    @ssm[Set[10, 13]] = 6
+
+    assert_equal(
+      [[1, Set[10, 11, 12]], [2, Set[10, 11]], [3, Set[11]], [4, Set[11, 12]],
+        [5, Set[9, 10, 11, 12, 13]], [6, Set[10, 13]]],
+      @ssm.get(Set[9, 10, 11, 12, 13]))
+  end
+
+  def test_multiple_equal_values
+    @ssm[Set[11, 12]] = 1
+    @ssm[Set[12, 13]] = 2
+    @ssm[Set[13, 14]] = 1
+    @ssm[Set[14, 15]] = 1
+
+    assert_equal(
+      [[1, Set[11, 12]], [2, Set[12, 13]], [1, Set[13, 14]], [1, Set[14, 15]]],
+      @ssm.get(Set[11, 12, 13, 14, 15]))
+  end
+end

data/test/haml/util_test.rb

@@ -66,6 +66,24 @@ class UtilTest < Test::Unit::TestCase
       merge_adjacent_strings(["foo ", "bar ", "baz", :bang, "biz", " bop", 12]))
   end
 
+  def test_intersperse
+    assert_equal(["foo", " ", "bar", " ", "baz"],
+      intersperse(%w[foo bar baz], " "))
+    assert_equal([], intersperse([], " "))
+  end
+
+  def test_substitute
+    assert_equal(["foo", "bar", "baz", 3, 4],
+      substitute([1, 2, 3, 4], [1, 2], ["foo", "bar", "baz"]))
+    assert_equal([1, "foo", "bar", "baz", 4],
+      substitute([1, 2, 3, 4], [2, 3], ["foo", "bar", "baz"]))
+    assert_equal([1, 2, "foo", "bar", "baz"],
+      substitute([1, 2, 3, 4], [3, 4], ["foo", "bar", "baz"]))
+
+    assert_equal([1, "foo", "bar", "baz", 2, 3, 4],
+      substitute([1, 2, 2, 2, 3, 4], [2, 2], ["foo", "bar", "baz"]))
+  end
+
   def test_strip_string_array
     assert_equal(["foo ", " bar ", " baz"],
       strip_string_array([" foo ", " bar ", " baz "]))
@@ -75,6 +93,13 @@ class UtilTest < Test::Unit::TestCase
       strip_string_array([" foo ", " bar ", :baz]))
   end
 
+  def test_paths
+    assert_equal([[1, 3, 5], [2, 3, 5], [1, 4, 5], [2, 4, 5]],
+      paths([[1, 2], [3, 4], [5]]))
+    assert_equal([[]], paths([]))
+    assert_equal([[1, 2, 3]], paths([[1], [2], [3]]))
+  end
+
   def test_silence_warnings
     old_stderr, $stderr = $stderr, StringIO.new
     warn "Out"

data/test/sass/conversion_test.rb

@@ -183,7 +183,7 @@ SASS
   def test_multiline_properties
     assert_scss_to_sass <<SASS, <<SCSS
 foo bar
-  baz: bip bam boon
+  baz: bip   bam         boon
 SASS
 foo bar {
   baz:
@@ -194,7 +194,7 @@ SCSS
 
     assert_scss_to_scss <<OUT, <<IN
 foo bar {
-  baz: bip bam boon; }
+  baz: bip   bam         boon; }
 OUT
 foo bar {
   baz:
@@ -915,7 +915,7 @@ SCSS
     assert_selector_renders['> E']
     assert_selector_renders['+ E']
     assert_selector_renders['~ E']
-    assert_selector_renders['>> E']
+    assert_selector_renders['> > E']
 
     assert_selector_renders['E*']
     assert_selector_renders['E*.foo']
@@ -1031,6 +1031,26 @@ div
 SASS
   end
 
+  def test_sass2_var_in_property_interpolation
+assert_sass_to_scss <<SCSS, <<SASS
+foo {
+  a: b \#{$c} d; }
+SCSS
+foo
+  a: b \#{!c} d
+SASS
+  end
+
+  def test_sass2_var_in_selector_interpolation
+assert_sass_to_scss <<SCSS, <<SASS
+foo-\#{$c} {
+  a: b; }
+SCSS
+foo-\#{!c}
+  a: b
+SASS
+  end
+
   private
 
   def assert_sass_to_sass(sass, options = {})

data/test/sass/engine_test.rb

@@ -592,6 +592,36 @@ END
     assert_equal("@a{b:c;#d{e:f}g:h}\n", render(to_render, :style => :compressed))
   end
 
+  def test_property_hacks
+    assert_equal(<<CSS, render(<<SASS))
+foo {
+  _name: val;
+  *name: val;
+  #name: val;
+  .name: val;
+  name: val; }
+CSS
+foo
+  _name: val
+  *name: val
+  #name: val
+  .name: val
+  name: val
+SASS
+  end
+
+  def test_properties_with_space_after_colon
+    assert_equal <<CSS, render(<<SASS)
+foo {
+  bar: baz;
+  bizz: bap; }
+CSS
+foo
+  bar : baz
+  bizz	: bap
+SASS
+  end
+
   def test_line_annotations
     assert_equal(<<CSS, render(<<SASS, :line_comments => true, :style => :compact))
 /* line 2, test_line_annotations_inline.sass */
@@ -980,6 +1010,19 @@ a-\#{$a}
 SASS
   end
 
+  def test_complex_property_interpolation
+    assert_equal(<<CSS, render(<<SASS))
+a-1 {
+  b-2 3-fizzap18: c-3; }
+CSS
+$a: 1
+$b: 2
+$c: 3
+a-\#{$a}
+  b-\#{$b $c}-\#{fizzap + ($c + 15)}: c-\#{$a + $b}
+SASS
+  end
+
   def test_if_directive
     assert_equal("a {\n  b: 1; }\n", render(<<SASS))
 $var: true
@@ -994,16 +1037,16 @@ SASS
   def test_for
     assert_equal(<<CSS, render(<<SASS))
 a-0 {
-  2i: 0; }
+  two-i: 0; }
 
 a-1 {
-  2i: 2; }
+  two-i: 2; }
 
 a-2 {
-  2i: 4; }
+  two-i: 4; }
 
 a-3 {
-  2i: 6; }
+  two-i: 6; }
 
 b-1 {
   j-1: 0; }
@@ -1020,7 +1063,7 @@ CSS
 $a: 3
 @for $i from 0 to $a + 1
   a-\#{$i}
-    2i: 2 * $i
+    two-i: 2 * $i
 
 @for $j from 1 through 4
   b-\#{$j}
@@ -1348,7 +1391,7 @@ SASS
 
   def test_attribute_selector_with_spaces
     assert_equal(<<CSS, render(<<SASS))
-a b[foo = bar] {
+a b[foo=bar] {
   c: d; }
 CSS
 a
@@ -1542,7 +1585,7 @@ SASS
 
   def test_interpolation_doesnt_deep_unquote_strings
     assert_equal(<<CSS, render(<<SASS))
-.foo-"bar" "baz" {
+.foo- "bar" "baz" {
   a: b; }
 CSS
 .foo-\#{"bar" "baz"}

data/test/sass/extend_test.rb

@@ -0,0 +1,1045 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+
+class ExtendTest < Test::Unit::TestCase
+  def test_basic
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+CSS
+.foo {a: b}
+.bar {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+CSS
+.bar {@extend .foo}
+.foo {a: b}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+
+.bar {
+  c: d; }
+CSS
+.foo {a: b}
+.bar {c: d; @extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+
+.bar {
+  c: d; }
+CSS
+.foo {a: b}
+.bar {@extend .foo; c: d}
+SCSS
+  end
+
+  def test_indented_syntax
+    assert_equal <<CSS, render(<<SASS, :syntax => :sass)
+.foo, .bar {
+  a: b; }
+CSS
+.foo
+  a: b
+.bar
+  @extend .foo
+SASS
+
+    assert_equal <<CSS, render(<<SASS, :syntax => :sass)
+.foo, .bar {
+  a: b; }
+CSS
+.foo
+  a: b
+.bar
+  @extend \#{".foo"}
+SASS
+  end
+
+  def test_multiple_targets
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+
+.blip .foo, .blip .bar {
+  c: d; }
+CSS
+.foo {a: b}
+.bar {@extend .foo}
+.blip .foo {c: d}
+SCSS
+  end
+
+  def test_multiple_extendees
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .baz {
+  a: b; }
+
+.bar, .baz {
+  c: d; }
+CSS
+.foo {a: b}
+.bar {c: d}
+.baz {@extend .foo; @extend .bar}
+SCSS
+  end
+
+  def test_multiple_extends_with_single_extender_and_single_target
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .baz .bar, .foo .baz, .baz .baz {
+  a: b; }
+CSS
+.foo .bar {a: b}
+.baz {@extend .foo; @extend .bar}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .bar.baz, .foo.baz, .baz {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.baz {@extend .foo; @extend .bar}
+SCSS
+  end
+
+  def test_multiple_extends_with_multiple_extenders_and_single_target
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .baz .bar, .foo .bang, .baz .bang {
+  a: b; }
+CSS
+.foo .bar {a: b}
+.baz {@extend .foo}
+.bang {@extend .bar}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .bar.baz, .foo.bang, .baz.bang {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.baz {@extend .foo}
+.bang {@extend .bar}
+SCSS
+  end
+
+  def test_chained_extends
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar, .baz, .bip {
+  a: b; }
+CSS
+.foo {a: b}
+.bar {@extend .foo}
+.baz {@extend .bar}
+.bip {@extend .bar}
+SCSS
+  end
+
+  def test_dynamic_extendee
+    assert_equal <<CSS, render(<<SCSS)
+.foo, .bar {
+  a: b; }
+CSS
+.foo {a: b}
+.bar {@extend \#{".foo"}}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+[baz^="blip12px"], .bar {
+  a: b; }
+CSS
+[baz^="blip12px"] {a: b}
+.bar {@extend [baz^="blip\#{12px}"]}
+SCSS
+  end
+
+  def test_nested_target
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .foo .baz {
+  a: b; }
+CSS
+.foo .bar {a: b}
+.baz {@extend .bar}
+SCSS
+  end
+
+  def test_target_with_child
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .baz .bar {
+  a: b; }
+CSS
+.foo .bar {a: b}
+.baz {@extend .foo}
+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)
+.foo.baz, .baz {
+  a: b; }
+CSS
+.foo.baz {a: b}
+.baz {@extend .foo}
+SCSS
+  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)
+.foo#baz, #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
+  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)
+.foo.bar, .bar {
+  a: b; }
+CSS
+.foo.bar {a: b}
+* {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .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
+  end
+
+  def test_universal_unification_with_namespaceless_universal_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)
+*|*.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)
+*.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
+  end
+
+  def test_universal_unification_with_namespaced_universal_target
+    assert_equal <<CSS, render(<<SCSS)
+ns|*.foo, ns|* {
+  a: b; }
+CSS
+ns|*.foo {a: b}
+* {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+ns|*.foo, 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|*.foo, ns|* {
+  a: b; }
+CSS
+ns|*.foo {a: b}
+ns|* {@extend .foo}
+SCSS
+  end
+
+  def test_universal_unification_with_namespaceless_element_target
+    assert_equal <<CSS, render(<<SCSS)
+a.foo, 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.foo, 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.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
+  end
+
+  def test_universal_unification_with_namespaced_element_target
+    assert_equal <<CSS, render(<<SCSS)
+ns|a.foo, ns|a {
+  a: b; }
+CSS
+ns|a.foo {a: b}
+* {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+ns|a.foo, 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.foo, ns|a {
+  a: b; }
+CSS
+ns|a.foo {a: b}
+ns|* {@extend .foo}
+SCSS
+  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
+  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
+  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
+  end
+
+  def test_element_unification_with_namespaceless_element_target
+    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.foo, 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.foo, *|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
+  end
+
+  def test_element_unification_with_namespaced_element_target
+    assert_equal <<CSS, render(<<SCSS)
+ns|a.foo, ns|a {
+  a: b; }
+CSS
+ns|a.foo {a: b}
+a {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+ns|a.foo, 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.foo, ns|a {
+  a: b; }
+CSS
+ns|a.foo {a: b}
+ns|a {@extend .foo}
+SCSS
+  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].baz, [foo=bar] {
+  a: b; }
+CSS
+[foo=bar].baz {a: b}
+[foo=bar] {@extend .baz}
+SCSS
+  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.baz, ::foo {
+  a: b; }
+CSS
+::foo.baz {a: b}
+::foo {@extend .baz}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+::foo(2n+1).baz, ::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)
+:foo.baz, :foo {
+  a: b; }
+CSS
+:foo.baz {a: b}
+:foo {@extend .baz}
+SCSS
+  end
+
+  def test_pseudoelement_remains_at_end_of_selector
+    assert_equal <<CSS, render(<<SCSS)
+.foo::bar, .baz::bar {
+  a: b; }
+CSS
+.foo::bar {a: b}
+.baz {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a.foo::bar, a.baz::bar {
+  a: b; }
+CSS
+a.foo::bar {a: b}
+.baz {@extend .foo}
+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).baz, :not(.foo) {
+  a: b; }
+CSS
+:not(.foo).baz {a: b}
+:not(.foo) {@extend .baz}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+:not([a=b]).baz, :not([a=b]) {
+  a: b; }
+CSS
+:not([a=b]).baz {a: b}
+:not([a = b]) {@extend .baz}
+SCSS
+  end
+
+  ## Long Extendees
+
+  def test_long_extendee
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .baz {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.baz {@extend .foo.bar}
+SCSS
+  end
+
+  def test_long_extendee_requires_all_selectors
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  a: b; }
+CSS
+.foo {a: b}
+.baz {@extend .foo.bar}
+SCSS
+  end
+
+  def test_long_extendee_matches_supersets
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar.bap, .bap.baz {
+  a: b; }
+CSS
+.foo.bar.bap {a: b}
+.baz {@extend .foo.bar}
+SCSS
+  end
+
+  def test_long_extendee_runs_unification
+    assert_equal <<CSS, render(<<SCSS)
+ns|*.foo.bar, ns|a.baz {
+  a: b; }
+CSS
+ns|*.foo.bar {a: b}
+a.baz {@extend .foo.bar}
+SCSS
+  end
+
+  ## Long Extenders
+
+  def test_long_extender
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, .bar.baz.bang {
+  a: b; }
+CSS
+.foo.bar {a: b}
+.baz.bang {@extend .foo}
+SCSS
+  end
+
+  def test_long_extender_runs_unification
+    assert_equal <<CSS, render(<<SCSS)
+ns|*.foo.bar, ns|a.bar.baz {
+  a: b; }
+CSS
+ns|*.foo.bar {a: b}
+a.baz {@extend .foo}
+SCSS
+  end
+
+  def test_long_extender_aborts_unification
+    assert_equal <<CSS, render(<<SCSS)
+a.foo#bar {
+  a: b; }
+CSS
+a.foo#bar {a: b}
+h1.baz {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a.foo#bar {
+  a: b; }
+CSS
+a.foo#bar {a: b}
+.bang#baz {@extend .foo}
+SCSS
+  end
+
+  ## Nested Extenders
+
+  def test_nested_extender
+    assert_equal <<CSS, render(<<SCSS)
+.foo, foo bar {
+  a: b; }
+CSS
+.foo {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_runs_unification
+    assert_equal <<CSS, render(<<SCSS)
+.foo.bar, foo bar.bar {
+  a: b; }
+CSS
+.foo.bar {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_aborts_unification
+    assert_equal <<CSS, render(<<SCSS)
+baz.foo {
+  a: b; }
+CSS
+baz.foo {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_interleaves_parents_with_unification
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz foo bar, foo.baz bar, foo .baz bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_interleaves_parents_with_aborted_unification
+    assert_equal <<CSS, render(<<SCSS)
+baz .foo, baz foo bar, foo baz bar {
+  a: b; }
+CSS
+baz .foo {a: b}
+foo bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_with_lots_of_interleaving
+    # Please, never ever do this in a real stylesheet
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar .baz .bang, .foo .bar .baz .foo2 .bar2 .baz2 .bang2, .foo .bar .foo2.baz .bar2 .baz2 .bang2, .foo .bar .foo2 .baz .bar2 .baz2 .bang2, .foo .bar .foo2 .bar2.baz .baz2 .bang2, .foo .bar .foo2 .bar2 .baz .baz2 .bang2, .foo .bar .foo2 .bar2 .baz2.baz .bang2, .foo .bar .foo2 .bar2 .baz2 .baz .bang2, .foo .foo2.bar .baz .bar2 .baz2 .bang2, .foo .foo2.bar .bar2.baz .baz2 .bang2, .foo .foo2.bar .bar2 .baz .baz2 .bang2, .foo .foo2.bar .bar2 .baz2.baz .bang2, .foo .foo2.bar .bar2 .baz2 .baz .bang2, .foo .foo2 .bar .baz .bar2 .baz2 .bang2, .foo .foo2 .bar .bar2.baz .baz2 .bang2, .foo .foo2 .bar .bar2 .baz .baz2 .bang2, .foo .foo2 .bar .bar2 .baz2.baz .bang2, .foo .foo2 .bar .bar2 .baz2 .baz .bang2, .foo .foo2 .bar2.bar .baz .baz2 .bang2, .foo .foo2 .bar2.bar .baz2.baz .bang2, .foo .foo2 .bar2.bar .baz2 .baz .bang2, .foo .foo2 .bar2 .bar .baz .baz2 .bang2, .foo .foo2 .bar2 .bar .baz2.baz .bang2, .foo .foo2 .bar2 .bar .baz2 .baz .bang2, .foo .foo2 .bar2 .baz2.bar .baz .bang2, .foo .foo2 .bar2 .baz2 .bar .baz .bang2, .foo2.foo .bar .baz .bar2 .baz2 .bang2, .foo2.foo .bar .bar2.baz .baz2 .bang2, .foo2.foo .bar .bar2 .baz .baz2 .bang2, .foo2.foo .bar .bar2 .baz2.baz .bang2, .foo2.foo .bar .bar2 .baz2 .baz .bang2, .foo2.foo .bar2.bar .baz .baz2 .bang2, .foo2.foo .bar2.bar .baz2.baz .bang2, .foo2.foo .bar2.bar .baz2 .baz .bang2, .foo2.foo .bar2 .bar .baz .baz2 .bang2, .foo2.foo .bar2 .bar .baz2.baz .bang2, .foo2.foo .bar2 .bar .baz2 .baz .bang2, .foo2.foo .bar2 .baz2.bar .baz .bang2, .foo2.foo .bar2 .baz2 .bar .baz .bang2, .foo2 .foo .bar .baz .bar2 .baz2 .bang2, .foo2 .foo .bar .bar2.baz .baz2 .bang2, .foo2 .foo .bar .bar2 .baz .baz2 .bang2, .foo2 .foo .bar .bar2 .baz2.baz .bang2, .foo2 .foo .bar .bar2 .baz2 .baz .bang2, .foo2 .foo .bar2.bar .baz .baz2 .bang2, .foo2 .foo .bar2.bar .baz2.baz .bang2, .foo2 .foo .bar2.bar .baz2 .baz .bang2, .foo2 .foo .bar2 .bar .baz .baz2 .bang2, .foo2 .foo .bar2 .bar .baz2.baz .bang2, .foo2 .foo .bar2 .bar .baz2 .baz .bang2, .foo2 .foo .bar2 .baz2.bar .baz .bang2, .foo2 .foo .bar2 .baz2 .bar .baz .bang2, .foo2 .bar2.foo .bar .baz .baz2 .bang2, .foo2 .bar2.foo .bar .baz2.baz .bang2, .foo2 .bar2.foo .bar .baz2 .baz .bang2, .foo2 .bar2.foo .baz2.bar .baz .bang2, .foo2 .bar2.foo .baz2 .bar .baz .bang2, .foo2 .bar2 .foo .bar .baz .baz2 .bang2, .foo2 .bar2 .foo .bar .baz2.baz .bang2, .foo2 .bar2 .foo .bar .baz2 .baz .bang2, .foo2 .bar2 .foo .baz2.bar .baz .bang2, .foo2 .bar2 .foo .baz2 .bar .baz .bang2, .foo2 .bar2 .baz2.foo .bar .baz .bang2, .foo2 .bar2 .baz2 .foo .bar .baz .bang2 {
+  a: b; }
+CSS
+.foo .bar .baz .bang {a: b}
+.foo2 .bar2 .baz2 .bang2 {@extend .bang}
+SCSS
+  end
+
+  def test_nested_extender_with_child_selector
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz foo > bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+foo > bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_with_descendant_and_child_selector
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz bang foo > bar, bang.baz foo > bar, bang .baz foo > bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+bang foo > bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_with_child_selector_unifies
+    assert_equal <<CSS, render(<<SCSS)
+.baz.foo, foo > bar.baz {
+  a: b; }
+CSS
+.baz.foo {a: b}
+foo > bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_with_child_selector_and_more
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .foo foo > bar baz, foo > bar.foo baz, foo > bar .foo baz {
+  a: b; }
+CSS
+.foo .bar {a: b}
+foo > bar baz {@extend .bar}
+SCSS
+  end
+
+  def test_nested_extender_with_trailing_child_selector
+    assert_raise(Sass::SyntaxError, "bar > can't extend: invalid selector") do
+      render("bar > {@extend .baz}")
+    end
+  end
+
+  def test_nested_extender_with_sibling_selector
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz foo + bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+foo + bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_with_hacky_selector
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz foo + > > + bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+foo + > > + bar {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.baz .foo, .baz > > bar {
+  a: b; }
+CSS
+.baz .foo {a: b}
+> > bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_merges_with_same_selector
+    assert_equal <<CSS, render(<<SCSS)
+.foo .bar, .foo .baz {
+  a: b; }
+CSS
+.foo {
+  .bar {a: b}
+  .baz {@extend .bar} }
+SCSS
+  end
+
+  def test_nested_extender_with_child_selector_merges_with_same_selector
+    assert_equal <<CSS, render(<<SCSS)
+.foo > .bar .baz, .foo > .bar .bang {
+  a: b; }
+CSS
+.foo > .bar .baz {a: b}
+.foo > .bar .bang {@extend .baz}
+SCSS
+  end
+
+  private
+
+  def render(sass, options = {})
+    munge_filename options
+    Sass::Engine.new(sass, {:syntax => :scss}.merge(options)).render
+  end
+end