sass 3.1.0 → 3.3.0

data/test/sass/importer_test.rb

@@ -1,34 +1,57 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
 require File.dirname(__FILE__) + '/test_helper'
+require 'mock_importer'
+require 'sass/plugin'
 
 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, sourcemap_directory = nil)
+      "http://#{parse(name)}.example.com/style.scss"
+    end
+
+    private
+
+    def parse(name)
+      name[%r{fruits/(\w+)(\.s[ac]ss)?}, 1]
+    end
+  end
+
+  class NoPublicUrlImporter < FruitImporter
+    def public_url(name, sourcemap_directory = nil)
+      nil
+    end
+
+    private
+
+    def parse(name)
+      name[%r{ephemeral/(\w+)(\.s[ac]ss)?}, 1]
+    end
   end
 
   # This class proves that you can override the extension scheme for importers
@@ -38,6 +61,72 @@ class ImporterTest < Test::Unit::TestCase
     end
   end
 
+  # This importer maps one import to another import
+  # based on the mappings passed to importer's constructor.
+  class IndirectImporter < Sass::Importers::Base
+    def initialize(mappings, mtimes)
+      @mappings = mappings
+      @mtimes = mtimes
+    end
+    def find_relative(uri, base, options)
+      nil
+    end
+    def find(name, options)
+      if @mappings.has_key?(name)
+        Sass::Engine.new(
+          %Q[@import "#{@mappings[name]}";],
+          options.merge(
+            :filename => name,
+            :syntax => :scss,
+            :importer => self
+          )
+        )
+      end
+    end
+    def mtime(uri, options)
+      @mtimes.fetch(uri, @mtimes.has_key?(uri) ? Time.now : nil)
+    end
+    def key(uri, options)
+      [self.class.name, uri]
+    end
+    def to_s
+      "IndirectImporter(#{@mappings.keys.join(", ")})"
+    end
+  end
+
+  # This importer maps the import to single class
+  # based on the mappings passed to importer's constructor.
+  class ClassImporter < Sass::Importers::Base
+    def initialize(mappings, mtimes)
+      @mappings = mappings
+      @mtimes = mtimes
+    end
+    def find_relative(uri, base, options)
+      nil
+    end
+    def find(name, options)
+      if @mappings.has_key?(name)
+        Sass::Engine.new(
+          %Q[.#{name}{#{@mappings[name]}}],
+          options.merge(
+            :filename => name,
+            :syntax => :scss,
+            :importer => self
+          )
+        )
+      end
+    end
+    def mtime(uri, options)
+      @mtimes.fetch(uri, @mtimes.has_key?(uri) ? Time.now : nil)
+    end
+    def key(uri, options)
+      [self.class.name, uri]
+    end
+    def to_s
+      "ClassImporter(#{@mappings.keys.join(", ")})"
+    end
+  end
+
   def test_can_resolve_generated_imports
     scss_file = %Q{
       $pear-color: green;
@@ -79,4 +168,235 @@ CSS
   ensure
     FileUtils.rm_rf(absolutize("tmp"))
   end
+
+  def test_staleness_check_across_importers
+    file_system_importer = Sass::Importers::Filesystem.new(fixture_dir)
+    # Make sure the first import is older
+    indirect_importer = IndirectImporter.new({"apple" => "pear"}, {"apple" => Time.now - 1})
+    # Make css file is newer so the dependencies are the only way for the css file to be out of date.
+    FileUtils.touch(fixture_file("test_staleness_check_across_importers.css"))
+    # Make sure the first import is older
+    class_importer = ClassImporter.new({"pear" => %Q{color: green;}}, {"pear" => Time.now + 1})
+
+    options = {
+      :style => :compact,
+      :filename => fixture_file("test_staleness_check_across_importers.scss"),
+      :importer => file_system_importer,
+      :load_paths => [file_system_importer, indirect_importer, class_importer],
+      :syntax => :scss
+    }
+
+    assert_equal File.read(fixture_file("test_staleness_check_across_importers.css")),
+                 Sass::Engine.new(File.read(fixture_file("test_staleness_check_across_importers.scss")), options).render
+
+    checker = Sass::Plugin::StalenessChecker.new(options)
+
+    assert checker.stylesheet_needs_update?(
+      fixture_file("test_staleness_check_across_importers.css"),
+      fixture_file("test_staleness_check_across_importers.scss"),
+      file_system_importer
+    )
+  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"],
+"names": [],
+"file": "css_uri"
+}
+JSON
+  end
+
+  def test_source_map_with_only_css_uri_can_have_no_public_url_without_warning
+    ephemeral_importer = NoPublicUrlImporter.new
+    mock_importer = MockImporter.new
+    def mock_importer.public_url(name, sourcemap_directory = nil)
+      "css_uri"
+    end
+
+    options = {
+      :filename => filename_for_test,
+      :sourcemap_filename => sourcemap_filename_for_test,
+      :importer => mock_importer,
+      :syntax => :scss,
+      :load_paths => [ephemeral_importer],
+      :cache => false
+    }
+
+    engine = Sass::Engine.new(<<SCSS, options)
+@import "ephemeral/orange";
+.orange {
+  @include orange;
+}
+SCSS
+
+    assert_warning("") do
+      css_output, sourcemap = engine.render_with_sourcemap('sourcemap_uri')
+      assert_equal <<CSS.strip, css_output.strip
+.orange {
+  color: orange; }
+
+/*# sourceMappingURL=sourcemap_uri */
+CSS
+      map = sourcemap.to_json(:css_uri => 'css_uri')
+      assert_equal <<JSON.strip, map
+{
+"version": 3,
+"mappings": "AACA,OAAQ",
+"sources": ["css_uri"],
+"names": [],
+"file": "css_uri"
+}
+JSON
+    end
+  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),
+      :sourcemap_filename => sourcemap_filename_for_test,
+      :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.
+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),
+      :sourcemap_filename => sourcemap_filename_for_test,
+      :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.
+WARNING
+  end
+
+  def test_source_map_with_css_uri_and_sourcemap_path_supports_filesystem_importer
+    file_system_importer = Sass::Importers::Filesystem.new('.')
+    css_uri = 'css_uri'
+    sourcemap_path = 'map/style.map'
+    options = {
+      :filename => 'sass/style.scss',
+      :sourcemap_filename => sourcemap_path,
+      :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')
+    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"],
+"names": [],
+"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('.')
+    sass_path = 'sass/style.scss'
+    css_path = 'static/style.css'
+    sourcemap_path = 'map/style.map'
+    options = {
+      :filename => sass_path,
+      :sourcemap_filename => sourcemap_path,
+      :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')
+    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"],
+"names": [],
+"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
+
+  def fixture_file(path)
+    File.join(fixture_dir, path)
+  end
+
+  def test_absolute_files_across_template_locations
+    importer = Sass::Importers::Filesystem.new(absolutize 'templates')
+    assert_not_nil importer.mtime(absolutize('more_templates/more1.sass'), {})
+  end
 end

data/test/sass/logger_test.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'pathname'
+
+class LoggerTest < Test::Unit::TestCase
+
+  class InterceptedLogger < Sass::Logger::Base
+
+    attr_accessor :messages
+
+    def initialize(*args)
+      super
+      self.messages = []
+    end
+
+    def reset!
+      self.messages = []
+    end
+
+    def _log(*args)
+      messages << [args]
+    end
+
+  end
+
+  def test_global_sass_logger_instance_exists
+    assert Sass.logger.respond_to?(:warn)
+  end
+
+  def test_log_level_orders
+    logged_levels = {
+      :trace => [ [], [:trace, :debug, :info, :warn, :error]],
+      :debug => [ [:trace],   [:debug, :info, :warn, :error]],
+      :info  => [ [:trace, :debug],   [:info, :warn, :error]],
+      :warn  => [ [:trace, :debug, :info],   [:warn, :error]],
+      :error => [ [:trace, :debug, :info, :warn],   [:error]]
+    }
+    logged_levels.each do |level, (should_not_be_logged, should_be_logged)|
+      logger = Sass::Logger::Base.new(level)
+      should_not_be_logged.each do |should_level|
+        assert !logger.logging_level?(should_level)
+      end
+      should_be_logged.each do |should_level|
+        assert logger.logging_level?(should_level)
+      end
+    end
+  end
+
+  def test_logging_can_be_disabled
+    logger = InterceptedLogger.new
+    logger.error("message #1")
+    assert_equal 1, logger.messages.size
+    logger.reset!
+    logger.disabled = true
+    logger.error("message #2")
+    assert_equal 0, logger.messages.size
+  end
+end

data/test/sass/more_results/more_import.css

@@ -1,3 +1,5 @@
+@import url(basic.css);
+@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -22,8 +24,6 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
-@import url(basic.css);
-@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/plugin_test.rb

@@ -4,11 +4,24 @@ require File.dirname(__FILE__) + '/test_helper'
 require 'sass/plugin'
 require 'fileutils'
 
+module Sass::Script::Functions
+  def filename
+    filename = options[:filename].gsub(%r{.*((/[^/]+){4})}, '\1')
+    Sass::Script::Value::String.new(filename)
+  end
+
+  def whatever
+    custom = options[:custom]
+    whatever = custom && custom[:whatever]
+    Sass::Script::Value::String.new(whatever || "incorrect")
+  end
+end
+
 class SassPluginTest < Test::Unit::TestCase
   @@templates = %w{
     complex script parent_ref import scss_import alt
     subdir/subdir subdir/nested_subdir/nested_subdir
-    options
+    options import_content filename_fn
   }
   @@templates += %w[import_charset import_charset_ibm866] unless Sass::Util.ruby1_8?
   @@templates << 'import_charset_1_8' if Sass::Util.ruby1_8?
@@ -110,6 +123,61 @@ 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!
+    File.open(tempfile_loc('single_import_loop')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...2].join("\n"))
+/*
+Syntax error: An @import loop has been found: #{template_loc('single_import_loop')} imports itself
+CSS
+    end
+  end
+
+  def test_double_level_import_loop
+    File.delete(tempfile_loc('double_import_loop1'))
+    check_for_updates!
+    File.open(tempfile_loc('double_import_loop1')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...4].join("\n"))
+/*
+Syntax error: An @import loop has been found:
+                  #{template_loc('double_import_loop1')} imports #{template_loc('_double_import_loop2')}
+                  #{template_loc('_double_import_loop2')} imports #{template_loc('double_import_loop1')}
+CSS
+    end
+  end
+
+  def test_import_name_cleanup
+    File.delete(tempfile_loc('subdir/import_up1'))
+    check_for_updates!
+    File.open(tempfile_loc('subdir/import_up1')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...5].join("\n"))
+/*
+Syntax error: File to import not found or unreadable: ../subdir/import_up3.scss.
+              Load path: #{template_loc}
+        on line 1 of #{template_loc 'subdir/import_up2'}
+        from line 1 of #{template_loc 'subdir/import_up1'}
+CSS
+    end
+  end
+
   def test_nonfull_exception_handling
     old_full_exception = Sass::Plugin.options[:full_exception]
     Sass::Plugin.options[:full_exception] = false
@@ -179,42 +247,39 @@ CSS
     assert_needs_update "basic"
   end
 
-  # Callbacks
-
-  def test_updating_stylesheets_callback
-    # Should run even when there's nothing to update
-    assert_callback :updating_stylesheets, []
-  end
-
-  def test_updating_stylesheets_callback_with_individual_files
-    files = [[template_loc("basic"), tempfile_loc("basic")]]
-    assert_callback(:updating_stylesheets, files) {Sass::Util.silence_sass_warnings{Sass::Plugin.update_stylesheets(files)}}
+  def test_import_same_name
+    assert_warning <<WARNING do
+WARNING: In #{template_loc}:
+  There are multiple files that match the name "same_name_different_partiality.scss":
+    _same_name_different_partiality.scss
+    same_name_different_partiality.scss
+WARNING
+      touch "_same_name_different_partiality"
+      assert_needs_update "same_name_different_partiality"
+    end
   end
 
-  def test_updating_stylesheets_callback_with_never_update
-    Sass::Plugin.options[:never_update] = true
-    assert_no_callback :updating_stylesheets
-  end
+  # Callbacks
 
-  def test_updating_stylesheet_callback_for_updated_template
+  def test_updated_stylesheet_callback_for_updated_template
     Sass::Plugin.options[:always_update] = false
     touch 'basic'
-    assert_no_callback :updating_stylesheet, template_loc("complex"), tempfile_loc("complex") do
+    assert_no_callback :updated_stylesheet, template_loc("complex"), tempfile_loc("complex") do
       assert_callbacks(
-        [:updating_stylesheet, template_loc("basic"), tempfile_loc("basic")],
-        [:updating_stylesheet, template_loc("import"), tempfile_loc("import")])
+        [:updated_stylesheet, template_loc("basic"), tempfile_loc("basic")],
+        [:updated_stylesheet, template_loc("import"), tempfile_loc("import")])
     end
   end
 
-  def test_updating_stylesheet_callback_for_fresh_template
+  def test_updated_stylesheet_callback_for_fresh_template
     Sass::Plugin.options[:always_update] = false
-    assert_no_callback :updating_stylesheet
+    assert_no_callback :updated_stylesheet
   end
 
-  def test_updating_stylesheet_callback_for_error_template
+  def test_updated_stylesheet_callback_for_error_template
     Sass::Plugin.options[:always_update] = false
     touch 'bork1'
-    assert_no_callback :updating_stylesheet
+    assert_no_callback :updated_stylesheet
   end
 
   def test_not_updating_stylesheet_callback_for_fresh_template
@@ -226,8 +291,8 @@ CSS
     Sass::Plugin.options[:always_update] = false
     assert_callback :not_updating_stylesheet, template_loc("complex"), tempfile_loc("complex") do
       assert_no_callbacks(
-        [:updating_stylesheet, template_loc("basic"), tempfile_loc("basic")],
-        [:updating_stylesheet, template_loc("import"), tempfile_loc("import")])
+        [:updated_stylesheet, template_loc("basic"), tempfile_loc("basic")],
+        [:updated_stylesheet, template_loc("import"), tempfile_loc("import")])
     end
   end
 
@@ -301,7 +366,24 @@ CSS
     check_for_updates!
     assert_renders_correctly 'if'
   ensure
-    set_plugin_opts :cache_store => @@cache_store
+    set_plugin_opts
+  end
+
+  def test_cached_import_option
+    set_plugin_opts :custom => {:whatever => "correct"}
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+
+    @@cache_store.reset!
+    set_plugin_opts :custom => nil, :always_update => false
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+
+    set_plugin_opts :custom => {:whatever => "correct"}, :always_update => true
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+  ensure
+    set_plugin_opts :custom => nil
   end
 
  private
@@ -347,19 +429,21 @@ CSS
 
   def assert_callback(name, *expected_args)
     run = false
+    received_args = nil
     Sass::Plugin.send("on_#{name}") do |*args|
-      run ||= expected_args.zip(args).all? do |ea, a|
-        ea.respond_to?(:call) ? ea.call(a) : ea == a
+      received_args = args
+      run ||= expected_args.zip(received_args).all? do |ea, ra|
+        ea.respond_to?(:call) ? ea.call(ra) : ea == ra
       end
     end
 
     if block_given?
-      yield
+      Sass::Util.silence_sass_warnings {yield}
     else
       check_for_updates!
     end
 
-    assert run, "Expected #{name} callback to be run with arguments:\n  #{expected_args.inspect}"
+    assert run, "Expected #{name} callback to be run with arguments:\n  #{expected_args.inspect}\nHowever, it got:\n  #{received_args.inspect}"
   end
 
   def assert_no_callback(name, *unexpected_args)

data/test/sass/results/cached_import_option.css

@@ -0,0 +1,3 @@
+partial { value: correct; }
+
+main { value: correct; }

data/test/sass/results/filename_fn.css

@@ -0,0 +1,3 @@
+filename { imported: /test/sass/templates/_filename_fn_import.scss; }
+
+filename { local: /test/sass/templates/filename_fn.scss; local-mixin: /test/sass/templates/filename_fn.scss; local-function: /test/sass/templates/filename_fn.scss; imported-mixin: /test/sass/templates/_filename_fn_import.scss; imported-function: /test/sass/templates/_filename_fn_import.scss; }

data/test/sass/results/import.css

@@ -1,3 +1,5 @@
+@import url(basic.css);
+@import url(../results/complex.css);
 imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
 
 body { font: Arial; background: blue; }
@@ -24,8 +26,6 @@ body { font: Arial; background: blue; }
 #content.user.show #container.top #column.right { width: 600px; }
 #content.user.show #container.bottom { background: brown; }
 
-@import url(basic.css);
-@import url(../results/complex.css);
 #foo { background-color: #bbaaff; }
 
 nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }