haml 3.0.0.rc.4 → 3.0.0.rc.5

data/Rakefile

@@ -263,7 +263,8 @@ OPTS
 
   YARD::Rake::YardocTask.new do |t|
     t.files = FileList.new(scope('lib/**/*.rb')) do |list|
-      list.exclude('lib/haml/template/*.rb')
+      list.exclude('lib/haml/template/patch.rb')
+      list.exclude('lib/haml/template/plugin.rb')
       list.exclude('lib/haml/railtie.rb')
       list.exclude('lib/haml/helpers/action_view_mods.rb')
       list.exclude('lib/haml/helpers/xss_mods.rb')

data/VERSION

@@ -1 +1 @@
-3.0.0.rc.4
+3.0.0.rc.5

data/lib/haml/util.rb

@@ -193,6 +193,24 @@ module Haml
       end
     end
 
+    # Computes a single longest common subsequence for `x` and `y`.
+    # If there are more than one longest common subsequences,
+    # the one returned is that which starts first in `x`.
+    #
+    # @param x [Array]
+    # @param y [Array]
+    # @yield [a, b] An optional block to use in place of a check for equality
+    #   between elements of `x` and `y`.
+    # @yieldreturn [Object, nil] If the two values register as equal,
+    #   this will return the value to use in the LCS array.
+    # @return [Array] The LCS
+    def lcs(x, y, &block)
+      x = [nil, *x]
+      y = [nil, *y]
+      block ||= proc {|a, b| a == b && a}
+      lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
+    end
+
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -564,5 +582,38 @@ METHOD
     def static_method_name(name, *vars)
       "#{name}_#{vars.map {|v| !!v}.join('_')}"
     end
+
+    private
+
+    # Calculates the memoization table for the Least Common Subsequence algorithm.
+    # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS)
+    def lcs_table(x, y)
+      c = Array.new(x.size) {[]}
+      x.size.times {|i| c[i][0] = 0}
+      y.size.times {|j| c[0][j] = 0}
+      (1...x.size).each do |i|
+        (1...y.size).each do |j|
+          c[i][j] =
+            if yield x[i], y[j]
+              c[i-1][j-1] + 1
+            else
+              [c[i][j-1], c[i-1][j]].max
+            end
+        end
+      end
+      return c
+    end
+
+    # Computes a single longest common subsequence for arrays x and y.
+    # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS)
+    def lcs_backtrace(c, x, y, i, j, &block)
+      return [] if i == 0 || j == 0
+      if v = yield(x[i], y[j])
+        return lcs_backtrace(c, x, y, i-1, j-1, &block) << v
+      end
+
+      return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
+      return lcs_backtrace(c, x, y, i-1, j, &block)
+    end
   end
 end

data/lib/sass/script/string.rb

@@ -41,23 +41,8 @@ module Sass::Script
 
     # @see Node#to_s
     def to_s(opts = {})
-      to_sass(opts)
-    end
-
-    # @param opts [{Symbol => Object}]
-    #   `opts[:type]` -- The type of string to render this as.
-    #     `:string`s have double quotes, `:identifier`s do not.
-    #     Defaults to `:identifier`.
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      type = opts[:type] || self.type
-      if type == :identifier
-        if context == :equals && self.value !~ Sass::SCSS::RX::URI &&
-            Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
-          return "unquote(#{Sass::Script::String.new(self.value, :string).to_sass})"
-        elsif context == :equals && self.value.size == 0
-          return %q{""}
-        end
+      if self.type == :identifier
+        return %q{""} if context == :equals && self.value.size == 0
         return self.value.gsub("\n", " ")
       end
 
@@ -67,5 +52,16 @@ module Sass::Script
       return "'#{value}'" unless value.include?("'")
       "\"#{value.gsub('"', "\\\"")}\"" #'
     end
+
+    # @see Node#to_sass
+    def to_sass(opts = {})
+      if self.type == :identifier && context == :equals &&
+          self.value !~ Sass::SCSS::RX::URI &&
+          Sass::SCSS::RX.escape_ident(self.value).include?(?\\)
+        return "unquote(#{Sass::Script::String.new(self.value, :string).to_sass})"
+      else
+        return to_s
+      end
+    end
   end
 end

data/lib/sass/scss/parser.rb

@@ -411,7 +411,18 @@ module Sass
             (tok(/\*/) && Selector::Universal.new(nil))
           res << v
         end
