sass 3.4.25 → 3.5.0.pre.rc.1

data/test/sass/css2sass_test.rb

@@ -14,7 +14,7 @@ CSS
 h1
   color: red
 SASS
-    silence_warnings {assert_equal(<<SASS, css2sass(css, :old => true))}
+    assert_equal(<<SASS, css2sass(css, :old => true))
 h1
   :color red
 SASS
@@ -498,24 +498,22 @@ CSS
 
   # Encodings
 
-  unless Sass::Util.ruby1_8?
-    def test_encoding_error
-      css2sass("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
-      assert(false, "Expected exception")
-    rescue Sass::SyntaxError => e
-      assert_equal(3, e.sass_line)
-      assert_equal('Invalid UTF-8 character "\xFE"', e.message)
-    end
-
-    def test_ascii_incompatible_encoding_error
-      template = "foo\nbar\nb_z".encode("utf-16le")
-      template[9] = "\xFE".force_encoding("utf-16le")
-      css2sass(template)
-      assert(false, "Expected exception")
-    rescue Sass::SyntaxError => e
-      assert_equal(3, e.sass_line)
-      assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
-    end
+  def test_encoding_error
+    css2sass("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => e
+    assert_equal(3, e.sass_line)
+    assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+  end
+
+  def test_ascii_incompatible_encoding_error
+    template = "foo\nbar\nb_z".encode("utf-16le")
+    template[9] = "\xFE".force_encoding("utf-16le")
+    css2sass(template)
+    assert(false, "Expected exception")
+  rescue Sass::SyntaxError => e
+    assert_equal(3, e.sass_line)
+    assert_equal('Invalid UTF-16LE character "\xFE"', e.message)
   end
 
   private

data/test/sass/css_variable_test.rb

@@ -3,103 +3,209 @@
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/engine'
 
+# Most CSS variable tests are in sass-spec, but a few relate to formatting or
+# conversion and so belong here.
 class CssVariableTest < MiniTest::Test
-  def test_variable_warning_for_operators
-    resolve_with_variable_warning("1 == 2")
-    resolve_with_variable_warning("1 != 2")
-    resolve_with_variable_warning("1 < 2")
-    resolve_with_variable_warning("1 <= 2")
-    resolve_with_variable_warning("1 > 2")
-    resolve_with_variable_warning("1 >= 2")
-    resolve_with_variable_warning("1 + 1")
-    resolve_with_variable_warning("1 - 1")
-    resolve_with_variable_warning("1 * 1")
-    resolve_with_variable_warning("1 % 1")
+  def test_folded_inline_whitespace
+    assert_variable_value "foo bar baz", "foo    bar        baz"
+    assert_variable_value "foo bar", "foo \t   bar"
   end
 
-  def test_variable_warning_for_variable
-    render_with_variable_warning(<<SCSS, "$var", 3)
+  def test_folded_multiline_whitespace
+    # We don't want to reformat newlines in nested and expanded mode, so we just
+    # remove trailing whitespace before them.
+    assert_equal <<CSS, render(<<SCSS)
 .foo {
-  $var: value;
-  --var: $var;
+  --multiline: foo
+    bar; }
+CSS
+.foo {
+  --multiline: foo\s
+    bar;
 }
 SCSS
-  end
 
-  def test_variable_warning_for_core_function
-    resolve_with_variable_warning("alpha(#abc)")
-  end
+    assert_equal <<CSS, render(<<SCSS)
+.foo {
+  --multiline: foo
+
 
-  def test_variable_warning_for_sass_function
-    render_with_variable_warning(<<SCSS, "my-fn()", 2)
-@function my-fn() {@return null}
-.foo {--var: my-fn()}
+    bar; }
+CSS
+.foo {
+  --multiline: foo\s
+
+
+    bar;
+}
 SCSS
-  end
 
-  def test_variable_warning_for_parens
-    resolve_with_variable_warning("(foo)", "foo")
-    resolve_with_variable_warning("(foo,)")
-  end
+    assert_equal <<CSS, render(<<SCSS, style: :expanded)
+.foo {
+  --multiline: foo
+    bar;
+}
+CSS
+.foo {
+  --multiline: foo\s
+    bar;
+}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS, style: :expanded)
+.foo {
+  --multiline: foo
+
 
-  def test_variable_warning_for_selector
-    resolve_with_variable_warning("&")
+    bar;
+}
+CSS
+.foo {
+  --multiline: foo\s
+
+
+    bar;
+}
+SCSS
+
+    # In compact and compressed mode, we fold all whitespace around newlines
+    # together.
+    assert_equal <<CSS, render(<<SCSS, style: :compact)
+.foo { --multiline: foo bar; }
+CSS
+.foo {
+  --multiline: foo\s
+    bar;
+}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS, style: :compact)
+.foo { --multiline: foo bar; }
+CSS
+.foo {
+  --multiline: foo\s
+
+
+    bar;
+}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS, style: :compressed)
+.foo{--multiline: foo bar}
+CSS
+.foo {
+  --multiline: foo\s
+    bar;
+}
+SCSS
+
+    assert_equal <<CSS, render(<<SCSS, style: :compressed)
+.foo{--multiline: foo bar}
+CSS
+.foo {
+  --multiline: foo\s
+
+
+    bar;
+}
+SCSS
   end
 
-  def test_variable_warning_for_nested_properties
-    assert_warning(<<WARNING) {render(<<SCSS)}
-DEPRECATION WARNING on line 2 of #{filename_for_test :scss}:
-Sass 3.6 will change the way CSS variables are parsed. Instead of being parsed as
-normal properties, they will not allow any Sass-specific behavior other than \#{}.
-WARNING
+  # Conversion.
+
+  def test_static_values_convert
+    assert_converts <<SASS, <<SCSS
+.foo
+  --bar: baz
+SASS
 .foo {
-  --var: {
-    a: b;
-  }
+  --bar: baz;
+}
+SCSS
+
+    assert_converts <<SASS, <<SCSS
+.foo
+  --bar: [({{([!;])}})]
+SASS
+.foo {
+  --bar: [({{([!;])}})];
+}
+SCSS
+
+    assert_converts <<SASS, <<SCSS
+.foo
+  --bar: {a: b; c: d}
+SASS
+.foo {
+  --bar: {a: b; c: d};
 }
 SCSS
   end
 
-  def test_no_warning
-    assert_no_variable_warning("foo")
-    assert_no_variable_warning("true")
-    assert_no_variable_warning("1, 2")
-    assert_no_variable_warning("1 2")
-    assert_no_variable_warning("1 / 2")
-    assert_no_variable_warning("foo / bar")
-    assert_no_variable_warning("asdf(foo)")
-    assert_no_variable_warning("calc(1 + 1)")
-    assert_no_variable_warning("asdf(foo=2)")
+  def test_dynamic_values_convert
+    assert_converts <<SASS, <<SCSS
+.foo
+  --bar: baz \#{bang} qux
+SASS
+.foo {
+  --bar: baz \#{bang} qux;
+}
+SCSS
+
+    assert_converts <<SASS, <<SCSS
+.foo
+  --bar: "baz \#{bang} qux"
+SASS
+.foo {
+  --bar: "baz \#{bang} qux";
+}
+SCSS
   end
 
-  def test_no_warning_within_interpolation
-    assert_no_variable_warning('#{1 + 1}')
-    assert_no_variable_warning('#{alpha(#abc)}')
+  def test_multiline_value_converts
+    assert_scss_to_scss <<SCSS
+.foo {
+  --bar: {
+    a: b;
+    c: d;
+  };
+}
+SCSS
+
+    assert_scss_to_sass <<SASS, <<SCSS
+.foo
+  --bar: {     a: b;     c: d;   }
+SASS
+.foo {
+  --bar: {
+    a: b;
+    c: d;
+  };
+}
+SCSS
   end
 
   private
 
-  def assert_no_variable_warning(str)
-    assert_no_warning {render("a {--var: #{str}}")}
-    assert_no_warning {render("a\n  --var: #{str}", :syntax => :sass)}
-  end
+  def assert_variable_value(expected, source)
+    expected = <<CSS
+x {
+  --variable: #{expected}; }
+CSS
 
-  def resolve_with_variable_warning(str, expression = nil)
-    render_with_variable_warning("a {--var: #{str}}", expression || str, 1)
-    render_with_variable_warning(
-      "a\n  --var: #{str}", expression || str, 2, :syntax => :sass)
+    assert_equal expected, render_variable(source)
+    assert_equal expected, render_variable(source, syntax: :sass)
   end
 
-  def render_with_variable_warning(sass, expression, line, opts = {})
-    opts[:syntax] ||= :scss
-    assert_warning(<<WARNING) {render(sass, opts)}
-DEPRECATION WARNING on line #{line} of #{filename_for_test(opts[:syntax])}:
-Sass 3.6 will change the way CSS variables are parsed. Instead of being parsed as
-normal properties, they will not allow any Sass-specific behavior other than \#{}.
-For forwards-compatibility, use \#{}:
-
-  --variable: \#{#{expression}};
-WARNING
+  def render_variable(source, syntax: :scss)
+    render(syntax == :scss ? <<SCSS : <<SASS, :syntax => syntax)
+x {
+  --variable: #{source};
+}
+SCSS
+x
+  --variable: #{source}
+SASS
   end
 
   def render(sass, options = {})

data/test/sass/encoding_test.rb

@@ -8,8 +8,6 @@ class EncodingTest < MiniTest::Test
   include Sass::Util::Test
 
   def test_encoding_error
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     render("foo\nbar\nb\xFEaz".force_encoding("utf-8"))
     assert(false, "Expected exception")
   rescue Sass::SyntaxError => e
@@ -18,8 +16,6 @@ class EncodingTest < MiniTest::Test
   end
 
   def test_ascii_incompatible_encoding_error
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     template = "foo\nbar\nb_z".encode("utf-16le")
     template[9] = "\xFE".force_encoding("utf-16le")
     render(template)
@@ -30,8 +26,6 @@ class EncodingTest < MiniTest::Test
   end
 
   def test_prefers_charset_to_ruby_encoding
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_renders_encoded(<<CSS, <<SASS.encode("IBM866").force_encoding("UTF-8"))
 @charset "UTF-8";
 fЖЖ {
@@ -44,8 +38,6 @@ SASS
   end
 
   def test_uses_ruby_encoding_without_charset
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_renders_encoded(<<CSS, <<SASS.encode("IBM866"))
 @charset "UTF-8";
 тАЬ {
@@ -57,8 +49,6 @@ SASS
   end
 
   def test_multibyte_charset_without_bom_declared_as_binary
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     engine = Sass::Engine.new(<<SASS.encode("UTF-16LE").force_encoding("BINARY"))
 @charset "utf-16le"
 fóó
@@ -71,8 +61,6 @@ SASS
   end
 
   def test_multibyte_charset_without_bom_declared_as_utf_8
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     engine = Sass::Engine.new(<<SASS.encode("UTF-16LE").force_encoding("UTF-8"))
 @charset "utf-16le"
 fóó
@@ -85,8 +73,6 @@ SASS
   end
 
   def test_utf_16le_with_bom
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_renders_encoded(<<CSS, <<SASS.encode("UTF-16LE").force_encoding("BINARY"))
 @charset "UTF-8";
 fóó {
@@ -98,8 +84,6 @@ SASS
   end
 
   def test_utf_16be_with_bom
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_renders_encoded(<<CSS, <<SASS.encode("UTF-16BE").force_encoding("BINARY"))
 @charset "UTF-8";
 fóó {
@@ -111,8 +95,6 @@ SASS
   end
 
   def test_utf_8_with_bom
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_renders_encoded(<<CSS, <<SASS.force_encoding("BINARY"))
 @charset "UTF-8";
 fóó {
@@ -124,8 +106,6 @@ SASS
   end
 
   def test_charset_with_multibyte_encoding
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     engine = Sass::Engine.new(<<SASS)
 @charset "utf-32be"
 fóó
@@ -137,8 +117,6 @@ SASS
   end
 
   def test_charset_with_special_case_encoding
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     # For some reason, a file with an ASCII-compatible UTF-16 charset
     # declaration is specced to be parsed as UTF-8.
     assert_renders_encoded(<<CSS, <<SASS.force_encoding("BINARY"))
@@ -153,8 +131,6 @@ SASS
   end
 
   def test_compressed_output_uses_bom
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_equal("\uFEFFfóó{a:b}\n", render(<<SASS, :style => :compressed))
 fóó
   a: b
@@ -167,19 +143,15 @@ SASS
   end
 
   def test_null_normalization
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-    
     assert_equal(<<CSS, render("/* foo\x00bar\x00baz */", :syntax => :scss))
-#{"@charset \"UTF-8\";\n" unless Sass::Util.ruby1_8?
-}/* foo�bar�baz */
+@charset "UTF-8";
+/* foo�bar�baz */
 CSS
   end
 
   # Regression
 
   def test_multibyte_prop_name
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_equal(<<CSS, render(<<SASS))
 @charset "UTF-8";
 #bar {
@@ -191,8 +163,6 @@ SASS
   end
 
   def test_multibyte_and_interpolation
-    return skip "Can't be run on Ruby 1.8." if Sass::Util.ruby1_8?
-
     assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
 #bar {
   background: a 0%; }