sass 3.2.7 → 3.3.0.rc.1

data/test/sass/importer_test.rb

@@ -8,29 +8,38 @@ class ImporterTest < Test::Unit::TestCase
   
   class FruitImporter < Sass::Importers::Base
     def find(name, context = nil)
-      if name =~ %r{fruits/(\w+)(\.s[ac]ss)?}
-        fruit = $1
-        color = case $1
-        when "apple"
-          "red"
-        when "orange"
-          "orange"
-        else
-          "blue"
-        end
-        contents = %Q{
-          $#{fruit}-color: #{color} !default;
-          @mixin #{fruit} {
-            color: $#{fruit}-color;
-          }
-        }
-        Sass::Engine.new(contents, :filename => name, :syntax => :scss, :importer => self)
+      fruit = parse(name)
+      return unless fruit
+      color = case fruit
+      when "apple"
+        "red"
+      when "orange"
+        "orange"
+      else
+        "blue"
       end
+      contents = %Q{
+        $#{fruit}-color: #{color} !default;
+        @mixin #{fruit} {
+          color: $#{fruit}-color;
+        }
+      }
+      Sass::Engine.new(contents, :filename => name, :syntax => :scss, :importer => self)
     end
 
     def key(name, context)
       [self.class.name, name]
     end
+
+    def public_url(name)
+      "http://#{parse(name)}.example.com/style.scss"
+    end
+
+    private
+
+    def parse(name)
+      name[%r{fruits/(\w+)(\.s[ac]ss)?}, 1]
+    end
   end
 
   # This class proves that you can override the extension scheme for importers
@@ -177,6 +186,145 @@ CSS
     )
   end
 