-        expected('"{"') if tok?(/&/)
+
+        if tok?(/&/)
+          begin
+            expected('"{"')
+          rescue Sass::SyntaxError => e
+            e.message << "\n\n" << <<MESSAGE
+In Sass 3, the parent selector & can only be used where element names are valid,
+since it could potentially be replaced by an element name.
+MESSAGE
+            raise e
+          end
+        end
 
         Selector::SimpleSequence.new(res)
       end

data/lib/sass/selector/abstract_sequence.rb

@@ -35,6 +35,28 @@ module Sass
         members.each {|m| m.filename = filename}
         @filename = filename
       end
+
+      # Returns a hash code for this sequence.
+      #
+      # Subclasses should define `#_hash` rather than overriding this method,
+      # which automatically handles memoizing the result.
+      #
+      # @return [Fixnum]
+      def hash
+        @_hash ||= _hash
+      end
+
+      # Checks equality between this and another object.
+      #
+      # Subclasses should define `#_eql?` rather than overriding this method,
+      # which handles checking class equality and hash equality.
+      #
+      # @param other [Object] The object to test equality against
+      # @return [Boolean] Whether or not this is equal to `other`
+      def eql?(other)
+        other.class == self.class && other.hash == self.hash && _eql?(other)
+      end
+      alias_method :==, :eql?
     end
   end
 end

data/lib/sass/selector/comma_sequence.rb

@@ -61,18 +61,13 @@ module Sass
         members.map {|m| m.inspect}.join(", ")
       end
 
-      # Returns a hash code for this sequence.
-      #
-      # @return [Fixnum]
-      def hash
+      private
+
+      def _hash
         members.hash
       end
 
-      # Checks equality between this and another object.
-      #
-      # @param other [Object] The object to test equality against
-      # @return [Boolean] Whether or not this is equal to `other`
-      def eql?(other)
+      def _eql?(other)
         other.class == self.class && other.members.eql?(self.members)
       end
     end

data/lib/sass/selector/sequence.rb

@@ -118,22 +118,6 @@ module Sass
         members.map {|m| m.inspect}.join(" ")
       end
 
-      # Returns a hash code for this sequence.
-      #
-      # @return [Fixnum]
-      def hash
-        members.reject {|m| m == "\n"}.hash
-      end
-
-      # Checks equality between this and another object.
-      #
-      # @param other [Object] The object to test equality against
-      # @return [Boolean] Whether or not this is equal to `other`
-      def eql?(other)
-        other.class == self.class &&
-          other.members.reject {|m| m == "\n"}.eql?(self.members.reject {|m| m == "\n"})
-      end
-
       private
 
       # Conceptually, this expands "parenthesized selectors".
@@ -176,37 +160,77 @@ module Sass
       def subweave(seq1, seq2, cache = {})
         return [seq2] if seq1.empty?
         return [seq1] if seq2.empty?
-        cache[[seq1, seq2]] ||=
-          begin
-            sseq1, rest1 = seq_split(seq1)
-            sseq2, rest2 = seq_split(seq2)
-
-            if sseq1.eql?(sseq2)
-              subweave(rest1, rest2, cache).map {|subseq| sseq1 + subseq}
-            else
-              unified = unify_heads(sseq1, sseq2) || unify_heads(sseq2, sseq1)
-              res = []
-              subweave(rest1, seq2, cache).each {|subseq| res << sseq1 + subseq}
-              subweave(rest1, rest2, cache).each {|subseq| res << unified + subseq} if unified
-              subweave(seq1, rest2, cache).each {|subseq| res << sseq2 + subseq}
-              res
-            end
-          end
+
+        seq1 = group_selectors(seq1)
+        seq2 = group_selectors(seq2)
+        lcs = Haml::Util.lcs(seq2, seq1) do |s1, s2|
+          next s1 if s1 == s2
+          next unless s1.first.is_a?(SimpleSequence) && s2.first.is_a?(SimpleSequence)
+          next s2 if subweave_superselector?(s1, s2)
+          next s1 if subweave_superselector?(s2, s1)
+        end
+
+        diff = []
+        until lcs.empty?
+          diff << chunks(seq1, seq2) {|s| subweave_superselector?(s.first, lcs.first)} << [lcs.shift]
+          seq1.shift
+          seq2.shift
+        end
+        diff << chunks(seq1, seq2) {|s| s.empty?}
+        diff.reject! {|c| c.empty?}
+
+        Haml::Util.paths(diff).map {|p| p.flatten}
+      end
+
+      def chunks(seq1, seq2)
+        chunk1 = []
+        chunk1 << seq1.shift until yield seq1
+        chunk2 = []
+        chunk2 << seq2.shift until yield seq2
+        return [] if chunk1.empty? && chunk2.empty?
+        return [chunk2] if chunk1.empty?
+        return [chunk1] if chunk2.empty?
+        [chunk1 + chunk2, chunk2 + chunk1]
       end
 
