haml 2.2.24 → 3.0.0.beta.1

data/test/sass/results/parent_ref.css

@@ -1,13 +1,13 @@
-a { color: #000; }
-a:hover { color: #f00; }
+a { color: black; }
+a:hover { color: red; }
 
 p, div { width: 100em; }
 p foo, div foo { width: 10em; }
 p:hover, p bar, div:hover, div bar { height: 20em; }
 
 #cool { border-style: solid; border-width: 2em; }
-.ie7 #cool, .ie6 #cool { content: string(Totally not cool.); }
-.firefox #cool { content: string(Quite cool.); }
+.ie7 #cool, .ie6 #cool { content: string("Totally not cool."); }
+.firefox #cool { content: string("Quite cool."); }
 
 .wow, .snazzy { font-family: fantasy; }
 .wow:hover, .wow:visited, .snazzy:hover, .snazzy:visited { font-weight: bold; }

data/test/sass/results/script.css

@@ -1,7 +1,7 @@
-#main { content: Hello!; qstr: Quo"ted"!; hstr: Hyph-en!; width: 30em; background-color: #000; color: #ffffaa; short-color: #112233; named-color: olive; con: foo bar(9 hi there boom); con2: noquo quo; }
+#main { content: Hello!; qstr: 'Quo"ted"!'; hstr: Hyph-en!; width: 30em; background-color: black; color: #ffffaa; short-color: #112233; named-color: olive; con: "foo" bar(9 hi there "boom"); con2: "noquo" quo; }
 #main #sidebar { background-color: #00ff98; num-normal: 10; num-dec: 10.2; num-dec0: 99; num-neg: -10; esc: 10 +12; many: 6; order: 7; complex: #4c9db1hi16; }
 
-#plus { num-num: 7; num-num-un: 25em; num-num-un2: 23em; num-num-neg: 9.87; num-str: 100px; num-col: #b7b7b7; num-perc: 31%; str-str: hi there; str-str2: hi there; str-col: 14em solid #112233; str-num: times: 13; col-num: #ff7b9d; col-col: #5173ff; }
+#plus { num-num: 7; num-num-un: 25em; num-num-un2: 23em; num-num-neg: 9.87; num-str: 100px; num-col: #b7b7b7; num-perc: 31%; str-str: "hi there"; str-str2: "hi there"; str-col: "14em solid #112233"; str-num: "times: 13"; col-num: #ff7b9d; col-col: #5173ff; }
 
 #minus { num-num: 900; col-num: #f9f9f4; col-col: #000035; unary-num: -1; unary-const: 10; unary-paren: -11; unary-two: 12; unary-many: 12; unary-crazy: -15; }
 
@@ -11,6 +11,6 @@
 
 #mod { num-num: 2; col-col: #0f0e05; col-num: #020001; }
 
-#const { escaped-quote: !foo; default: Hello! !important; }
+#const { escaped-quote: $foo !bar; default: Hello! !important; }
 
 #regression { a: 4; }

data/test/sass/results/scss_import.css

@@ -0,0 +1,15 @@
+imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
+
+body { font: Arial; background: blue; }
+
+#page { width: 700px; height: 100; }
+#page #header { height: 300px; }
+#page #header h1 { font-size: 50px; color: blue; }
+
+#content.user.show #container.top #column.left { width: 100px; }
+#content.user.show #container.top #column.right { width: 600px; }
+#content.user.show #container.bottom { background: brown; }
+
+midrule { inthe: middle; }
+
+nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/results/scss_importee.css

@@ -0,0 +1,2 @@
+scss {
+  imported: yes; }

data/test/sass/script_conversion_test.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+require File.dirname(__FILE__) + '/../test_helper'
+require 'sass/engine'
+
+class SassScriptConversionTest < Test::Unit::TestCase
+  def test_bool
+    assert_renders "true"
+    assert_renders "false"
+  end
+
+  def test_color
+    assert_renders "#abcdef"
+    assert_renders "blue"
+    assert_renders "rgba(0, 1, 2, 0.2)"
+
+    assert_equal "#aabbcc", render("#abc")
+    assert_equal "blue", render("#0000ff")
+  end
+
+  def test_number
+    assert_renders "10"
+    assert_renders "10.35"
+    assert_renders "12px"
+    assert_renders "12.45px"
+
+    assert_equal "12.346", render("12.345678901")
+  end
+
+  def test_string
+    assert_renders '"foo"'
+    assert_renders '"bar baz"'
+    assert_equal '"baz bang"', render("'baz bang'")
+  end
+
+  def test_string_quotes
+    assert_equal "'quote\"quote'", render('"quote\\"quote"')
+    assert_equal '"quote\'quote"', render("'quote\\'quote'")
+    assert_renders '"quote\'quote\\"quote"'
+    assert_equal '"quote\'quote\\"quote"', render("'quote\\'quote\"quote'")
+  end
+
+  def test_string_escapes
+    assert_renders '"foo\\\\bar"'
+  end
+
+  def test_funcall
+    assert_renders "foo(true, blue)"
+    assert_renders "hsla(20deg, 30%, 50%, 0.3)"
+    assert_renders "blam()"
+
+    assert_renders "-\xC3\xBFoo(12px)"
+    assert_renders "-foo(12px)"
+  end
+
+  def test_variable
+    assert_renders "$foo-bar"
+    assert_renders "$flaznicate"
+    assert_warning(<<WARN) {assert_equal "$tumbly-wumbly", render("!tumbly-wumbly")}
+DEPRECATION WARNING:
+On line 1, character 1 of 'test_variable_inline.sass'
+Variables with ! have been deprecated and will be removed in version 3.2.
+Use "$tumbly-wumbly" instead.
+
+You can use `sass-convert --in-place --from sass2 file.sass' to convert files automatically.
+WARN
+  end
+
+  def test_important
+    assert_renders "!important"
+    assert_renders "$foo !important"
+  end
+
+  def test_comma_operator
+    assert_renders "$foo, $bar $baz"
+    assert_renders "$foo $bar, $baz"
+
+    assert_renders "($foo, $bar) $baz"
+    assert_renders "$foo ($bar, $baz)"
+
+    assert_equal "$foo, $bar $baz", render("$foo, ($bar $baz)")
+    assert_equal "$foo $bar, $baz", render("($foo $bar), $baz")
+  end
+
+  def test_concat_operator
+    assert_renders "$foo $bar or $baz"
+    assert_renders "$foo or $bar $baz"
+
+    assert_renders "($foo $bar) or $baz"
+    assert_renders "$foo or ($bar $baz)"
+
+    assert_equal "$foo $bar or $baz", render("$foo ($bar or $baz)")
+    assert_equal "$foo or $bar $baz", render("($foo or $bar) $baz")
+  end
+
+  def self.test_precedence(outer, inner)
+    op_outer = Sass::Script::Lexer::OPERATORS_REVERSE[outer]
+    op_inner = Sass::Script::Lexer::OPERATORS_REVERSE[inner]
+    class_eval <<RUBY
+      def test_precedence_#{outer}_#{inner} 
+        assert_renders "$foo #{op_outer} $bar #{op_inner} $baz"
+        assert_renders "$foo #{op_inner} $bar #{op_outer} $baz"
+
+        assert_renders "($foo #{op_outer} $bar) #{op_inner} $baz"
+        assert_renders "$foo #{op_inner} ($bar #{op_outer} $baz)"
+
+        assert_equal "$foo #{op_outer} $bar #{op_inner} $baz",
+          render("$foo #{op_outer} ($bar #{op_inner} $baz)")
+        assert_equal "$foo #{op_inner} $bar #{op_outer} $baz",
+          render("($foo #{op_inner} $bar) #{op_outer} $baz")
+      end
+RUBY
+  end
+
+  test_precedence :or, :and
+  test_precedence :and, :eq
+  test_precedence :and, :neq
+  test_precedence :eq, :gt
+  test_precedence :eq, :gte
+  test_precedence :eq, :lt
+  test_precedence :eq, :lte
+  test_precedence :gt, :plus
+  test_precedence :gt, :minus
+  test_precedence :plus, :times
+  test_precedence :plus, :div
+  test_precedence :plus, :mod
+
+  def test_unary_op
+    assert_renders "-12px"
+    assert_renders '/"foo"'
+    assert_renders 'not true'
+
+    assert_renders "-(foo(12px))"
+    assert_renders "-(-foo(12px))"
+    assert_renders "-(_foo(12px))"
+    assert_renders "-(\xC3\xBFoo(12px))"
+    assert_renders "-(blue)"
+
+    assert_equal 'not true or false', render('(not true) or false')
+    assert_equal 'not (true or false)', render('not (true or false)')
+  end
+
+  private
+
+  def assert_renders(script, options = {})
+    assert_equal(script, render(script, options))
+  end
+
+  def render(script, options = {})
+    munge_filename(options)
+    Sass::Script.parse(script, 1, 0, options).to_sass
+  end
+end

data/test/sass/script_test.rb

@@ -2,6 +2,13 @@
 require File.dirname(__FILE__) + '/../test_helper'
 require 'sass/engine'
 
+module Sass::Script::Functions::UserFunctions
+  def assert_options(val)
+    val.options[:foo]
+    Sass::Script::String.new("Options defined!")
+  end
+end
+
 class SassScriptTest < Test::Unit::TestCase
   include Sass::Script
 
@@ -10,10 +17,27 @@ class SassScriptTest < Test::Unit::TestCase
     assert_raise(Sass::SyntaxError, "Color values must be between 0 and 255") {Color.new([256, 2, 3])}
   end
 
+  def test_color_checks_rgba_input
+    assert_raise(Sass::SyntaxError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
+    assert_raise(Sass::SyntaxError, "Alpha channel must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
+  end
+
   def test_string_escapes
+    assert_equal "'", resolve("\"'\"")
     assert_equal '"', resolve("\"\\\"\"")
     assert_equal "\\", resolve("\"\\\\\"")
     assert_equal "\\02fa", resolve("\"\\02fa\"")
+
+    assert_equal "'", resolve("'\\''")
+    assert_equal '"', resolve("'\"'")
+    assert_equal "\\", resolve("'\\\\'")
+    assert_equal "\\02fa", resolve("'\\02fa'")
+  end
+
+  def test_string_interpolation
+    assert_equal "foo2bar", resolve('\'foo#{1 + 1}bar\'')
+    assert_equal "foo2bar", resolve('"foo#{1 + 1}bar"')
+    assert_equal "foo1bar5baz4bang", resolve('\'foo#{1 + "bar#{2 + 3}baz" + 4}bang\'')
   end
 
   def test_color_names
@@ -22,14 +46,57 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal "#fffffe", resolve("white - #000001")
   end
 
-  def test_implicit_strings
-    silence_warnings do
-      assert_equal Sass::Script::String.new("foo"), eval("foo")
-      assert_equal Sass::Script::String.new("foo bar"), eval("foo bar")
-      assert_equal Sass::Script::String.new("foo/bar"), eval("foo/bar")
+  def test_rgba_color_literals
+    assert_equal Sass::Script::Color.new([1, 2, 3, 0.75]), eval("rgba(1, 2, 3, 0.75)")
+    assert_equal "rgba(1, 2, 3, 0.75)", resolve("rgba(1, 2, 3, 0.75)")
+
+    assert_equal Sass::Script::Color.new([1, 2, 3, 0]), eval("rgba(1, 2, 3, 0)")
+    assert_equal "rgba(1, 2, 3, 0)", resolve("rgba(1, 2, 3, 0)")
+
+    assert_equal Sass::Script::Color.new([1, 2, 3]), eval("rgba(1, 2, 3, 1)")
+    assert_equal Sass::Script::Color.new([1, 2, 3, 1]), eval("rgba(1, 2, 3, 1)")
+    assert_equal "#010203", resolve("rgba(1, 2, 3, 1)")
+    assert_equal "white", resolve("rgba(255, 255, 255, 1)")
+  end
+
+  def test_rgba_color_math
+    assert_equal "rgba(50, 50, 100, 0.35)", resolve("rgba(1, 1, 2, 0.35) * rgba(50, 50, 50, 0.35)")
+    assert_equal "rgba(52, 52, 52, 0.25)", resolve("rgba(2, 2, 2, 0.25) + rgba(50, 50, 50, 0.25)")
+
+    assert_raise(Sass::SyntaxError, "Alpha channels must be equal: rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)") do
+      resolve("rgba(1, 2, 3, 0.15) + rgba(50, 50, 50, 0.75)")
+    end
+    assert_raise(Sass::SyntaxError, "Alpha channels must be equal: #123456 * rgba(50, 50, 50, 0.75)") do
+      resolve("#123456 * rgba(50, 50, 50, 0.75)")
+    end
+    assert_raise(Sass::SyntaxError, "Alpha channels must be equal: #123456 / #123456") do
+      resolve("rgba(50, 50, 50, 0.75) / #123456")
     end
   end
 
+  def test_rgba_number_math
+    assert_equal "rgba(49, 49, 49, 0.75)", resolve("rgba(50, 50, 50, 0.75) - 1")
+    assert_equal "rgba(100, 100, 100, 0.75)", resolve("rgba(50, 50, 50, 0.75) * 2")
+  end
+
+  def test_compressed_colors
+    assert_equal "#123456", resolve("#123456", :style => :compressed)
+    assert_equal "rgba(1, 2, 3, 0.5)", resolve("rgba(1, 2, 3, 0.5)", :style => :compressed)
+    assert_equal "#123", resolve("#112233", :style => :compressed)
+    assert_equal "#000", resolve("black", :style => :compressed)
+    assert_equal "red", resolve("#f00", :style => :compressed)
+    assert_equal "blue", resolve("#00f", :style => :compressed)
+    assert_equal "navy", resolve("#000080", :style => :compressed)
+    assert_equal "navy #fff", resolve("#000080 white", :style => :compressed)
+    assert_equal "This color is #fff", resolve('"This color is #{ white }"', :style => :compressed)
+  end
+
+  def test_implicit_strings
+    assert_equal Sass::Script::String.new("foo"), eval("foo")
+    assert_equal Sass::Script::String.new("foo bar"), eval("foo bar")
+    assert_equal Sass::Script::String.new("foo/bar"), eval("foo/bar")
+  end
+
   def test_interpolation
     assert_equal "foo bar, baz bang", resolve('"foo #{"bar"}, #{"baz"} bang"')
     assert_equal "foo bar baz bang", resolve('"foo #{"#{"ba" + "r"} baz"} bang"')
@@ -61,63 +128,23 @@ foo \#{"\\\#{" + "baz"} bang
 SASS
   end
 
-  def test_implicit_string_warning
-    assert_warning(<<WARN) {eval("foo")}
-DEPRECATION WARNING:
-On line 1, character 1 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-    assert_warning(<<WARN) {eval("1 + foo")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-    assert_warning(<<WARN) {render("@if 1 + foo")}
-DEPRECATION WARNING:
-On line 1, character 9 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'foo' was not quoted. Please add double quotes (e.g. "foo").
-WARN
-
-    # Regression
-    assert_warning(<<WARN) {render("@if if")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_implicit_string_warning_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'if' was not quoted. Please add double quotes (e.g. "if").
-WARN
-  end
-
   def test_inaccessible_functions
-    assert_warning <<WARN do
-DEPRECATION WARNING:
-On line 2, character 6 of 'test_inaccessible_functions_inline.sass'
-Implicit strings have been deprecated and will be removed in version 3.0.
-'to_s' was not quoted. Please add double quotes (e.g. "to_s").
-WARN
-      assert_equal "send(to_s)", resolve("send(to_s)", :line => 2)
-    end
+    assert_equal "send(to_s)", resolve("send(to_s)", :line => 2)
     assert_equal "public_instance_methods()", resolve("public_instance_methods()")
   end
 
-  def test_hyphen_warning
-    a = Sass::Script::String.new("a")
-    b = Sass::Script::String.new("b")
-    assert_warning(<<WARN) {eval("!a-!b", {}, env("a" => a, "b" => b))}
-DEPRECATION WARNING:
-On line 1, character 3 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 3.0.
-Please add whitespace to separate it from the previous token.
-WARN
+  def test_default_functions
+    assert_equal "url(12)", resolve("url(12)")
+    assert_equal 'blam("foo")', resolve('blam("foo")')
+  end
 
-    assert_warning(<<WARN) {eval("true-false")}
-DEPRECATION WARNING:
-On line 1, character 5 of 'test_hyphen_warning_inline.sass'
-- will be allowed as part of variable names in version 3.0.
-Please add whitespace to separate it from the previous token.
-WARN
+  def test_function_results_have_options
+    assert_equal "Options defined!", resolve("assert_options(abs(1))")
+    assert_equal "Options defined!", resolve("assert_options(round(1.2))")
+  end
+
+  def test_hyphenated_variables
+    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::String.new("a-b"))))
   end
 
   def test_ruby_equality
@@ -155,27 +182,27 @@ WARN
     assert_equal "2", resolve("1 + 1")
     assert_equal "0", resolve("1 - 1")
     assert_equal "8", resolve("2 * 4")
-    assert_equal "0.5", resolve("2 / 4")
-    assert_equal "2", resolve("4 / 2")
+    assert_equal "0.5", resolve("(2 / 4)")
+    assert_equal "2", resolve("(4 / 2)")
 
     assert_equal "-1", resolve("-1")
   end
 
   def test_string_ops
-    assert_equal "foo bar", resolve('"foo" "bar"')
+    assert_equal '"foo" "bar"', resolve('"foo" "bar"')
     assert_equal "true 1", resolve('true 1')
-    assert_equal "foo, bar", resolve('"foo" , "bar"')
+    assert_equal '"foo", "bar"', resolve("'foo' , 'bar'")
     assert_equal "true, 1", resolve('true , 1')
     assert_equal "foobar", resolve('"foo" + "bar"')
     assert_equal "true1", resolve('true + 1')
-    assert_equal "foo-bar", resolve('"foo" - "bar"')
+    assert_equal '"foo"-"bar"', resolve("'foo' - 'bar'")
     assert_equal "true-1", resolve('true - 1')
-    assert_equal "foo/bar", resolve('"foo" / "bar"')
+    assert_equal '"foo"/"bar"', resolve('"foo" / "bar"')
     assert_equal "true/1", resolve('true / 1')
 
-    assert_equal "-bar", resolve('- "bar"')
+    assert_equal '-"bar"', resolve("- 'bar'")
     assert_equal "-true", resolve('- true')
-    assert_equal "/bar", resolve('/ "bar"')
+    assert_equal '/"bar"', resolve('/ "bar"')
     assert_equal "/true", resolve('/ true')
   end
 
@@ -195,7 +222,7 @@ WARN
   end
 
   def test_equals
-    assert_equal("true", resolve('"foo" == !foo', {},
+    assert_equal("true", resolve('"foo" == $foo', {},
         env("foo" => Sass::Script::String.new("foo"))))
     assert_equal "true", resolve("1 == 1.0")
     assert_equal "true", resolve("false != true")
@@ -225,7 +252,46 @@ WARN
     assert_equal "true", resolve("1.1cm == 11mm")
   end
 
-  # Regression tests
+  def test_operations_have_options
+    assert_equal "Options defined!", resolve("assert_options(1 + 1)")
+    assert_equal "Options defined!", resolve("assert_options('bar' + 'baz')")
+  end
+
+  def test_slash_compiles_literally_when_left_alone
+    assert_equal "1px/2px", resolve("1px/2px")
+    assert_equal "1px/2px/3px/4px", resolve("1px/2px/3px/4px")
+
+    assert_equal "1px/2px redpx bluepx", resolve("1px/2px redpx bluepx")
+    assert_equal "foo 1px/2px/3px bar", resolve("foo 1px/2px/3px bar")
+  end
+
+  def test_slash_divides_with_parens
+    assert_equal "0.5", resolve("(1px/2px)")
+    assert_equal "0.5", resolve("(1px)/2px")
+    assert_equal "0.5", resolve("1px/(2px)")
+  end
+
+  def test_slash_divides_with_other_arithmetic
+    assert_equal "0.5px", resolve("1px*1px/2px")
+    assert_equal "0.5px", resolve("1px/2px*1px")
+    assert_equal "0.5", resolve("0+1px/2px")
+    assert_equal "0.5", resolve("1px/2px+0")
+  end
+
+  def test_slash_divides_with_variable
+    assert_equal "0.5", resolve("$var/2px", {}, env("var" => eval("1px")))
+    assert_equal "0.5", resolve("1px/$var", {}, env("var" => eval("2px")))
+    assert_equal "0.5", resolve("$var", {}, env("var" => eval("1px/2px")))
+  end
+
+  # Regression Tests
+
+  def test_funcall_has_higher_precedence_than_color_name
+    assert_equal "teal(12)", resolve("teal(12)")
+    assert_equal "tealbang(12)", resolve("tealbang(12)")
+    assert_equal "teal-bang(12)", resolve("teal-bang(12)")
+    assert_equal "teal+bang(12)", resolve("teal\\+bang(12)")
+  end
 
   def test_interpolation_after_hash
     assert_equal "#2", resolve('"##{1 + 1}"')
@@ -235,13 +301,14 @@ WARN
 
   def resolve(str, opts = {}, environment = env)
     munge_filename opts
-    eval(str, opts, environment).to_s
+    val = eval(str, opts, environment)
+    val.is_a?(Sass::Script::String) ? val.value : val.to_s
   end
 
   def eval(str, opts = {}, environment = env)
     munge_filename opts
-    Sass::Script.parse(str, opts[:line] || 1,
-      opts[:offset] || 0, opts[:filename]).perform(environment)
+    Sass::Script.parse(str, opts.delete(:line) || 1,
+      opts.delete(:offset) || 0, opts).perform(environment)
   end
 
   def render(sass, options = {})