sass 3.2.0.alpha.61 → 3.2.0.alpha.62

data/REVISION

@@ -1 +1 @@
-f03f995506891014aea1df1a16672298469b3966
+b646179a5713cbb2f2156c254e0add381c1d1824

data/VERSION

@@ -1 +1 @@
-3.2.0.alpha.61
+3.2.0.alpha.62

data/lib/sass/cache_stores/filesystem.rb

@@ -53,7 +53,6 @@ module Sass
       # @param key [String]
       # @return [String] The path to the cache file.
       def path_to(key)
-        key = key.gsub(/[<>:\\|?*%]/) {|c| "%%%03d" % Sass::Util.ord(c)}
         File.join(cache_location, key)
       end
     end

data/lib/sass/engine.rb

@@ -224,7 +224,7 @@ module Sass
     # If you're compiling a single Sass file from the filesystem,
     # use \{Sass::Engine.for\_file}.
     # If you're compiling multiple files from the filesystem,
-    # use {Sass::Plugin}.
+    # use {Sass::Plugin.
     #
     # @param template [String] The Sass template.
     #   This template can be encoded using any encoding

data/lib/sass/script/funcall.rb

@@ -36,7 +36,7 @@ module Sass
       # @return [String] A string representation of the function call
       def inspect
         args = @args.map {|a| a.inspect}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
+        keywords = @keywords.sort_by {|k, v| k}.
             map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
         "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end
@@ -44,7 +44,7 @@ module Sass
       # @see Node#to_sass
       def to_sass(opts = {})
         args = @args.map {|a| a.to_sass(opts)}.join(', ')
-        keywords = Sass::Util.hash_to_a(@keywords).
+        keywords = @keywords.sort_by {|k, v| k}.
           map {|k, v| "$#{dasherize(k, opts)}: #{v.to_sass(opts)}"}.join(', ')
         "#{dasherize(name, opts)}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
       end

data/lib/sass/script/literal.rb

@@ -55,6 +55,26 @@ The #options attribute is not set on this #{self.class}.
 MSG
     end
 
+    # The SassScript `and` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of a logical and:
+    #   `other` if this literal isn't a false {Bool},
+    #   and this literal otherwise
+    def and(other)
+      to_bool ? other : self
+    end
+
+    # The SassScript `or` operation.
+    #
+    # @param other [Literal] The right-hand side of the operator
+    # @return [Literal] The result of the logical or:
+    #   this literal if it isn't a false {Bool},
+    #   and `other` otherwise
+    def or(other)
+      to_bool ? self : other
+    end
+
     # The SassScript `==` operation.
     # **Note that this returns a {Sass::Script::Bool} object,
     # not a Ruby boolean**.

data/lib/sass/script/operation.rb

@@ -72,14 +72,6 @@ module Sass::Script
     # @raise [Sass::SyntaxError] if the operation is undefined for the operands
     def _perform(environment)
       literal1 = @operand1.perform(environment)
-
-      # Special-case :and and :or to support short-circuiting.
-      if @operator == :and
-        return literal1.to_bool ? @operand2.perform(environment) : literal1
-      elsif @operator == :or
-        return literal1.to_bool ? literal1 : @operand2.perform(environment)
-      end
-
       literal2 = @operand2.perform(environment)
 
       begin

data/lib/sass/selector.rb

@@ -379,7 +379,7 @@ module Sass
       attr_reader :selector
 
       # @param [String] The name of the pseudoclass
-      # @param [Selector::CommaSequence] The selector argument
+      # @param [Selector::Sequence] The selector argument
       def initialize(name, selector)
         @name = name
         @selector = selector

data/lib/sass/selector/sequence.rb

@@ -124,15 +124,15 @@ module Sass
       # @param path [Array<Array<SimpleSequence or String>>] A list of parenthesized selector groups.
       # @return [Array<Array<SimpleSequence or String>>] A list of fully-expanded selectors.
       def weave(path)
-        # This function works by moving through the selector path left-to-right,
-        # building all possible prefixes simultaneously. These prefixes are
-        # `befores`, while the remaining parenthesized suffixes is `afters`.
         befores = [[]]
         afters = path.dup
 
         until afters.empty?
           current = afters.shift.dup
           last_current = [current.pop]
+          while !current.empty? && last_current.first.is_a?(String) || current.last.is_a?(String)
+            last_current.unshift(current.pop)
+          end
           befores = Sass::Util.flatten(befores.map do |before|
               next [] unless sub = subweave(before, current)
               sub.map {|seqs| seqs + last_current}
@@ -150,12 +150,6 @@ module Sass
       # `.foo .baz .bar .bang`, `.foo .baz .bar.bang`, `.foo .baz .bang .bar`,
       # and so on until `.baz .bang .foo .bar`.
       #
-      # Semantically, for selectors A and B, this returns all selectors `AB_i`
-      # such that the union over all i of elements matched by `AB_i X` is
-      # identical to the intersection of all elements matched by `A X` and all
-      # elements matched by `B X`. Some `AB_i` are elided to reduce the size of
-      # the output.
-      #
       # @param seq1 [Array<SimpleSequence or String>]
       # @param seq2 [Array<SimpleSequence or String>]
       # @return [Array<Array<SimpleSequence or String>>]
@@ -163,34 +157,31 @@ module Sass
         return [seq2] if seq1.empty?
         return [seq1] if seq2.empty?
 
-        seq1, seq2 = seq1.dup, seq2.dup
         return unless init = merge_initial_ops(seq1, seq2)
-        return unless fin = merge_final_ops(seq1, seq2)
         seq1 = group_selectors(seq1)
         seq2 = group_selectors(seq2)
         lcs = Sass::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 superselector?(s1, s2)
-          next s1 if superselector?(s2, s1)
+          next s2 if subweave_superselector?(s1, s2)
+          next s1 if subweave_superselector?(s2, s1)
         end
 
         diff = [[init]]
         until lcs.empty?
-          diff << chunks(seq1, seq2) {|s| superselector?(s.first, lcs.first)} << [lcs.shift]
+          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 += fin.map {|sel| sel.is_a?(Array) ? sel : [sel]}
         diff.reject! {|c| c.empty?}
 
         Sass::Util.paths(diff).map {|p| p.flatten}
       end
 
-      # Extracts initial selector combinators (`"+"`, `">"`, `"~"`, and `"\n"`)
+      # Extracts initial selector operators (`"+"`, `">"`, `"~"`, and `"\n"`)
       # from two sequences and merges them together into a single array of
-      # selector combinators.
+      # selector operators.
       #
       # @param seq1 [Array<SimpleSequence or String>]
       # @param seq2 [Array<SimpleSequence or String>]
@@ -213,100 +204,6 @@ module Sass
         return (newline ? ["\n"] : []) + (ops1.size > ops2.size ? ops1 : ops2)
       end
 
-      # Extracts final selector combinators (`"+"`, `">"`, `"~"`) and the
-      # selectors to which they apply from two sequences and merges them
-      # together into a single array.
-      #
-      # @param seq1 [Array<SimpleSequence or String>]
-      # @param seq2 [Array<SimpleSequence or String>]
-      # @return [Array<SimpleSequence or String or
-      #     Array<Array<SimpleSequence or String>>]
-      #   If there are no trailing combinators to be merged, this will be the
-      #   empty array. If the trailing combinators cannot be merged, this will
-      #   be nil. Otherwise, this will contained the merged selector. Array
-      #   elements are [Sass::Util#paths]-style options; conceptually, an "or"
-      #   of multiple selectors.
-      def merge_final_ops(seq1, seq2, res = [])
-        ops1, ops2 = [], []
-        ops1 << seq1.pop while seq1.last.is_a?(String)
-        ops2 << seq2.pop while seq2.last.is_a?(String)
-
-        # Not worth the headache of trying to preserve newlines here. The most
-        # important use of newlines is at the beginning of the selector to wrap
-        # across lines anyway.
-        ops1.reject! {|o| o == "\n"}
-        ops2.reject! {|o| o == "\n"}
-
-        return res if ops1.empty? && ops2.empty?
-        if ops1.size > 1 || ops2.size > 1
-          # If there are multiple operators, something hacky's going on. If one
-          # is a supersequence of the other, use that, otherwise give up.
-          lcs = Sass::Util.lcs(ops1, ops2)
-          return unless lcs == ops1 || lcs == ops2
-          res.unshift *(ops1.size > ops2.size ? ops1 : ops2).reverse
-          return res
-        end
-
-        # This code looks complicated, but it's actually just a bunch of special
-        # cases for interactions between different combinators.
-        op1, op2 = ops1.first, ops2.first
-        if op1 && op2
-          sel1 = seq1.pop
-          sel2 = seq2.pop
-          if op1 == '~' && op2 == '~'
-            if superselector?([sel1], [sel2])
-              res.unshift sel2, '~'
-            elsif superselector?([sel2], [sel1])
-              res.unshift sel1, '~'
-            else
-              merged = sel1.unify(sel2.members)
-              res.unshift [
-                [sel1, '~', sel2, '~'],
-                [sel2, '~', sel1, '~'],
-                ([merged, '~'] if merged)
-              ].compact
-            end
-          elsif (op1 == '~' && op2 == '+') || (op1 == '+' && op2 == '~')
-            if op1 == '~'
-              tilde_sel, plus_sel = sel1, sel2
-            else
-              tilde_sel, plus_sel = sel2, sel1
-            end
-
-            if superselector?([tilde_sel], [plus_sel])
-              res.unshift plus_sel, '+'
-            else
-              merged = plus_sel.unify(tilde_sel.members)
-              res.unshift [
-                [tilde_sel, '~', plus_sel, '+'],
-                ([merged, '+'] if merged)
-              ].compact
-            end
-          elsif op1 == '>' && %w[~ +].include?(op2)
-            res.unshift sel2, op2
-            seq1.push sel1, op1
-          elsif op2 == '>' && %w[~ +].include?(op1)
-            res.unshift sel1, op1
-            seq2.push sel2, op2
-          elsif op1 == op2
-            return unless merged = sel1.unify(sel2.members)
-            res.unshift merged, op1
-          else
-            # Unknown selector combinators can't be unified
-            return
-          end
-          return merge_final_ops(seq1, seq2, res)
-        elsif op1
-          seq2.pop if op1 == '>' && seq2.last && superselector?([seq2.last], [seq1.last])
-          res.unshift seq1.pop, op1
-          return merge_final_ops(seq1, seq2, res)
-        else # op2
-          seq1.pop if op2 == '>' && seq1.last && superselector?([seq1.last], [seq2.last])
-          res.unshift seq2.pop, op2
-          return merge_final_ops(seq1, seq2, res)
-        end
-      end
-
       # Takes initial subsequences of `seq1` and `seq2` and returns all
       # orderings of those subsequences. The initial subsequences are determined
       # by a block.
@@ -326,7 +223,6 @@ module Sass
       #   cutting off some initial subsequence.
       # @yieldreturn [Boolean] Whether or not to cut off the initial subsequence
       #   here.
-      # @return [Array<Array>] All possible orderings of the initial subsequences.
       def chunks(seq1, seq2)
         chunk1 = []
         chunk1 << seq1.shift until yield seq1
@@ -361,33 +257,25 @@ module Sass
       end
 
       # Given two sequences of simple selectors, returns whether `sseq1` is a
-      # superselector of `sseq2`; that is, whether `sseq1` matches every element
-      # `sseq2` matches.
-      #
-      # Both `sseq1` and `sseq2` are of the form
-      # `SimpleSelector (String SimpleSelector)* String*`, although selectors
-      # with a trailing operator are considered to be neither superselectors nor
-      # subselectors.
+      # superselector of `sseq2`.
       #
-      # @param sseq1 [Array<SimpleSequence or String>]
-      # @param sseq2 [Array<SimpleSequence or String>]
+      # @param sseq1 [Array<SimpleSelector or String>]
+      # @param sseq2 [Array<SimpleSelector or String>]
       # @return [Boolean]
-      def superselector?(sseq1, sseq2)
-        sseq1 = sseq1.reject {|e| e == "\n"}
-        sseq2 = sseq2.reject {|e| e == "\n"}
-        # Selectors with trailing operators are neither superselectors nor
-        # subselectors.
-        return if sseq1.last.is_a?(String) || sseq2.last.is_a?(String)
+      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 superselector?(sseq1[2..-1], sseq2[2..-1])
+          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 superselector?(sseq1, sseq2[2..-1])
+          return false if sseq2.size == 2
+          return subweave_superselector?(sseq1, sseq2[2..-1])
         else
           sseq1.first.superselector?(sseq2.first)
         end

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

@@ -168,8 +168,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   def visit_mixin(node)
     unless node.args.empty? && node.keywords.empty?
       args = node.args.map {|a| a.to_sass(@options)}.join(", ")
-      keywords = Sass::Util.hash_to_a(node.keywords).
-        map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
+      keywords = node.keywords.map {|k, v| "$#{dasherize(k)}: #{v.to_sass(@options)}"}.join(', ')
       arglist = "(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords})"
     end
     "#{tab_str}#{@format == :sass ? '+' : '@include '}#{dasherize(node.name)}#{arglist}#{node.has_children ? yield : semi}\n"

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

@@ -52,27 +52,12 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
   def visit_root(node)
     yield
 
-    if parent.nil?
-      # In Ruby 1.9 we can make all @charset nodes invisible
-      # and infer the final @charset from the encoding of the final string.
-      if Sass::Util.ruby1_8?
-        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.unshift charset if charset
-      end
-
-      imports = Sass::Util.extract!(node.children) do |c|
-        c.is_a?(Sass::Tree::DirectiveNode) && !c.is_a?(Sass::Tree::MediaNode) &&
-          c.resolved_value =~ /^@import /i
-      end
-      charset_and_index = Sass::Util.ruby1_8? &&
-        node.children.each_with_index.find {|c, _| c.is_a?(Sass::Tree::CharsetNode)}
-      if charset_and_index
-        index = charset_and_index.last
-        node.children = node.children[0..index] + imports + node.children[index+1..-1]
-      else
-        node.children = imports + node.children
-      end
+    # In Ruby 1.9 we can make all @charset nodes invisible
+    # and infer the final @charset from the encoding of the final string.
+    if Sass::Util.ruby1_8? && parent.nil?
+      charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
+      node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
+      node.children.unshift charset if charset
     end
 
     return node, @extends

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

@@ -247,8 +247,6 @@ END
   # Runs SassScript interpolation in the selector,
   # and then parses the result into a {Sass::Selector::CommaSequence}.
   def visit_rule(node)
-    rule = node.rule
-    rule = rule.map {|e| e.is_a?(String) && e != ' ' ? e.strip : e} if node.style == :compressed
     parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
     node.parsed_rules ||= parser.parse_selector
     if node.options[:trace_selectors]

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

@@ -67,10 +67,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   end
 
   def visit_directive(node)
-    was_in_directive = @in_directive
     return node.resolved_value + ";" unless node.has_children
     return node.resolved_value + " {}" if node.children.empty?
-    @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
     result = if node.style == :compressed
                "#{node.resolved_value}{"
              else
@@ -103,8 +101,6 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
                     else
                       (node.style == :expanded ? "\n" : " ") + "}\n"
                     end
-  ensure
-    @in_directive = was_in_directive
   end
 
   def visit_media(node)
@@ -137,11 +133,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       joined_rules = node.resolved_rules.members.map do |seq|
         next if seq.has_placeholder?
         rule_part = seq.to_a.join
-        if node.style == :compressed
-          rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
-          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
-          rule_part.strip!
-        end
+        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
         rule_part
       end.compact.join(rule_separator)
 
@@ -153,7 +145,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       old_spaces = '  ' * @tabs
       spaces = '  ' * (@tabs + 1)
       if node.style != :compressed
-        if node.options[:debug_info] && !@in_directive
+        if node.options[:debug_info]
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
         elsif node.options[:trace_selectors]
           to_return << "#{old_spaces}/* "
@@ -199,7 +191,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.resolved("@media -sass-debug-info")
-    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(

data/lib/sass/util.rb

@@ -218,20 +218,6 @@ module Sass
       lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
     end
 
-    # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
-    # with the following exceptions:
-    #
-    # * In Ruby 1.8, `Hash#to_a` is not deterministically ordered, but this is.
-    # * In Ruby 1.9 when running tests, this is ordered in the same way it would
-    #   be under Ruby 1.8 (sorted key order rather than insertion order).
-    #
-    # @param hash [Hash]
-    # @return [Array]
-    def hash_to_a(hash)
-      return has.to_a unless ruby1_8? || defined?(Test::Unit)
-      return hash.sort_by {|k, v| k}
-    end
-
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -575,24 +561,6 @@ MSG
       ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
     end
 
-    # Destructively removes all elements from an array that match a block, and
-    # returns the removed elements.
-    #
-    # @param array [Array] The array from which to remove elements.
-    # @yield [el] Called for each element.
-    # @yieldparam el [*] The element to test.
-    # @yieldreturn [Boolean] Whether or not to extract the element.
-    # @return [Array] The extracted elements.
-    def extract!(array)
-      out = []
-      array.reject! do |e|
-        next false unless yield e
-        out << e
-        true
-      end
-      out
-    end
-
     # Returns the ASCII code of the given character.
     #
     # @param c [String] All characters but the first are ignored.

data/test/sass/engine_test.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
-require File.dirname(__FILE__) + '/../test_helper'
-require File.dirname(__FILE__) + '/test_helper'
+require 'test_helper'
+require 'sass/test_helper'
 require 'sass/engine'
 require 'stringio'
 require 'mock_importer'
@@ -1028,23 +1028,6 @@ foo
 SASS
   end
 
-  def test_debug_info_in_keyframes
-    assert_equal(<<CSS, render(<<SASS, :debug_info => true))
-@-webkit-keyframes warm {
-  from {
-    color: black; }
-
-  to {
-    color: red; } }
-CSS
-@-webkit-keyframes warm
-  from
-    color: black
-  to
-    color: red
-SASS
-  end
-
   def test_empty_first_line
     assert_equal("#a {\n  b: c; }\n", render("#a\n\n  b: c"))
   end
@@ -2579,15 +2562,6 @@ CSS
 SASS
   end
 
-  def test_selector_compression
-    assert_equal <<CSS, render(<<SASS, :style => :compressed)
-a>b,c+d,:-moz-any(e,f,g){h:i}
-CSS
-a > b, c + d, :-moz-any(e, f, g)
-  h: i
-SASS
-  end
-
   # Encodings
 
   unless Sass::Util.ruby1_8?

data/test/sass/extend_test.rb

@@ -1165,70 +1165,6 @@ SCSS
 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
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo .bar, .foo > .baz {
-  a: b; }
-CSS
-.foo {
-  .bar {a: b}
-  > .baz {@extend .bar}
-}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo .bar, .foo .bip > .baz {
-  a: b; }
-CSS
-.foo {
-  .bar {a: b}
-  .bip > .baz {@extend .bar}
-}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo .bip .bar, .foo .bip .foo > .baz {
-  a: b; }
-CSS
-.foo {
-  .bip .bar {a: b}
-  > .baz {@extend .bar}
-}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo > .bar, .foo > .bip + .baz {
-  a: b; }
-CSS
-.foo > .bar {a: b}
-.bip + .baz {@extend .bar}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo + .bar, .bip > .foo + .baz {
-  a: b; }
-CSS
-.foo + .bar {a: b}
-.bip > .baz {@extend .bar}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.foo > .bar, .bip.foo > .baz {
-  a: b; }
-CSS
-.foo > .bar {a: b}
-.bip > .baz {@extend .bar}
 SCSS
   end
 
@@ -1250,7 +1186,7 @@ SCSS
 
   def test_nested_extender_with_hacky_selector
     assert_equal <<CSS, render(<<SCSS)
-.baz .foo, .baz foo + > > + bar, foo .baz + > > + bar {
+.baz .foo, .baz foo + > > + bar {
   a: b; }
 CSS
 .baz .foo {a: b}
@@ -1258,7 +1194,7 @@ foo + > > + bar {@extend .foo}
 SCSS
 
     assert_equal <<CSS, render(<<SCSS)
-.baz .foo, > > .baz bar {
+.baz .foo, .baz > > bar {
   a: b; }
 CSS
 .baz .foo {a: b}
@@ -1287,402 +1223,6 @@ CSS
 SCSS
   end
 
-  # Combinator Unification
-
-  def test_combinator_unification_for_hacky_combinators
-    assert_equal <<CSS, render(<<SCSS)
-.a > + x, .a .b > + y, .b .a > + y {
-  a: b; }
-CSS
-.a > + x {a: b}
-.b y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a x, .a .b > + y, .b .a > + y {
-  a: b; }
-CSS
-.a x {a: b}
-.b > + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > + x, .a .b > + y, .b .a > + y {
-  a: b; }
-CSS
-.a > + x {a: b}
-.b > + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ > + x, .a .b ~ > + y, .b .a ~ > + y {
-  a: b; }
-CSS
-.a ~ > + x {a: b}
-.b > + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + > x {
-  a: b; }
-CSS
-.a + > x {a: b}
-.b > + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + > x {
-  a: b; }
-CSS
-.a + > x {a: b}
-.b > + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ > + .b > x, .a .c ~ > + .d.b > y, .c .a ~ > + .d.b > y {
-  a: b; }
-CSS
-.a ~ > + .b > x {a: b}
-.c > + .d > y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_double_tilde
-    assert_equal <<CSS, render(<<SCSS)
-.a.b ~ x, .a.b ~ y {
-  a: b; }
-CSS
-.a.b ~ x {a: b}
-.a ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ x, .a.b ~ y {
-  a: b; }
-CSS
-.a ~ x {a: b}
-.a.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ x, .a ~ .b ~ y, .b ~ .a ~ y, .b.a ~ y {
-  a: b; }
-CSS
-.a ~ x {a: b}
-.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.a ~ x, a.a ~ b.b ~ y, b.b ~ a.a ~ y {
-  a: b; }
-CSS
-a.a ~ x {a: b}
-b.b ~ y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_tilde_plus
-    assert_equal <<CSS, render(<<SCSS)
-.a.b + x, .a.b + y {
-  a: b; }
-CSS
-.a.b + x {a: b}
-.a ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .a.b ~ .a + y, .a.b + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.a.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .b ~ .a + y, .b.a + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.a + x, b.b ~ a.a + y {
-  a: b; }
-CSS
-a.a + x {a: b}
-b.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a.b ~ x, .a.b ~ .a + y, .a.b + y {
-  a: b; }
-CSS
-.a.b ~ x {a: b}
-.a + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ x, .a.b + y {
-  a: b; }
-CSS
-.a ~ x {a: b}
-.a.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ x, .a ~ .b + y, .a.b + y {
-  a: b; }
-CSS
-.a ~ x {a: b}
-.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.a ~ x, a.a ~ b.b + y {
-  a: b; }
-CSS
-a.a ~ x {a: b}
-b.b + y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_angle_sibling
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .a > .b ~ y {
-  a: b; }
-CSS
-.a > x {a: b}
-.b ~ y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .a > .b + y {
-  a: b; }
-CSS
-.a > x {a: b}
-.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a ~ x, .b > .a ~ y {
-  a: b; }
-CSS
-.a ~ x {a: b}
-.b > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .b > .a + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.b > y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_double_angle
-    assert_equal <<CSS, render(<<SCSS)
-.a.b > x, .b.a > y {
-  a: b; }
-CSS
-.a.b > x {a: b}
-.b > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .a.b > y {
-  a: b; }
-CSS
-.a > x {a: b}
-.a.b > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .b.a > y {
-  a: b; }
-CSS
-.a > x {a: b}
-.b > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.a > x {
-  a: b; }
-CSS
-a.a > x {a: b}
-b.b > y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_double_plus
-    assert_equal <<CSS, render(<<SCSS)
-.a.b + x, .b.a + y {
-  a: b; }
-CSS
-.a.b + x {a: b}
-.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .a.b + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.a.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .b.a + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-a.a + x {
-  a: b; }
-CSS
-a.a + x {a: b}
-b.b + y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_angle_space
-    assert_equal <<CSS, render(<<SCSS)
-.a.b > x, .a.b > y {
-  a: b; }
-CSS
-.a.b > x {a: b}
-.a y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .a.b .a > y {
-  a: b; }
-CSS
-.a > x {a: b}
-.a.b y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > x, .b .a > y {
-  a: b; }
-CSS
-.a > x {a: b}
-.b y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a.b x, .a.b .a > y {
-  a: b; }
-CSS
-.a.b x {a: b}
-.a > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a x, .a.b > y {
-  a: b; }
-CSS
-.a x {a: b}
-.a.b > y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a x, .a .b > y {
-  a: b; }
-CSS
-.a x {a: b}
-.b > y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_plus_space
-    assert_equal <<CSS, render(<<SCSS)
-.a.b + x, .a .a.b + y {
-  a: b; }
-CSS
-.a.b + x {a: b}
-.a y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .a.b .a + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.a.b y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a + x, .b .a + y {
-  a: b; }
-CSS
-.a + x {a: b}
-.b y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a.b x, .a.b .a + y {
-  a: b; }
-CSS
-.a.b x {a: b}
-.a + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a x, .a .a.b + y {
-  a: b; }
-CSS
-.a x {a: b}
-.a.b + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a x, .a .b + y {
-  a: b; }
-CSS
-.a x {a: b}
-.b + y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_nested
-    assert_equal <<CSS, render(<<SCSS)
-.a > .b + x, .c.a > .d.b + y {
-  a: b; }
-CSS
-.a > .b + x {a: b}
-.c > .d + y {@extend x}
-SCSS
-
-    assert_equal <<CSS, render(<<SCSS)
-.a > .b + x, .c.a > .b + y {
-  a: b; }
-CSS
-.a > .b + x {a: b}
-.c > y {@extend x}
-SCSS
-  end
-
-  def test_combinator_unification_with_newlines
-    assert_equal <<CSS, render(<<SCSS)
-.a >
-.b
-+ x, .c.a > .d.b + y {
-  a: b; }
-CSS
-.a >
-.b
-+ x {a: b}
-.c
-> .d +
-y {@extend x}
-SCSS
-  end
-
   # Loops
 
   def test_extend_self_loop
@@ -1891,20 +1431,6 @@ SCSS
 
   # Regression Tests
 
-  def test_newline_near_combinator
-    assert_equal <<CSS, render(<<SCSS)
-.a +
-.b x, .a +
-.b .c y, .c .a +
-.b y {
-  a: b; }
-CSS
-.a +
-.b x {a: b}
-.c y {@extend x}
-SCSS
-  end
-
   def test_duplicated_selector_with_newlines
     assert_equal(<<CSS, render(<<SCSS))
 .example-1-1,

data/test/sass/more_results/more_import.css

@@ -1,5 +1,3 @@
-@import url(basic.css);
-@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -24,6 +22,8 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
+@import url(basic.css);
+@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/results/import.css

@@ -1,5 +1,3 @@
-@import url(basic.css);
-@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -26,6 +24,8 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
+@import url(basic.css);
+@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/results/import_charset.css

@@ -1,5 +1,4 @@
 @charset "UTF-8";
-@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: щ; }

data/test/sass/results/import_charset_1_8.css

@@ -1,5 +1,4 @@
 @charset "IBM866";
-@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: �; }

data/test/sass/results/import_charset_ibm866.css

@@ -1,5 +1,4 @@
 @charset "IBM866";
-@import url(foo.css);
 .foo { a: b; }
 
 .bar { a: �; }

data/test/sass/results/scss_import.css

@@ -1,5 +1,3 @@
-@import url(basic.css);
-@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -26,6 +24,8 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
+@import url(basic.css);
+@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/script_test.rb

@@ -432,11 +432,6 @@ SASS
     assert_raise_message(Sass::SyntaxError, "wrong number of arguments (1 for 0) for `arg-error'") {resolve("arg-error(1)")}
   end
 
-  def test_boolean_ops_short_circuit
-    assert_equal "false", resolve("$ie and $ie <= 7", {}, env('ie' => Sass::Script::Bool.new(false)))
-    assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Bool.new(true)))
-  end
-
   # Regression Tests
 
   def test_funcall_has_higher_precedence_than_color_name