-      def seq_split(seq)
+      def group_selectors(seq)
+        newseq = []
         tail = seq.dup
-        head = []
-        begin
-          head << tail.shift
-        end while !tail.empty? && head.last.is_a?(String) || tail.first.is_a?(String)
-        return head, tail
+        until tail.empty?
+          head = []
+          begin
+            head << tail.shift
+          end while !tail.empty? && head.last.is_a?(String) || tail.first.is_a?(String)
+          newseq << head
+        end
+        return newseq
+      end
+
+      def subweave_superselector?(sseq1, sseq2)
+        if sseq1.size > 1
+          # More complex selectors are never superselectors of less complex ones
+          return unless sseq2.size > 1
+          # .foo ~ .bar is a superselector of .foo + .bar
+          return unless sseq1[1] == "~" ? sseq2[1] != ">" : sseq2[1] == sseq1[1]
+          return unless sseq1.first.superselector?(sseq2.first)
+          return true if sseq1.size == 2
+          return false if sseq2.size == 2
+          return subweave_superselector?(sseq1[2..-1], sseq2[2..-1])
+        elsif sseq2.size > 1
+          return true if sseq2[1] == ">" && sseq1.first.superselector?(sseq2.first)
+          return false if sseq2.size == 2
+          return subweave_superselector?(sseq1, sseq2[2..-1])
+        else
+          sseq1.first.superselector?(sseq2.first)
+        end
+      end
+
+      def _hash
+        members.reject {|m| m == "\n"}.hash
       end
 
-      def unify_heads(sseq1, sseq2)
-        return unless sseq2.size == 1 # Can't unify ".foo > .bar" and ".baz > .bang"
-        unified = sseq1.last.unify(sseq2.last.members) unless sseq1.last.is_a?(String) || sseq2.last.is_a?(String)
-        sseq1[0...-1] << unified if unified
+      def _eql?(other)
+        other.members.reject {|m| m == "\n"}.eql?(self.members.reject {|m| m == "\n"})
       end
     end
   end

data/lib/sass/selector/simple.rb

@@ -41,7 +41,7 @@ module Sass
       #
       # @return [Fixnum]
       def hash
-        to_a.hash
+        @_hash ||= to_a.hash
       end
 
       # Checks equality between this and another object.
@@ -53,8 +53,9 @@ module Sass
       # @param other [Object] The object to test equality against
       # @return [Boolean] Whether or not this is equal to `other`
       def eql?(other)
-        other.class == self.class && other.to_a.eql?(to_a)
+        other.class == self.class && other.hash == self.hash && other.to_a.eql?(to_a)
       end
+      alias_method :==, :eql?
 
       # Unifies this selector with a {SimpleSequence}'s {SimpleSequence#members members array},
       # returning another `SimpleSequence` members array

data/lib/sass/selector/simple_sequence.rb

@@ -122,20 +122,14 @@ module Sass
         members.map {|m| m.inspect}.join
       end
 
-      # Returns a hash code for this sequence.
-      #
-      # @return [Fixnum]
-      def hash
+      private
+
+      def _hash
         [base, Haml::Util.set_hash(rest)].hash
       end
 
-      # Checks equality between this and another object.
-      #
-      # @param other [Object] The object to test equality against
-      # @return [Boolean] Whether or not this is equal to `other`
-      def eql?(other)
-        other.class == self.class && other.base.eql?(self.base) &&
-          Haml::Util.set_eql?(other.rest, self.rest)
+      def _eql?(other)
+        other.base.eql?(self.base) && Haml::Util.set_eql?(other.rest, self.rest)
       end
     end
   end

data/lib/sass/tree/import_node.rb

@@ -38,6 +38,11 @@ module Sass
         "#{'  ' * tabs}@import \"#{@imported_filename}\";\n"
       end
 
+      # @see Node#cssize
+      def cssize(*args)
+        super.first
+      end
+
       protected
 
       # @see Node#_cssize

data/lib/sass/tree/node.rb

@@ -120,17 +120,6 @@ module Sass
         self.class == other.class && other.children == children
       end
 
