sass 3.4.25 → 3.5.0

data/test/sass/css2sass_test.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 require 'minitest/autorun'
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/css'
@@ -498,24 +497,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

@@ -1,105 +1,210 @@
-#!/usr/bin/env ruby
 
 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

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
 require File.dirname(__FILE__) + '/test_helper'
@@ -8,8 +7,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 +15,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 +25,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 +37,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 +48,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 +60,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 +72,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 +83,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 +94,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 +105,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 +116,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 +130,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 +142,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 +162,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%; }

data/test/sass/engine_test.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
 require File.dirname(__FILE__) + '/test_helper'
@@ -98,8 +97,6 @@ MSG
     "a\n\t\tb: c\n\tb: c" => ["Inconsistent indentation: 1 tab was used for indentation, but the rest of the document was indented using 2 tabs.", 3],
     "a\n  b: c\n   b: c" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 3],
     "a\n  b: c\n  a\n   d: e" => ["Inconsistent indentation: 3 spaces were used for indentation, but the rest of the document was indented using 2 spaces.", 4],
-    "a\n  b: c\na\n    d: e" => ["The line was indented 2 levels deeper than the previous line.", 4],
-    "a\n  b: c\n  a\n        d: e" => ["The line was indented 3 levels deeper than the previous line.", 4],
     "a\n \tb: c" => ["Indentation can't use both tabs and spaces.", 2],
     "=a(" => 'Invalid CSS after "(": expected variable (e.g. $foo), was ""',
     "=a(b)" => 'Invalid CSS after "(": expected variable (e.g. $foo), was "b)"',
@@ -139,7 +136,7 @@ MSG
     '@for $a from "foo" to 1' => '"foo" is not an integer.',
     '@for $a from 1 to "2"' => '"2" is not an integer.',
     '@for $a from 1 to "foo"' => '"foo" is not an integer.',
-    '@for $a from 1 to 1.232323' => '1.23232 is not an integer.',
+    '@for $a from 1 to 1.23232323232' => '1.2323232323 is not an integer.',
     '@for $a from 1px to 3em' => "Incompatible units: 'em' and 'px'.",
     '@if' => "Invalid if directive '@if': expected expression.",
     '@while' => "Invalid while directive '@while': expected expression.",
@@ -1793,7 +1790,7 @@ SASS
 
   def test_loud_comment_is_evaluated
     assert_equal <<CSS, render(<<SASS)
-/*! Hue: 327.21649deg */
+/*! Hue: 327.2164948454deg */
 CSS
 /*! Hue: \#{hue(#f836a0)}
 SASS
@@ -2700,15 +2697,6 @@ a
 SASS
   end
 
-  def test_mixin_no_arg_error
-    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "($bar,": expected variable (e.g. $foo), was ")"') do
-      render(<<SASS)
-=foo($bar,)
-  bip: bap
-SASS
-    end
-  end
-
   def test_import_with_commas_in_url
     assert_equal <<CSS, render(<<SASS)
 @import url(foo.css?bar,baz);
@@ -3324,13 +3312,13 @@ SASS
 
   def test_numeric_formatting_of_integers
     assert_equal(<<CSS, render(<<SASS, :syntax => :scss, :style => :compressed))
-a{near:3.00001;plus:3;minus:3;negative:-3}
+a{near:3.0000000001;plus:3;minus:3;negative:-3}
 CSS
 a {
-  near: (3 + 0.00001);
-  plus: (3 + 0.0000001);
-  minus: (3 - 0.0000001);
-  negative: (-3 + 0.0000001);
+  near: (3 + 0.0000000001);
+  plus: (3 + 0.000000000001);
+  minus: (3 - 0.000000000001);
+  negative: (-3 + 0.000000000001);
 }
 SASS
   end
@@ -3391,6 +3379,70 @@ CSS
 SASS
   end
 
+  def test_trailing_commas_in_arglists
+    assert_equal(<<CSS, render(<<SASS, :style => :nested))
+.includes {
+  one-positional-arg: positional 1 a;
+  two-positional-args: positional 2 a b;
+  one-keyword-arg: keyword 1 z;
+  two-keyword-args: keyword 2 y z;
+  mixed-args: mixed 2 y z; }
+
+.calls {
+  one-positional-arg: positional 1 a;
+  two-positional-args: positional 2 a b;
+  one-keyword-arg: keyword 1 z;
+  two-keyword-args: keyword 2 y z;
+  mixed-args: mixed 2 y z; }
+CSS
+=one-positional-arg($a,)
+  one-positional-arg: positional 1 $a
+
+=two-positional-args($a, $b,)
+  two-positional-args: positional 2 $a $b
+
+=one-keyword-arg($a: a,)
+  one-keyword-arg: keyword 1 $a
+
+=two-keyword-args($a: a, $b: b,)
+  two-keyword-args: keyword 2 $a $b
+
+=mixed-args($a, $b: b,)
+  mixed-args: mixed 2 $a $b
+
+@function one-positional-arg($a)
+  @return positional 1 $a
+
+@function two-positional-args($a, $b)
+  @return positional 2 $a $b
+
+@function one-keyword-arg($a: a)
+  @return keyword 1 $a
+
+@function two-keyword-args($a: a, $b: b)
+  @return keyword 2 $a $b
+
+@function mixed-args($a, $b: b)
+  @return mixed 2 $a $b
+
+
+.includes
+  +one-positional-arg(a,)
+  +two-positional-args(a, b,)
+  +one-keyword-arg($a: z,)
+  +two-keyword-args($a: y, $b: z,)
+  +mixed-args(y, $b: z,)
+
+
+.calls
+  one-positional-arg: one-positional-arg(a)
+  two-positional-args: two-positional-args(a, b)
+  one-keyword-arg: one-keyword-arg($a: z)
+  two-keyword-args: two-keyword-args($a: y, $b: z)
+  mixed-args: mixed-args(y, $b: z)
+SASS
+  end
+
   private
 
   def assert_hash_has(hash, expected)

data/test/sass/exec_test.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 require 'fileutils'
 require 'sass/util/test'