+  def test_source_map_with_only_css_uri_supports_public_url_imports
+    fruit_importer = FruitImporter.new
+
+    options = {
+      :filename => 'fruits/orange',
+      :importer => fruit_importer,
+      :syntax => :scss
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+.orchard {
+  color: blue;
+}
+SCSS
+
+    _, sourcemap = engine.render_with_sourcemap('sourcemap_uri')
+    assert_equal <<JSON.strip, sourcemap.to_json(:css_uri => 'css_uri')
+{
+"version": "3",
+"mappings": "AAAA,QAAS;EACP,KAAK,EAAE,IAAI",
+"sources": ["http://orange.example.com/style.scss"],
+"file": "css_uri"
+}
+JSON
+  end
+
+  def test_source_map_with_only_css_uri_doesnt_support_filesystem_importer
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    options = {
+      :filename => filename_for_test(:scss),
+      :importer => file_system_importer,
+      :syntax => :scss
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+.foo {a: b}
+SCSS
+
+    _, sourcemap = engine.render_with_sourcemap('http://1.example.com/style.map')
+
+    assert_warning(<<WARNING) {sourcemap.to_json(:css_uri => 'css_uri')}
+WARNING: Couldn't determine public URL for "#{filename_for_test(:scss)}" while generating sourcemap.
+  Without a public URL, there's nothing for the source map to link to.
+  Custom importers should define the #public_url method.
+WARNING
+  end
+
+  def test_source_map_with_css_uri_and_css_path_doesnt_support_filesystem_importer
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    options = {
+      :filename => filename_for_test(:scss),
+      :importer => file_system_importer,
+      :syntax => :scss
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+.foo {a: b}
+SCSS
+
+    _, sourcemap = engine.render_with_sourcemap('http://1.example.com/style.map')
+
+    assert_warning(<<WARNING) {sourcemap.to_json(:css_uri => 'css_uri', :css_path => 'css_path')}
+WARNING: Couldn't determine public URL for "#{filename_for_test(:scss)}" while generating sourcemap.
+  Without a public URL, there's nothing for the source map to link to.
+  Custom importers should define the #public_url method.
+WARNING
+  end
+
+  def test_source_map_with_css_uri_and_sourcemap_path_supports_filesystem_importer
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    options = {
+      :filename => 'sass/style.scss',
+      :importer => file_system_importer,
+      :syntax => :scss
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+.foo {a: b}
+SCSS
+
+    rendered, sourcemap = engine.render_with_sourcemap('http://1.example.com/style.map')
+
+
+    rendered, sourcemap = engine.render_with_sourcemap('http://map.example.com/map/style.map')
+    css_uri = 'css_uri'
+    sourcemap_path = 'map/style.map'
+    assert_equal <<JSON.strip, sourcemap.to_json(:css_uri => css_uri, :sourcemap_path => sourcemap_path)
+{
+"version": "3",
+"mappings": "AAAA,IAAK;EAAC,CAAC,EAAE,CAAC",
+"sources": ["../sass/style.scss"],
+"file": "css_uri"
+}
+JSON
+  end
+
+  def test_source_map_with_css_path_and_sourcemap_path_supports_file_system_importer
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    options = {
+      :filename => 'sass/style.scss',
+      :importer => file_system_importer,
+      :syntax => :scss
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+.foo {a: b}
+SCSS
+
+    _, sourcemap = engine.render_with_sourcemap('http://map.example.com/map/style.map')
+    css_path = 'static/style.css'
+    sourcemap_path = 'map/style.map'
+    assert_equal <<JSON.strip, sourcemap.to_json(:css_path => css_path, :sourcemap_path => sourcemap_path)
+{
+"version": "3",
+"mappings": "AAAA,IAAK;EAAC,CAAC,EAAE,CAAC",
+"sources": ["../sass/style.scss"],
+"file": "../static/style.css"
+}
+JSON
+  end
+
+  def test_render_with_sourcemap_requires_filename
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    engine = Sass::Engine.new(".foo {a: b}", :syntax => :scss, :importer => file_system_importer)
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE) {engine.render_with_sourcemap('sourcemap_url')}
+Error generating source map: couldn't determine public URL for the source stylesheet.
+  No filename is available so there's nothing for the source map to link to.
+MESSAGE
+  end
+
+  def test_render_with_sourcemap_requires_importer_with_public_url
+    class_importer = ClassImporter.new({"pear" => "color: green;"}, {"pear" => Time.now})
+    assert_raise_message(Sass::SyntaxError, <<MESSAGE) {class_importer.find("pear", {}).render_with_sourcemap('sourcemap_url')}
+Error generating source map: couldn't determine public URL for "pear".
+  Without a public URL, there's nothing for the source map to link to.
+  Custom importers should define the #public_url method.
+MESSAGE
+  end
+
   def fixture_dir
     File.join(File.dirname(__FILE__), "fixtures")
   end

data/test/sass/plugin_test.rb

@@ -7,13 +7,13 @@ require 'fileutils'
 module Sass::Script::Functions
   def filename
     filename = options[:filename].gsub(%r{.*((/[^/]+){4})}, '\1')
-    Sass::Script::String.new(filename)
+    Sass::Script::Value::String.new(filename)
   end
 
   def whatever
     custom = options[:custom]
     whatever = custom && custom[:whatever]
-    Sass::Script::String.new(whatever || "incorrect")
+    Sass::Script::Value::String.new(whatever || "incorrect")
   end
 end
 
@@ -123,6 +123,23 @@ CSS
     File.delete(tempfile_loc('bork1'))
   end
 
+  def test_full_exception_with_block_comment
+    File.delete(tempfile_loc('bork5'))
+    check_for_updates!
+    File.open(tempfile_loc('bork5')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...7].join("\n"))
+/*
+Syntax error: Undefined variable: "$bork".
+        on line 3 of #{template_loc('bork5')}
+
+1: bork
+2:   /* foo *\\/
+3:   :bork $bork
+CSS
+    end
+    File.delete(tempfile_loc('bork1'))
+  end
+
   def test_single_level_import_loop
     File.delete(tempfile_loc('single_import_loop'))
     check_for_updates!
@@ -230,17 +247,6 @@ WARNING
 
   # Callbacks
 
-  def test_updating_stylesheets_callback
-    # Should run even when there's nothing to update
-    Sass::Plugin.options[:template_location] = nil
-    assert_callback :updating_stylesheets, []
-  end
-
-  def test_updating_stylesheets_callback_with_never_update
-    Sass::Plugin.options[:never_update] = true
-    assert_no_callback :updating_stylesheets
-  end
-
   def test_updated_stylesheet_callback_for_updated_template
     Sass::Plugin.options[:always_update] = false
     touch 'basic'

data/test/sass/script_conversion_test.rb

@@ -69,6 +69,46 @@ class SassScriptConversionTest < Test::Unit::TestCase
     assert_renders "$flaznicate"
   end
 
+  def test_null
+    assert_renders "null"
+  end
+
+  def test_empty_list
+    assert_renders "()"
+  end
+
+  def test_list_in_args
+    assert_renders "foo((a, b, c))"
+    assert_renders "foo($arg: (a, b, c))"
+    assert_renders "foo(a, b, (a, b, c)...)"
+  end
+
+  def test_singleton_list
+    assert_renders "(1,)"
+    assert_renders "(1 2 3,)"
+    assert_renders "((1, 2, 3),)"
+  end
+
+  def test_map
+    assert_renders "(foo: bar)"
+    assert_renders "(foo: bar, baz: bip)"
+    assert_renders "(foo: bar, baz: (bip: bap))"
+  end
+
+  def test_map_in_list
+    assert_renders "(foo: bar) baz"
+    assert_renders "(foo: bar), (baz: bip)"
+  end
+
+  def test_list_in_map
+    assert_renders "(foo: bar baz)"
+    assert_renders "(foo: (bar, baz), bip: bop)"
+  end
+
+  def test_selector
+    assert_renders "&"
+  end
+
   def self.test_precedence(outer, inner)
     op_outer = Sass::Script::Lexer::OPERATORS_REVERSE[outer]
     op_inner = Sass::Script::Lexer::OPERATORS_REVERSE[inner]

data/test/sass/script_test.rb

@@ -5,7 +5,7 @@ require 'sass/engine'
 module Sass::Script::Functions::UserFunctions
   def assert_options(val)
     val.options[:foo]
-    Sass::Script::String.new("Options defined!")
+    Sass::Script::Value::String.new("Options defined!")
   end
 
   def arg_error
@@ -21,13 +21,13 @@ class SassScriptTest < Test::Unit::TestCase
   include Sass::Script
 
   def test_color_checks_input
-    assert_raise_message(ArgumentError, "Blue value -1 must be between 0 and 255") {Color.new([1, 2, -1])}
-    assert_raise_message(ArgumentError, "Red value 256 must be between 0 and 255") {Color.new([256, 2, 3])}
+    assert_raise_message(ArgumentError, "Blue value -1 must be between 0 and 255") {Sass::Script::Value::Color.new([1, 2, -1])}
+    assert_raise_message(ArgumentError, "Red value 256 must be between 0 and 255") {Sass::Script::Value::Color.new([256, 2, 3])}
   end
 
   def test_color_checks_rgba_input
-    assert_raise_message(ArgumentError, "Alpha channel 1.1 must be between 0 and 1") {Color.new([1, 2, 3, 1.1])}
-    assert_raise_message(ArgumentError, "Alpha channel -0.1 must be between 0 and 1") {Color.new([1, 2, 3, -0.1])}
+    assert_raise_message(ArgumentError, "Alpha channel 1.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, 1.1])}
+    assert_raise_message(ArgumentError, "Alpha channel -0.1 must be between 0 and 1") {Sass::Script::Value::Color.new([1, 2, 3, -0.1])}
   end
 
   def test_string_escapes
@@ -46,17 +46,19 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal "white", resolve("white")
     assert_equal "white", resolve("#ffffff")
     assert_equal "#fffffe", resolve("white - #000001")
+    assert_equal "transparent", resolve("transparent")
+    assert_equal "transparent", resolve("rgba(0, 0, 0, 0)")
   end
 
   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 Sass::Script::Value::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 Sass::Script::Value::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 Sass::Script::Value::Color.new([1, 2, 3]), eval("rgba(1, 2, 3, 1)")
+    assert_equal Sass::Script::Value::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
@@ -95,6 +97,7 @@ class SassScriptTest < Test::Unit::TestCase
     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)
+    assert_equal "transparent", resolve("rgba(0, 0, 0, 0)", :style => :compressed)
   end
 
   def test_compressed_comma
@@ -104,8 +107,8 @@ class SassScriptTest < Test::Unit::TestCase
   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::Value::String.new("foo"), eval("foo")
+    assert_equal Sass::Script::Value::String.new("foo/bar"), eval("foo/bar")
   end
 
   def test_basic_interpolation
@@ -134,6 +137,7 @@ class SassScriptTest < Test::Unit::TestCase
     assert_equal '3,7', resolve('#{1 + 2},#{3 + 4}')
     assert_equal '3, 7, 11', resolve('#{1 + 2}, #{3 + 4}, #{5 + 6}')
     assert_equal '3, 7, 11', resolve('3, #{3 + 4}, 11')
+    assert_equal '3, 7, 11', resolve('3, 7, #{5 + 6}')
 
     assert_equal '3 / 7', resolve('3 / #{3 + 4}')
     assert_equal '3 /7', resolve('3 /#{3 + 4}')
@@ -228,9 +232,9 @@ SASS
   end
 
   def test_dynamic_url
-    assert_equal "url(foo-bar)", resolve("url($foo)", {}, env('foo' => Sass::Script::String.new("foo-bar")))
-    assert_equal "url(foo-bar baz)", resolve("url($foo $bar)", {}, env('foo' => Sass::Script::String.new("foo-bar"), 'bar' => Sass::Script::String.new("baz")))
-    assert_equal "url(foo baz)", resolve("url(foo $bar)", {}, env('bar' => Sass::Script::String.new("baz")))
+    assert_equal "url(foo-bar)", resolve("url($foo)", {}, env('foo' => Sass::Script::Value::String.new("foo-bar")))
+    assert_equal "url(foo-bar baz)", resolve("url($foo $bar)", {}, env('foo' => Sass::Script::Value::String.new("foo-bar"), 'bar' => Sass::Script::Value::String.new("baz")))
+    assert_equal "url(foo baz)", resolve("url(foo $bar)", {}, env('bar' => Sass::Script::Value::String.new("baz")))
     assert_equal "url(foo bar)", resolve("url(foo    bar)")
   end
 
@@ -242,7 +246,7 @@ SASS
   end
 
   def test_hyphenated_variables
-    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::String.new("a-b"))))
+    assert_equal("a-b", resolve("$a-b", {}, env("a-b" => Sass::Script::Value::String.new("a-b"))))
   end
 
   def test_ruby_equality
@@ -372,7 +376,7 @@ SASS
 
   def test_equals
     assert_equal("true", resolve('"foo" == $foo', {},
-        env("foo" => Sass::Script::String.new("foo"))))
+        env("foo" => Sass::Script::Value::String.new("foo"))))
     assert_equal "true", resolve("1 == 1.0")
     assert_equal "true", resolve("false != true")
     assert_equal "false", resolve("1em == 1px")
@@ -488,6 +492,59 @@ SASS
     assert_equal "1 2 3", resolve("null 1 2 3")
   end
 
+  def test_map_can_have_trailing_comma
+    assert_equal("(foo: 1, bar: 2)", eval("(foo: 1, bar: 2,)").to_sass)
+  end
+
+  def test_list_can_have_trailing_comma
+    assert_equal("1, 2, 3", resolve("1, 2, 3,"))
+  end
+
+  def test_trailing_comma_defines_singleton_list
+    assert_equal("1 2 3", resolve("nth((1 2 3,), 1)"))
+  end
+
+  def test_map_cannot_have_duplicate_keys
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, foo: baz).') do
+      eval("(foo: bar, foo: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, fo + o: baz).') do
+      eval("(foo: bar, fo + o: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key "foo" in map (foo: bar, "foo": baz).') do
+      eval("(foo: bar, 'foo': baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key 2px in map (2px: bar, 1px + 1px: baz).') do
+      eval("(2px: bar, 1px + 1px: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Duplicate key #0000ff in map (blue: bar, blue: baz).') do
+      eval("(blue: bar, #00f: baz)")
+    end
+  end
+
+  def test_non_duplicate_map_keys
+    # These shouldn't throw errors
+    eval("(foo: foo, bar: bar)")
+    eval("(2px: foo, 2: bar)")
+    eval("(2px: foo, 2em: bar)")
+    eval("('2px': foo, 2px: bar)")
+  end
+
+  def test_map_syntax_errors
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo:": expected expression (e.g. 1px, bold), was ")"') do
+      eval("(foo:)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(": expected ")", was ":bar)"') do
+      eval("(:bar)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo, bar": expected ")", was ": baz)"') do
+      eval("(foo, bar: baz)")
+    end
+    assert_raise_message(Sass::SyntaxError, 'Invalid CSS after "(foo: bar, baz": expected ":", was ")"') do
+      eval("(foo: bar, baz)")
+    end
+  end
+
   def test_deep_argument_error_not_unwrapped
     # JRuby (as of 1.6.7.2) offers no way of distinguishing between
     # argument errors caused by programming errors in a function and
@@ -503,8 +560,128 @@ SASS
   end
 
   def test_boolean_ops_short_circuit
-    assert_equal "false", resolve("$ie and $ie <= 7", {}, env('ie' => Sass::Script::Bool.new(false)))
-    assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Bool.new(true)))
+    assert_equal "false", resolve("$ie and $ie <= 7", {}, env('ie' => Sass::Script::Value::Bool.new(false)))
+    assert_equal "true", resolve("$ie or $undef", {}, env('ie' => Sass::Script::Value::Bool.new(true)))
+  end
+
+  def test_selector
+    env = Sass::Environment.new
+    assert_equal "true", resolve("& == null", {}, env)
+
+    env.selector = selector('.foo.bar .baz.bang, .bip.bop')
+    assert_equal ".foo.bar .baz.bang, .bip.bop", resolve("&", {}, env)
+    assert_equal ".foo.bar .baz.bang", resolve("nth(&, 1)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(&, 2)", {}, env)
+    assert_equal ".foo.bar", resolve("nth(nth(&, 1), 1)", {}, env)
+    assert_equal ".baz.bang", resolve("nth(nth(&, 1), 2)", {}, env)
+    assert_equal ".bip.bop", resolve("nth(nth(&, 2), 1)", {}, env)
+    assert_equal "string", resolve("type-of(nth(nth(&, 1), 1))", {}, env)
+
+    env.selector = selector('.foo > .bar')
+    assert_equal ".foo > .bar", resolve("&", {}, env)
+    assert_equal ".foo > .bar", resolve("nth(&, 1)", {}, env)
+    assert_equal ".foo", resolve("nth(nth(&, 1), 1)", {}, env)
+    assert_equal ">", resolve("nth(nth(&, 1), 2)", {}, env)
+    assert_equal ".bar", resolve("nth(nth(&, 1), 3)", {}, env)
+  end
+
+  def test_setting_global_variable_locally_warns
+    assert_warning(<<WARNING) {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+DEPRECATION WARNING on line 4 of test_setting_global_variable_locally_warns_inline.scss:
+Assigning to global variable "$var" by default is deprecated.
+In future versions of Sass, this will create a new local variable.
+If you want to assign to the global variable, use "$var: x !global" instead.
+WARNING
+.foo {
+  a: x; }
+
+.bar {
+  b: x; }
+CSS
+$var: 1;
+
+.foo {
+  $var: x;
+  a: $var;
+}
+
+.bar {
+  b: $var;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_globally
+    assert_no_warning {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+.foo {
+  a: 1; }
+
+.bar {
+  b: 2; }
+CSS
+$var: 1;
+
+.foo {
+  a: $var;
+}
+
+$var: 2;
+
+.bar {
+  b: $var;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_with_flag
+    assert_no_warning {assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))}
+.bar {
+  a: x;
+  b: y;
+  c: z; }
+CSS
+$var1: 1;
+$var3: 3;
+
+.foo {
+  $var1: x !global;
+  $var2: y !global;
+  @each $var3 in _ {
+    $var3: z !global;
+  }
+}
+
+.bar {
+  a: $var1;
+  b: $var2;
+  c: $var3;
+}
+SCSS
+  end
+
+  def test_setting_global_variable_with_flag_and_default
+    assert_equal(<<CSS, render(<<SCSS, :syntax => :scss))
+.bar {
+  a: 1;
+  b: y;
+  c: z; }
+CSS
+$var1: 1;
+
+.foo {
+  $var1: x !global !default;
+  $var2: y !global !default;
+  @each $var3 in _ {
+    $var3: z !global !default;
+  }
+}
+
+.bar {
+  a: $var1;
+  b: $var2;
+  c: $var3;
+}
+SCSS
   end
 
   # Regression Tests
@@ -537,25 +714,48 @@ SASS
     assert_equal "and-bang", resolve("and-bang")
   end
 
+  def test_number_initialization
+    assert_equal Sass::Script::Value::Number.new(10, ["px"]), Sass::Script::Value::Number.new(10, "px")
+    assert_equal Sass::Script::Value::Number.new(10, ["px"], ["em"]), Sass::Script::Value::Number.new(10, "px", "em")
+  end
+
+  def test_is_unit
+    assert Sass::Script::Value::Number.new(10, "px").is_unit?("px")
+    assert Sass::Script::Value::Number.new(10).is_unit?(nil)
+    assert !Sass::Script::Value::Number.new(10, "px", "em").is_unit?("px")
+    assert !Sass::Script::Value::Number.new(10, [], "em").is_unit?("em")
+    assert !Sass::Script::Value::Number.new(10, ["px", "em"]).is_unit?("px")
+  end
+
+  def test_rename_redirect
+    assert_no_warning do
+      assert_equal Sass::Script::Value::Base, Sass::Script::Literal
+      assert_equal Sass::Script::Tree::Node, Sass::Script::Node
+      assert_equal Sass::Script::Tree::Operation, Sass::Script::Operation
+      assert_equal Sass::Script::Value::String, Sass::Script::String
+    end
+  end
+
   private
 
   def resolve(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)
-    val.is_a?(Sass::Script::String) ? val.value : val.to_s
+    assert_kind_of Sass::Script::Value::Base, val
+    val.is_a?(Sass::Script::Value::String) ? val.value : val.to_s
   end
 
   def assert_unquoted(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)
-    assert_kind_of Sass::Script::String, val
+    assert_kind_of Sass::Script::Value::String, val
     assert_equal :identifier, val.type
   end
 
   def assert_quoted(str, opts = {}, environment = env)
     munge_filename opts
     val = eval(str, opts, environment)
-    assert_kind_of Sass::Script::String, val
+    assert_kind_of Sass::Script::Value::String, val
     assert_equal :string, val.type
   end
 
@@ -577,6 +777,12 @@ SASS
     env
   end
 
+  def selector(str)
+    parser = Sass::SCSS::StaticParser.new(
+      str, filename_for_test, Sass::Importers::Filesystem.new('.'))
+    parser.parse_selector
+  end
+
   def test_number_printing
     assert_equal "1", eval("1")
     assert_equal "1", eval("1.0")
@@ -586,4 +792,8 @@ SASS
     assert_equal "-Infinity", eval("-1.0/0.0")
     assert_equal "NaN", eval("0.0/0.0")
   end
+
+  def test_null_is_a_singleton
+    assert_same Sass::Script::Value::Null.new, Sass::Script::Value::Null.new
+  end
 end