-      # Runs the dynamic Sass code *and* computes the CSS for the tree.
-      #
-      # @see #perform
-      # @see #to_s
-      def render
-        extends = Haml::Util::SubsetMap.new
-        result = perform(Environment.new).cssize(extends)
-        result = result.do_extend(extends) unless extends.empty?
-        result.to_s
-      end
-
       # True if \{#to\_s} will return `nil`;
       # that is, if the node shouldn't be rendered.
       # Should only be called in a static tree.

data/lib/sass/tree/root_node.rb

@@ -21,6 +21,16 @@ module Sass
         raise e
       end
 
+      # Runs the dynamic Sass code *and* computes the CSS for the tree.
+      #
+      # @see #perform
+      # @see #to_s
+      def render
+        result, extends = perform(Environment.new).cssize
+        result = result.do_extend(extends) unless extends.empty?
+        result.to_s
+      end
+
       # @see Node#perform
       def perform(environment)
         environment.options = @options if environment.options.nil? || environment.options.empty?
@@ -30,9 +40,14 @@ module Sass
         raise e
       end
 
-      # @see Node#cssize
-      def cssize(*args)
-        super
+      # Like {Node#cssize}, except that this method
+      # will create its own `extends` map if necessary,
+      # and it returns that map along with the cssized tree.
+      #
+      # @return [(Tree::Node, Haml::Util::SubsetMap)] The resulting tree of static nodes
+      #   *and* the extensions defined for this tree
+      def cssize(extends = Haml::Util::SubsetMap.new, parent = nil)
+        return super(extends), extends
       rescue Sass::SyntaxError => e
         e.sass_template = @template
         raise e

data/test/haml/util_test.rb

@@ -100,6 +100,23 @@ class UtilTest < Test::Unit::TestCase
     assert_equal([[1, 2, 3]], paths([[1], [2], [3]]))
   end
 
+  def test_lcs
+    assert_equal([1, 2, 3], lcs([1, 2, 3], [1, 2, 3]))
+    assert_equal([], lcs([], [1, 2, 3]))
+    assert_equal([], lcs([1, 2, 3], []))
+    assert_equal([1, 2, 3], lcs([5, 1, 4, 2, 3, 17], [0, 0, 1, 2, 6, 3]))
+
+    assert_equal([1], lcs([1, 2, 3, 4], [4, 3, 2, 1]))
+    assert_equal([1, 2], lcs([1, 2, 3, 4], [3, 4, 1, 2]))
+  end
+
+  def test_lcs_with_block
+    assert_equal(["1", "2", "3"],
+      lcs([1, 4, 2, 5, 3], [1, 2, 3]) {|a, b| a == b && a.to_s})
+    assert_equal([-4, 2, 8],
+      lcs([-5, 3, 2, 8], [-4, 1, 8]) {|a, b| (a - b).abs <= 1 && [a, b].max})
+  end
+
   def test_silence_warnings
     old_stderr, $stderr = $stderr, StringIO.new
     warn "Out"

data/test/sass/engine_test.rb

@@ -1608,13 +1608,15 @@ foo {
   a: foo;
   b: bar;
   c: foo bar;
-  d: foo, bar; }
+  d: foo, bar baz;
+  e: foo bar, bar; }
 CSS
 foo
   a= "foo"
   b= bar
   c= "foo" bar
-  d= foo, "bar"
+  d= foo, "bar baz"
+  e= "foo bar", bar
 SASS
     end
   end

data/test/sass/extend_test.rb

@@ -974,34 +974,73 @@ foo bar {@extend .foo}
 SCSS
   end
 
-  def test_nested_extender_interleaves_parents_with_unification
+  def test_nested_extender_alternates_parents
     assert_equal <<CSS, render(<<SCSS)