data/test/sass/scss/scss_test.rb

@@ -1245,11 +1245,11 @@ SCSS
 
 
   def test_newlines_removed_from_selectors_when_compressed
-    assert_equal <<CSS, render(<<SCSS, :style => :compressed)
+    assert_equal <<CSS, render(<<SCSS, :style=>:compressed)
 z a,z b{display:block}
 CSS
-a
-, b {
+a,
+b {
   z & {
     display: block;
   }

data/test/sass/templates/import_charset.sass

@@ -1,8 +1,6 @@
 .foo
   a: b
 
-@import "foo.css"
-
 // Even though the imported file is in IBM866,
 // since the root file is in UTF-8/ASCII
 // the output will end up being UTF-8.

data/test/sass/templates/import_charset_1_8.sass

@@ -1,6 +1,4 @@
 .foo
   a: b
 
-@import "foo.css"
-
 @import "imported_charset_ibm866"

data/test/sass/templates/import_charset_ibm866.sass

@@ -3,8 +3,6 @@
 .foo
   a: b
 
-@import "foo.css"
-
 // Even though the imported file is in UTF-8,
 // since the root file is in IBM866
 // the output will end up being IBM866.

data/test/sass/util_test.rb

@@ -159,12 +159,6 @@ class UtilTest < Test::Unit::TestCase
       enum_cons(%w[foo bar baz], 2).map {|s1, s2| "#{s1}#{s2}"})
   end
 
-  def test_extract
-    arr = [1, 2, 3, 4, 5]
-    assert_equal([1, 3, 5], extract!(arr) {|e| e % 2 == 1})
-    assert_equal([2, 4], arr)
-  end
-
   def test_ord
     assert_equal(102, ord("f"))
     assert_equal(98, ord("bar"))

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: sass
 version: !ruby/object:Gem::Version 
-  hash: 592302951
+  hash: 592302945
   prerelease: 6
   segments: 
   - 3
   - 2
   - 0
   - alpha
-  - 61
-  version: 3.2.0.alpha.61
+  - 62
+  version: 3.2.0.alpha.62
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -19,7 +19,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-02-03 00:00:00 -05:00
+date: 2012-01-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -86,7 +86,7 @@ files:
 - lib/sass/logger.rb
 - lib/sass/logger/base.rb
 - lib/sass/logger/log_level.rb
-- lib/sass/util.rb
+- lib/sass/media.rb
 - lib/sass/plugin.rb
 - lib/sass/plugin/compiler.rb
 - lib/sass/plugin/configuration.rb
@@ -163,7 +163,7 @@ files:
 - lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
 - lib/sass/tree/trace_node.rb
-- lib/sass/media.rb
+- lib/sass/util.rb
 - lib/sass/util/multibyte_string_scanner.rb
 - lib/sass/util/subset_map.rb
 - lib/sass/version.rb
@@ -239,7 +239,7 @@ files:
 - test/sass/results/import_charset.css
 - test/sass/results/import_charset_1_8.css
 - test/sass/results/import_charset_ibm866.css
-- test/sass/results/scss_import.css
+- test/sass/results/import_content.css
 - test/sass/results/line_numbers.css
 - test/sass/results/mixins.css
 - test/sass/results/multiline.css
@@ -247,13 +247,13 @@ files:
 - test/sass/results/options.css
 - test/sass/results/parent_ref.css
 - test/sass/results/script.css
+- test/sass/results/scss_import.css
 - test/sass/results/scss_importee.css
 - test/sass/results/subdir/nested_subdir/nested_subdir.css
 - test/sass/results/subdir/subdir.css
 - test/sass/results/units.css
 - test/sass/results/warn.css
 - test/sass/results/warn_imported.css
-- test/sass/results/import_content.css
 - test/sass/script_conversion_test.rb
 - test/sass/script_test.rb
 - test/sass/scss/css_test.rb
@@ -262,7 +262,7 @@ files:
 - test/sass/scss/test_helper.rb
 - test/sass/templates/_imported_charset_ibm866.sass
 - test/sass/templates/_imported_charset_utf8.sass
-- test/sass/templates/import_charset.sass
+- test/sass/templates/_imported_content.sass
 - test/sass/templates/_partial.sass
 - test/sass/templates/alt.sass
 - test/sass/templates/basic.sass
@@ -277,9 +277,10 @@ files:
 - test/sass/templates/expanded.sass
 - test/sass/templates/if.sass
 - test/sass/templates/import.sass
+- test/sass/templates/import_charset.sass
 - test/sass/templates/import_charset_1_8.sass
 - test/sass/templates/import_charset_ibm866.sass
-- test/sass/templates/_imported_content.sass
+- test/sass/templates/import_content.sass
 - test/sass/templates/importee.less
 - test/sass/templates/importee.sass
 - test/sass/templates/line_numbers.sass
@@ -305,7 +306,6 @@ files:
 - test/sass/templates/units.sass
 - test/sass/templates/warn.sass
 - test/sass/templates/warn_imported.sass
-- test/sass/templates/import_content.sass
 - test/sass/test_helper.rb
 - test/sass/util/multibyte_string_scanner_test.rb
 - test/sass/util/subset_map_test.rb