sass 3.2.0.alpha.60 → 3.2.0.alpha.61

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

@@ -247,6 +247,8 @@ 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]
@@ -295,6 +297,7 @@ END
   end
 
   def visit_media(node)
+    node.query = node.query.deep_copy
     node.query.perform {|interp| run_interp(interp)}
     yield
   end

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

@@ -94,4 +94,14 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
     node.expr.options = @options
     yield
   end
+
+  def visit_directive(node)
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Node)}
+    yield
+  end
+
+  def visit_media(node)
+    node.query.options = @options
+    yield
+  end
 end

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

@@ -67,8 +67,10 @@ 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
@@ -101,6 +103,8 @@ 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)
@@ -133,7 +137,11 @@ 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
-        rule_part.gsub!(/\s*([^,])\s*\n\s*/m, '\1 ') if node.style == :compressed
+        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
       end.compact.join(rule_separator)
 
@@ -145,7 +153,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]
+        if node.options[:debug_info] && !@in_directive
           to_return << visit(debug_info_rule(node.debug_info, node.options)) << "\n"
         elsif node.options[:trace_selectors]
           to_return << "#{old_spaces}/* "
@@ -191,7 +199,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")
-    debug_info.map {|k, v| [k.to_s, v.to_s]}.sort.each do |k, v|
+    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).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,6 +218,20 @@ 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
@@ -561,6 +575,24 @@ 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 'test_helper'
-require 'sass/test_helper'
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/engine'
 require 'stringio'
 require 'mock_importer'
@@ -1028,6 +1028,23 @@ 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
@@ -2212,6 +2229,27 @@ SASS
 
   # Regression tests
 
+  def test_variable_in_media_in_mixin
+    assert_equal <<CSS, render(<<SASS)
+@media screen and (min-width: 10px) {
+  body {
+    background: red; } }
+@media screen and (min-width: 20px) {
+  body {
+    background: blue; } }
+CSS
+@mixin respond-to($width)
+  @media screen and (min-width: $width)
+    @content
+
+body
+  @include respond-to(10px)
+    background: red
+  @include respond-to(20px)
+    background: blue
+SASS
+  end
+
   def test_tricky_mixin_loop_exception
     render <<SASS
 @mixin foo($a)
@@ -2541,6 +2579,15 @@ 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,6 +1165,70 @@ 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
 
@@ -1186,7 +1250,7 @@ SCSS
 
   def test_nested_extender_with_hacky_selector
     assert_equal <<CSS, render(<<SCSS)
-.baz .foo, .baz foo + > > + bar {
+.baz .foo, .baz foo + > > + bar, foo .baz + > > + bar {
   a: b; }
 CSS
 .baz .foo {a: b}
@@ -1194,7 +1258,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}
@@ -1223,6 +1287,402 @@ 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
@@ -1431,6 +1891,20 @@ 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,