-.baz .foo, .baz foo bar, foo.baz bar, foo .baz bar {
+.baz .bip .foo, .baz .bip foo .grank bar, foo .grank .baz .bip bar {
   a: b; }
 CSS
-.baz .foo {a: b}
-foo bar {@extend .foo}
+.baz .bip .foo {a: b}
+foo .grank bar {@extend .foo}
 SCSS
   end
 
-  def test_nested_extender_interleaves_parents_with_aborted_unification
+  def test_nested_extender_unifies_identical_parents
     assert_equal <<CSS, render(<<SCSS)
-baz .foo, baz foo bar, foo baz bar {
+.baz .bip .foo, .baz .bip bar {
   a: b; }
 CSS
-baz .foo {a: b}
-foo bar {@extend .foo}
+.baz .bip .foo {a: b}
+.baz .bip bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_unifies_common_substring
+    assert_equal <<CSS, render(<<SCSS)
+.baz .bip .bap .bink .foo, .baz .brat .bip .bap .bink bar, .brat .baz .bip .bap .bink bar {
+  a: b; }
+CSS
+.baz .bip .bap .bink .foo {a: b}
+.brat .bip .bap bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_unifies_common_subseq
+    assert_equal <<CSS, render(<<SCSS)
+.a .x .b .y .foo, .a .x .n .b .y .m bar, .a .n .x .b .y .m bar, .a .x .n .b .m .y bar, .a .n .x .b .m .y bar {
+  a: b; }
+CSS
+.a .x .b .y .foo {a: b}
+.a .n .b .m bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_chooses_first_subseq
+    assert_equal <<CSS, render(<<SCSS)
+.a .b .c .d .foo, .a .b .c .d .a .b .bar {
+  a: b; }
+CSS
+.a .b .c .d .foo {a: b}
+.c .d .a .b .bar {@extend .foo}
+SCSS
+  end
+
+  def test_nested_extender_counts_extended_subselectors
+    assert_equal <<CSS, render(<<SCSS)
+.a .bip.bop .foo, .a .b .bip.bop .bar, .b .a .bip.bop .bar {
+  a: b; }
+CSS
+.a .bip.bop .foo {a: b}
+.b .bip .bar {@extend .foo}
 SCSS
   end
 
-  def test_nested_extender_with_lots_of_interleaving
-    # Please, never ever do this in a real stylesheet
+  def test_nested_extender_counts_extended_superselectors
     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 .bip .foo, .a .b .bip.bop .bar, .b .a .bip.bop .bar {
   a: b; }
 CSS
-.foo .bar .baz .bang {a: b}
-.foo2 .bar2 .baz2 .bang2 {@extend .bang}
+.a .bip .foo {a: b}
+.b .bip.bop .bar {@extend .foo}
 SCSS
   end
 
@@ -1015,33 +1054,101 @@ foo > bar {@extend .foo}
 SCSS
   end
 
-  def test_nested_extender_with_descendant_and_child_selector
+  def test_nested_extender_finds_common_selectors_around_child_selector
     assert_equal <<CSS, render(<<SCSS)
-.baz .foo, .baz bang foo > bar, bang.baz foo > bar, bang .baz foo > bar {
+a > b c .c1, a > b c .c2 {
   a: b; }
 CSS
-.baz .foo {a: b}
-bang foo > bar {@extend .foo}
+a > b c .c1 {a: b}
+a c .c2 {@extend .c1}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a > b c .c1, a > b c .c2 {
+  a: b; }
+CSS
+a > b c .c1 {a: b}
+b c .c2 {@extend .c1}
 SCSS
   end
 
-  def test_nested_extender_with_child_selector_unifies
+  def test_nested_extender_doesnt_find_common_selectors_around_adjacent_sibling_selector
     assert_equal <<CSS, render(<<SCSS)
-.baz.foo, foo > bar.baz {
+a + b c .c1, a + b a c .c2, a a + b c .c2 {
   a: b; }
 CSS
-.baz.foo {a: b}
-foo > bar {@extend .foo}
+a + b c .c1 {a: b}
+a c .c2 {@extend .c1}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a + b c .c1, a a + b c .c2 {
+  a: b; }
+CSS
+a + b c .c1 {a: b}
+a b .c2 {@extend .c1}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a + b c .c1, a + b c .c2 {
+  a: b; }
+CSS
+a + b c .c1 {a: b}
+b c .c2 {@extend .c1}
 SCSS
   end
 
-  def test_nested_extender_with_child_selector_and_more
+  def test_nested_extender_doesnt_find_common_selectors_around_sibling_selector
     assert_equal <<CSS, render(<<SCSS)
-.foo .bar, .foo foo > bar baz, foo > bar.foo baz, foo > bar .foo baz {
+a ~ b c .c1, a ~ b a c .c2, a a ~ b c .c2 {
   a: b; }
 CSS
-.foo .bar {a: b}
-foo > bar baz {@extend .bar}
+a ~ b c .c1 {a: b}
+a c .c2 {@extend .c1}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a ~ b c .c1, a a ~ b c .c2 {
+  a: b; }
+CSS
+a ~ b c .c1 {a: b}
+a b .c2 {@extend .c1}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+a ~ b c .c1, a ~ b c .c2 {
+  a: b; }
+CSS
+a ~ b c .c1 {a: b}
+b c .c2 {@extend .c1}
+SCSS
+  end
+
+  def test_nested_extender_with_early_child_selectors_doesnt_subseq_them
+    assert_equal <<CSS, render(<<SCSS)
+.bip > .bap .foo, .bip > .bap .grip > .bap .bar, .grip > .bap .bip > .bap .bar {
+  a: b; }
+CSS
+.bip > .bap .foo {a: b}
+.grip > .bap .bar {@extend .foo}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS)
+.bap > .bip .foo, .bap > .bip .bap > .grip .bar, .bap > .grip .bap > .bip .bar {
+  a: b; }
+CSS
+.bap > .bip .foo {a: b}
+.bap > .grip .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
 

data/test/sass/less_conversion_test.rb

@@ -37,8 +37,8 @@ LESS
   end
 
   def test_import
-    path = File.dirname(__FILE__) + "/templates/importee.less"
-    resolved_path = File.dirname(__FILE__) + "/templates/importee"
+    path = relative_path_to(File.dirname(__FILE__) + "/templates/importee.less")
+    resolved_path = relative_path_to(File.dirname(__FILE__) + "/templates/importee")
     assert_renders <<SCSS, <<LESS
 @import "#{resolved_path}";
 @import "#{resolved_path}";
@@ -57,8 +57,8 @@ LESS
   end
 
   def test_mixins_found_through_import
-    path = File.dirname(__FILE__) + "/templates/importee.less"
-    resolved_path = File.dirname(__FILE__) + "/templates/importee"
+    path = relative_path_to(File.dirname(__FILE__) + "/templates/importee.less")
+    resolved_path = relative_path_to(File.dirname(__FILE__) + "/templates/importee")
     assert_renders <<SCSS, <<LESS
 @import "#{resolved_path}";
 
@@ -618,6 +618,13 @@ LESS
   def assert_renders(scss, less)
     assert_equal(scss, Less::Engine.new(less).to_tree.to_sass_tree.to_scss)
   end
+
+  # Necessary because Less can't import absolute files
+  def relative_path_to(file)
+    file = Pathname.new(file)
+    pwd = file.absolute? ? Dir.pwd : "."
+    file.relative_path_from(Pathname.new(pwd))
+  end
 end
 
 rescue LoadError => e

data/test/sass/scss/scss_test.rb

@@ -950,7 +950,12 @@ SCSS
   end
 
   def test_parent_in_mid_selector_error
-    assert_raise(Sass::SyntaxError, 'Invalid CSS after ".foo": expected "{", was "&.bar"') {render <<SCSS}
+    assert_raise(Sass::SyntaxError, <<MESSAGE) {render <<SCSS}
+Invalid CSS after ".foo": expected "{", was "&.bar"
+
+In Sass 3, the parent selector & can only be used where element names are valid,
+since it could potentially be replaced by an element name.
+MESSAGE
 flim {
   .foo&.bar {a: b}
 }
@@ -958,7 +963,12 @@ SCSS
   end
 
   def test_parent_in_mid_selector_error
-    assert_raise(Sass::SyntaxError, 'Invalid CSS after ".foo.bar": expected "{", was "&"') {render <<SCSS}
+    assert_raise(Sass::SyntaxError, <<MESSAGE) {render <<SCSS}
+Invalid CSS after ".foo.bar": expected "{", was "&"
+
+In Sass 3, the parent selector & can only be used where element names are valid,
+since it could potentially be replaced by an element name.
+MESSAGE
 flim {
   .foo.bar& {a: b}
 }
@@ -966,7 +976,12 @@ SCSS
   end
 
   def test_double_parent_selector_error
-    assert_raise(Sass::SyntaxError, 'Invalid CSS after "&": expected "{", was "&"') {render <<SCSS}
+    assert_raise(Sass::SyntaxError, <<MESSAGE) {render <<SCSS}
+Invalid CSS after "&": expected "{", was "&"
+
+In Sass 3, the parent selector & can only be used where element names are valid,
+since it could potentially be replaced by an element name.
+MESSAGE
 flim {
   && {a: b}
 }

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - rc
-  - 4
-  version: 3.0.0.rc.4
+  - 5
+  version: 3.0.0.rc.5
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -17,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-03 00:00:00 -07:00
+date: 2010-05-07 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency