sass 3.3.0 → 3.4.25

data/test/sass/css2sass_test.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
-require 'test/unit'
+require 'minitest/autorun'
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/css'
 
-class CSS2SassTest < Test::Unit::TestCase
+class CSS2SassTest < MiniTest::Test
   def test_basic
     css = <<CSS
 h1 {
@@ -14,7 +14,7 @@ CSS
 h1
   color: red
 SASS
-    assert_equal(<<SASS, css2sass(css, :old => true))
+    silence_warnings {assert_equal(<<SASS, css2sass(css, :old => true))}
 h1
   :color red
 SASS
@@ -24,10 +24,13 @@ SASS
     assert_equal(<<SASS, css2sass(<<CSS))
 li
   display: none
+
   a
     text-decoration: none
+
     span
       color: yellow
+
     &:hover
       text-decoration: underline
 SASS
@@ -62,7 +65,7 @@ div .debug
 SASS
 div .warning {
   color: #d21a19; }
-span .debug { 
+span .debug {
   cursor: crosshair;}
 div .debug {
   cursor: default; }
@@ -117,6 +120,7 @@ span.turkey
 
 #overhere
   bored: sorta
+
   /*                  it's for a good
    * cause
   better_than: thread_pools
@@ -168,12 +172,16 @@ CSS
     assert_equal(<<SASS, css2sass(<<CSS))
 hello
   parent: true
+
   there
     parent: false
+
   who
     hoo: false
+
   why
     y: true
+
   when
     wen: nao
 
@@ -229,6 +237,7 @@ CSS
     assert_equal(<<SASS, css2sass(<<CSS))
 \\:focus
   a: b
+
   \\:foo
     bar: baz
 SASS
@@ -238,19 +247,22 @@ CSS
   end
 
   def test_subject
-    assert_equal(<<SASS, css2sass(<<CSS))
+    silence_warnings {assert_equal(<<SASS, css2sass(<<CSS))}
 .foo
   .bar!
     .baz
       a: b
+
     .bip
       c: d
+
   .bar .bonk
     e: f
 
 .flip!
   &.bar
     a: b
+
   &.baz
     c: d
 SASS
@@ -263,8 +275,61 @@ SASS
 CSS
   end
 
+  def test_keyframes
+    assert_equal(<<SASS, css2sass(<<CSS))
+@keyframes dash
+  from
+    stroke-dasharray: 1,200
+    stroke-dashoffset: 0
+
+  50%
+    stroke-dasharray: 89,200
+    stroke-dashoffset: -35
+
+  to
+    stroke-dasharray: 89,200
+    stroke-dashoffset: -124
+SASS
+@keyframes dash {
+  from {
+    stroke-dasharray: 1,200;
+    stroke-dashoffset: 0;
+  }
+  50% {
+    stroke-dasharray: 89,200;
+    stroke-dashoffset: -35;
+  }
+  to {
+    stroke-dasharray: 89,200;
+    stroke-dashoffset: -124;
+  }
+}
+CSS
+  end
+
   # Regressions
 
+  def test_nesting_with_matching_property
+    assert_equal(<<SASS, css2sass(<<CSS))
+ul
+  width: 10px
+
+  div
+    width: 20px
+
+article
+  width: 10px
+
+  p
+    width: 20px
+SASS
+ul {width: 10px}
+ul div {width: 20px}
+article {width: 10px}
+article p {width: 20px}
+CSS
+  end
+
   def test_empty_rule
     assert_equal(<<SASS, css2sass(<<CSS))
 a
@@ -277,6 +342,7 @@ CSS
     assert_equal(<<SASS, css2sass(<<CSS))
 a
   color: red
+
   > b
 SASS
 a {color: red}
@@ -327,6 +393,7 @@ CSS
 .foo >
   .bar
     a: b
+
   .baz
     c: d
 SASS
@@ -338,6 +405,7 @@ CSS
 .foo
   &::bar
     a: b
+
   &::baz
     c: d
 SASS

data/test/sass/css_variable_test.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../test_helper'
+require 'sass/engine'
+
+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")
+  end
+
+  def test_variable_warning_for_variable
+    render_with_variable_warning(<<SCSS, "$var", 3)
+.foo {
+  $var: value;
+  --var: $var;
+}
+SCSS
+  end
+
+  def test_variable_warning_for_core_function
+    resolve_with_variable_warning("alpha(#abc)")
+  end
+
+  def test_variable_warning_for_sass_function
+    render_with_variable_warning(<<SCSS, "my-fn()", 2)
+@function my-fn() {@return null}
+.foo {--var: my-fn()}
+SCSS
+  end
+
+  def test_variable_warning_for_parens
+    resolve_with_variable_warning("(foo)", "foo")
+    resolve_with_variable_warning("(foo,)")
+  end
+
+  def test_variable_warning_for_selector
+    resolve_with_variable_warning("&")
+  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
+.foo {
+  --var: {
+    a: b;
+  }
+}
+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)")
+  end
+
+  def test_no_warning_within_interpolation
+    assert_no_variable_warning('#{1 + 1}')
+    assert_no_variable_warning('#{alpha(#abc)}')
+  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 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)
+  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
+  end
+
+  def render(sass, options = {})
+    options[:syntax] ||= :scss
+    options[:cache] = false
+    munge_filename options
+    Sass::Engine.new(sass, options).render
+  end
+
+  def resolve(str, opts = {}, environment = env)
+    munge_filename opts
+    val = eval(str, opts, environment)
+    assert_kind_of Sass::Script::Value::Base, val
+    val.options = opts
+    val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s
+  end
+
+  def eval(str, opts = {}, environment = env)
+    munge_filename opts
+    Sass::Script.parse(str, opts.delete(:line) || 1,
+      opts.delete(:offset) || 0, opts).
+      perform(Sass::Environment.new(environment, opts))
+  end
+
+  def env(hash = {})
+    env = Sass::Environment.new
+    hash.each {|k, v| env.set_var(k, v)}
+    env
+  end
+end

data/test/sass/encoding_test.rb

@@ -0,0 +1,219 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+require 'sass/util/test'
+
+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
+    assert_equal(3, e.sass_line)
+    assert_equal('Invalid UTF-8 character "\xFE"', e.message)
+  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)
+    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_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ЖЖ {
+  a: b; }
+CSS
+@charset "ibm866"
+fЖЖ
+  a: b
+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";
+тАЬ {
+  a: b; }
+CSS
+тАЬ
+  a: b
+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óó
+  a: b
+SASS
+    # Since multibyte encodings' @charset declarations aren't
+    # ASCII-compatible, we have to interpret the files as UTF-8 which will
+    # inevitably fail.
+    assert_raise_message(Sass::SyntaxError, "Invalid UTF-8 character \"\\xF3\"") {engine.render}
+  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óó
+  a: b
+SASS
+    # Since multibyte encodings' @charset declarations aren't
+    # ASCII-compatible, we have to interpret the files as UTF-8 which will
+    # inevitably fail.
+    assert_raise_message(Sass::SyntaxError, "Invalid UTF-8 character \"\\xF3\"") {engine.render}
+  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óó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+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óó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+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óó {
+  a: b; }
+CSS
+\uFEFFfóó
+  a: b
+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óó
+  a: b
+SASS
+    # The charset declaration is just false here, so we should get an
+    # encoding error.
+    assert_raise_message(Sass::SyntaxError, "Invalid UTF-32BE character \"\\xC3\"") {engine.render}
+  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"))
+@charset "UTF-8";
+fóó {
+  a: b; }
+CSS
+@charset "utf-16"
+fóó
+  a: b
+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
+SASS
+  end
+
+  def test_newline_normalization
+    assert_equal("/* foo\nbar\nbaz\nbang\nqux */\n",
+      render("/* foo\nbar\r\nbaz\fbang\rqux */", :syntax => :scss))
+  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 */
+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 {
+  cölor: blue; }
+CSS
+#bar
+  cölor: blue
+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%; }
+CSS
+#bar {
+  // 
+  background: \#{a} 0%;
+}
+SCSS
+  end
+
+  private
+
+  def assert_renders_encoded(css, sass)
+    result = render(sass)
+    assert_equal css.encoding, result.encoding
+    assert_equal css, result
+  end
+
+  def render(sass, options = {})
+    munge_filename options
+    Sass::Engine.new(sass, options).render
+  end
+end