haml-edge 3.1.73 → 3.1.74

data/test/sass/engine_test.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 # -*- coding: utf-8 -*-
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/engine'
 require 'stringio'
 
@@ -11,6 +12,7 @@ module Sass::Script::Functions::UserFunctions
 end
 
 class SassEngineTest < Test::Unit::TestCase
+  FAKE_FILE_NAME = __FILE__.gsub(/rb$/,"sass")
   # A map of erroneous Sass documents to the error messages they should produce.
   # The error messages may be arrays;
   # if so, the second element should be the line number that should be reported for the error.
@@ -61,9 +63,7 @@ MSG
     "$a: b\n  :c d\n" => "Illegal nesting: Nothing may be nested beneath variable declarations.",
     "@import foo.sass" => <<MSG,
 File to import not found or unreadable: foo.sass.
-Load paths:
-  #{File.dirname(__FILE__)}
-  .
+Load path: .
 MSG
     "@import templates/basic\n  foo" => "Illegal nesting: Nothing may be nested beneath import directives.",
     "foo\n  @import templates/basic" => "Import directives may only be used at the root of a document.",
@@ -144,6 +144,33 @@ MSG
     renders_correctly "nested", { :style => :nested }
     renders_correctly "compressed", { :style => :compressed }
   end
+
+  def test_compile
+    assert_equal "div { hello: world; }\n", Sass.compile("$who: world\ndiv\n  hello: $who", :syntax => :sass, :style => :compact)
+    assert_equal "div { hello: world; }\n", Sass.compile("$who: world; div { hello: $who }", :style => :compact)
+  end
+
+  def test_compile_file
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/test_compile_file.sass"), "w") {|f| f.write("$who: world\ndiv\n  hello: $who")}
+    open(absolutize("tmp/test_compile_file.scss"), "w") {|f| f.write("$who: world; div { hello: $who }")}
+    assert_equal "div { hello: world; }\n", Sass.compile_file(absolutize("tmp/test_compile_file.sass"), :style => :compact)
+    assert_equal "div { hello: world; }\n", Sass.compile_file(absolutize("tmp/test_compile_file.scss"), :style => :compact)
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
+
+  def test_compile_file_to_css_file
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/test_compile_file.sass"), "w") {|f| f.write("$who: world\ndiv\n  hello: $who")}
+    open(absolutize("tmp/test_compile_file.scss"), "w") {|f| f.write("$who: world; div { hello: $who }")}
+    Sass.compile_file(absolutize("tmp/test_compile_file.sass"), absolutize("tmp/test_compile_file_sass.css"), :style => :compact)
+    Sass.compile_file(absolutize("tmp/test_compile_file.scss"), absolutize("tmp/test_compile_file_scss.css"), :style => :compact)
+    assert_equal "div { hello: world; }\n", File.read(absolutize("tmp/test_compile_file_sass.css"))
+    assert_equal "div { hello: world; }\n", File.read(absolutize("tmp/test_compile_file_scss.css"))
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
   
   def test_flexible_tabulation
     assert_equal("p {\n  a: b; }\n  p q {\n    c: d; }\n",
@@ -156,14 +183,14 @@ MSG
     define_method("test_exception (#{key.inspect})") do
       line = 10
       begin
-        silence_warnings {Sass::Engine.new(key, :filename => __FILE__, :line => line).render}
+        silence_warnings {Sass::Engine.new(key, :filename => FAKE_FILE_NAME, :line => line).render}
       rescue Sass::SyntaxError => err
         value = [value] unless value.is_a?(Array)
 
         assert_equal(value.first.rstrip, err.message, "Line: #{key}")
-        assert_equal(__FILE__, err.sass_filename)
+        assert_equal(FAKE_FILE_NAME, err.sass_filename)
         assert_equal((value[1] || key.split("\n").length) + line - 1, err.sass_line, "Line: #{key}")
-        assert_match(/#{Regexp.escape(__FILE__)}:[0-9]+/, err.backtrace[0], "Line: #{key}")
+        assert_match(/#{Regexp.escape(FAKE_FILE_NAME)}:[0-9]+/, err.backtrace[0], "Line: #{key}")
       else
         assert(false, "Exception not raised for\n#{key}")
       end
@@ -196,9 +223,9 @@ rule
   :broken
 SASS
     begin
-      Sass::Engine.new(to_render, :filename => __FILE__, :line => (__LINE__-7)).render
+      Sass::Engine.new(to_render, :filename => FAKE_FILE_NAME, :line => (__LINE__-7)).render
     rescue Sass::SyntaxError => err
-      assert_equal(__FILE__, err.sass_filename)
+      assert_equal(FAKE_FILE_NAME, err.sass_filename)
       assert_equal((__LINE__-6), err.sass_line)
     else
       assert(false, "Exception not raised for '#{to_render}'!")
@@ -500,17 +527,17 @@ CSS
   end
 
   def test_sass_import
-    assert !File.exists?(sassc_path("importee"))
+    sassc_file = sassc_path("importee")
+    assert !File.exists?(sassc_file)
     renders_correctly "import", { :style => :compact, :load_paths => [File.dirname(__FILE__) + "/templates"] }
-    assert File.exists?(sassc_path("importee"))
+    assert File.exists?(sassc_file)
   end
 
   def test_nonexistent_extensionless_import
-    assert_warning(<<WARN) do
-WARNING: Neither nonexistent.sass nor .scss found. Using nonexistent.css instead.
-This behavior is deprecated and will be removed in a future version.
-If you really need nonexistent.css, import it explicitly.
-WARN
+    assert_raise_message(Sass::SyntaxError, <<ERR.rstrip) do
+File to import not found or unreadable: nonexistent.
+Load path: .
+ERR
       assert_equal("@import url(nonexistent.css);\n", render("@import nonexistent"))
     end
   end
@@ -2204,6 +2231,7 @@ SASS
     sass_file  = load_file(name, "sass")
     css_file   = load_file(name, "css")
     options[:filename] ||= filename(name, "sass")
+    options[:syntax] ||= :sass
     options[:css_filename] ||= filename(name, "css")
     css_result = Sass::Engine.new(sass_file, options).render
     assert_equal css_file, css_result
@@ -2221,7 +2249,10 @@ SASS
 
   def sassc_path(template)
     sassc_path = File.join(File.dirname(__FILE__) + "/templates/#{template}.sass")
-    Sass::Files.send(:sassc_filename, sassc_path, Sass::Engine::DEFAULT_OPTIONS)
+    engine = Sass::Engine.new("", :filename => sassc_path,
+      :importer => Sass::Importers::Filesystem.new("."))
+    key = engine.send(:sassc_key)
+    File.join(engine.options[:cache_location], key)
   end
 end
  

data/test/sass/importer_test.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+
+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)
+      end
+    end
+
+    def key(name, context)
+      [self.class.name, name]
+    end
+  end
+
+  # This class proves that you can override the extension scheme for importers
+  class ReversedExtImporter < Sass::Importers::Filesystem
+    def extensions
+      {"sscs" => :scss, "ssas" => :sass}
+    end
+  end
+
+  def test_can_resolve_generated_imports
+    scss_file = %Q{
+      $pear-color: green;
+      @import "fruits/apple"; @import "fruits/orange"; @import "fruits/pear";
+      .apple { @include apple; }
+      .orange { @include orange; }
+      .pear { @include pear; }
+    }
+    css_file = <<CSS
+.apple { color: red; }
+
+.orange { color: orange; }
+
+.pear { color: green; }
+CSS
+    options = {:style => :compact, :load_paths => [FruitImporter.new], :syntax => :scss}
+    assert_equal css_file, Sass::Engine.new(scss_file, options).render
+  end
+
+  def test_extension_overrides
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/foo.ssas"), "w") {|f| f.write(".foo\n  reversed: true\n")}
+    open(absolutize("tmp/bar.sscs"), "w") {|f| f.write(".bar {reversed: true}\n")}
+    scss_file = %Q{
+      @import "foo", "bar";
+      @import "foo.ssas", "bar.sscs";
+    }
+    css_file = <<CSS
+.foo { reversed: true; }
+
+.bar { reversed: true; }
+
+.foo { reversed: true; }
+
+.bar { reversed: true; }
+CSS
+    options = {:style => :compact, :load_paths => [ReversedExtImporter.new(absolutize("tmp"))], :syntax => :scss}
+    assert_equal css_file, Sass::Engine.new(scss_file, options).render
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
+end

data/test/sass/plugin_test.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
 require 'sass/plugin'
 require 'fileutils'
 
@@ -10,9 +11,11 @@ class SassPluginTest < Test::Unit::TestCase
     options
   }
 
+  @@cache_store = Sass::InMemoryCacheStore.new
+
   def setup
-    FileUtils.mkdir tempfile_loc
-    FileUtils.mkdir tempfile_loc(nil,"more_")
+    FileUtils.mkdir_p tempfile_loc
+    FileUtils.mkdir_p tempfile_loc(nil,"more_")
     set_plugin_opts
     update_all_stylesheets!
     reset_mtimes
@@ -20,7 +23,7 @@ class SassPluginTest < Test::Unit::TestCase
 
   def teardown
     clean_up_sassc
-    clear_callbacks
+    Sass::Plugin.reset!
     FileUtils.rm_r tempfile_loc
     FileUtils.rm_r tempfile_loc(nil,"more_")
   end
@@ -250,7 +253,7 @@ CSS
 
   def test_cached_dependencies_update
     FileUtils.mv(template_loc("basic"), template_loc("basic", "more_"))
-    set_plugin_opts :load_paths => [result_loc, template_loc(nil, "more_")]
+    set_plugin_opts :load_paths => [template_loc(nil, "more_")]
 
     touch 'basic', 'more_'
     assert_needs_update "import"
@@ -260,6 +263,15 @@ CSS
     FileUtils.mv(template_loc("basic", "more_"), template_loc("basic"))
   end
 
+  def test_cached_relative_import
+    old_always_update = Sass::Plugin.options[:always_update]
+    Sass::Plugin.options[:always_update] = true
+    update_all_stylesheets!
+    assert_renders_correctly('subdir/subdir')
+  ensure
+    Sass::Plugin.options[:always_update] = old_always_update
+  end
+
  private
 
   def assert_renders_correctly(*arguments)
@@ -342,10 +354,6 @@ CSS
     assert_no_callback(*args.pop) {assert_no_callbacks(*args)}
   end
 
-  def clear_callbacks
-    Sass::Plugin.instance_variable_set('@_sass_callbacks', {})
-  end
-
   def update_all_stylesheets!
     Haml::Util.silence_haml_warnings do
       Sass::Plugin.update_stylesheets
@@ -398,19 +406,17 @@ CSS
     end
   end
 
-  def absolutize(file)
-    "#{File.dirname(__FILE__)}/#{file}"
-  end
-
   def set_plugin_opts(overrides = {})
-    Sass::Plugin.options = {
+    Sass::Plugin.options.merge!(
       :template_location => template_loc,
       :css_location => tempfile_loc,
       :style => :compact,
-      :load_paths => [result_loc],
       :always_update => true,
       :never_update => false,
-    }.merge(overrides)
+      :full_exception => true,
+      :cache_store => @@cache_store
+    )
+    Sass::Plugin.options.merge!(overrides)
   end
 end
 

data/test/sass/test_helper.rb

@@ -0,0 +1,5 @@
+class Test::Unit::TestCase
+  def absolutize(file)
+    "#{File.dirname(__FILE__)}/#{file}"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: haml-edge
 version: !ruby/object:Gem::Version 
-  version: 3.1.73
+  version: 3.1.74
 platform: ruby
 authors: 
 - Nathan Weizenbaum
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-06 00:00:00 -04:00
+date: 2010-09-13 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,7 +77,6 @@ files:
 - lib/sass/engine.rb
 - lib/sass/environment.rb
 - lib/sass/error.rb
-- lib/sass/files.rb
 - lib/sass/less.rb
 - lib/sass/plugin.rb
 - lib/sass/plugin/configuration.rb
@@ -86,6 +85,7 @@ files:
 - lib/sass/plugin/rack.rb
 - lib/sass/plugin/rails.rb
 - lib/sass/plugin/staleness_checker.rb
+- lib/sass/plugin/compiler.rb
 - lib/sass/repl.rb
 - lib/sass/script.rb
 - lib/sass/script/bool.rb
@@ -135,6 +135,10 @@ files:
 - lib/sass/tree/variable_node.rb
 - lib/sass/tree/warn_node.rb
 - lib/sass/tree/while_node.rb
+- lib/sass/cache_store.rb
+- lib/sass/importers.rb
+- lib/sass/importers/base.rb
+- lib/sass/importers/filesystem.rb
 - vendor/fssm/LICENSE
 - vendor/fssm/README.markdown
 - vendor/fssm/Rakefile
@@ -316,6 +320,9 @@ files:
 - test/sass/templates/units.sass
 - test/sass/templates/warn.sass
 - test/sass/templates/warn_imported.sass
+- test/sass/cache_test.rb
+- test/sass/importer_test.rb
+- test/sass/test_helper.rb
 - test/test_helper.rb
 - extra/haml-mode.el
 - extra/sass-mode.el
@@ -380,3 +387,5 @@ test_files:
 - test/sass/scss/css_test.rb
 - test/sass/scss/rx_test.rb
 - test/sass/scss/scss_test.rb
+- test/sass/cache_test.rb
+- test/sass/importer_test.rb

data/lib/sass/files.rb

@@ -1,160 +0,0 @@
-require 'digest/sha1'
-require 'pathname'
-require 'fileutils'
-
-module Sass
-  # This module contains various bits of functionality
-  # related to finding and caching Sass files.
-  module Files
-    extend self
-
-    # Returns the {Sass::Tree} for the given file,
-    # reading it from the Sass cache if possible.
-    #
-    # @param filename [String] The path to the Sass or SCSS file
-    # @param options [{Symbol => Object}] The options hash.
-    #   Only the {file:SASS_REFERENCE.md#cache-option `:cache_location`} option is used
-    # @raise [Sass::SyntaxError] if there's an error in the document.
-    #   The caller has responsibility for setting backtrace information, if necessary
-    def tree_for(filename, options)
-      default_options = Sass::Engine::DEFAULT_OPTIONS.dup
-      default_options.delete(:syntax)
-      options = default_options.merge!(options)
-      text = File.read(filename)
-
-      if options[:cache] || options[:read_cache]
-        compiled_filename = sassc_filename(filename, options)
-        sha = Digest::SHA1.hexdigest(text)
-
-        if root = try_to_read_sassc(filename, compiled_filename, sha)
-          root.options = options.merge(:filename => filename)
-          return root
-        end
-      end
-
-      options = options.merge(:filename => filename)
-      if filename =~ /\.scss$/
-        options = {:syntax => :scss}.merge(options)
-      elsif filename =~ /\.sass$/
-        options = {:syntax => :sass}.merge(options)
-      end
-
-      engine = Sass::Engine.new(text, options)
-
-      root = engine.to_tree
-      try_to_write_sassc(root, compiled_filename, sha, options) if options[:cache]
-      root
-    end
-
-    # Find the full filename of a Sass, SCSS, or CSS file to import.
-    # This follows Sass's import rules:
-    # if the filename given ends in `".sass"`, `".scss"`, or `".css"`,
-    # it will try to find that type of file;
-    # otherwise, it will try to find the corresponding Sass/SCSS file
-    # and fall back on CSS if it's not available.
-    #
-    # Any Sass/SCSS filename returned will correspond to
-    # an actual file of the corresponding type on the filesystem.
-    # CSS filenames, however, may not;
-    # they're expected to be put through directly to the stylesheet
-    # as CSS `@import` statements.
-    #
-    # @param filename [String] The filename to search for
-    # @param load_paths [Array<String>] The set of filesystem paths
-    #   to search for Sass/SCSS files.
-    # @return [String] The filename of the imported file.
-    #   This is an absolute path if the file is a `".sass"` or `".scss"` file.
-    # @raise [Sass::SyntaxError] if `filename` ends in `".sass"` or `".scss"`
-    #   and no corresponding Sass/SCSS file could be found.
-    def find_file_to_import(filename, load_paths)
-      was_sass = was_scss = false
-      original_filename = filename
-
-      if [".sass", ".scss"].include?(filename[-5..-1])
-        was_sass = filename[-5..-1] == ".sass"
-        was_scss = filename[-5..-1] == ".scss"
-        filename = filename[0...-5]
-      elsif filename[-4..-1] == ".css"
-        return filename
-      end
-
-      new_filename = nil
-      load_paths = load_paths.uniq
-      load_paths.each do |load_path|
-        new_filename ||= find_full_path("#{filename}.sass", load_path) unless was_scss
-        new_filename ||= find_full_path("#{filename}.scss", load_path) unless was_sass
-      end
-
-      return new_filename if new_filename
-      unless was_sass || was_scss
-        Haml::Util.haml_warn <<END
-WARNING: Neither #{filename}.sass nor .scss found. Using #{filename}.css instead.
-This behavior is deprecated and will be removed in a future version.
-If you really need #{filename}.css, import it explicitly.
-END
-        return filename + '.css'
-      end
-
-      message = "File to import not found or unreadable: #{original_filename}.\n"
-      if load_paths.size == 1
-        message << "Load path: #{load_paths.first}"
-      else
-        message << "Load paths:\n  " << load_paths.join("\n  ")
-      end
-
-      raise SyntaxError.new(message)
-    end
-
-    private
-
-    def sassc_filename(filename, options)
-      File.join(options[:cache_location],
-        Digest::SHA1.hexdigest(File.dirname(File.expand_path(filename))),
-        File.basename(filename) + 'c')
-    end
-
-    def try_to_read_sassc(filename, compiled_filename, sha)
-      return unless File.readable?(compiled_filename)
-
-      File.open(compiled_filename, "rb") do |f|
-        return unless f.readline("\n").strip == Sass::VERSION
-        return unless f.readline("\n").strip == sha
-        return Marshal.load(f.read)
-      end
-    rescue EOFError, TypeError, ArgumentError => e
-      Haml::Util.haml_warn "Warning. Error encountered while reading cache #{compiled_filename}: #{e}"
-    end
-
-    def try_to_write_sassc(root, compiled_filename, sha, options)
-      return unless File.writable?(File.dirname(options[:cache_location]))
-      return if File.exists?(options[:cache_location]) && !File.writable?(options[:cache_location])
-      return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
-      return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
-      FileUtils.mkdir_p(File.dirname(compiled_filename))
-      File.open(compiled_filename, "wb") do |f|
-        f.write(Sass::VERSION)
-        f.write("\n")
-        f.write(sha)
-        f.write("\n")
-        f.write(Marshal.dump(root))
-      end
-    end
-
-    def find_full_path(filename, load_path)
-      partial_name = File.join(File.dirname(filename), "_#{File.basename(filename)}")
-
-      if Pathname.new(filename).absolute?
-        [partial_name, filename].each do |name|
-          return name if File.readable?(name)
-        end
-        return nil
-      end
-
-      [partial_name, filename].each do |name|
-        full_path = File.join(load_path, name)
-        return full_path if File.readable?(full_path)
-      end
-      nil
-    end
-  end
-end