haml-edge 3.1.73 → 3.1.74

data/lib/sass/plugin.rb

@@ -1,12 +1,11 @@
 require 'fileutils'
 
 require 'sass'
-require 'sass/plugin/configuration'
-require 'sass/plugin/staleness_checker'
+require 'sass/plugin/compiler'
 
 module Sass
-  # This module handles the compilation of Sass/SCSS files.
-  # It provides global options and checks whether CSS files
+  # This module provides a single interface to the compilation of Sass/SCSS files
+  # for an application. It provides global options and checks whether CSS files
   # need to be updated.
   #
   # This module is used as the primary interface with Sass
@@ -20,6 +19,9 @@ module Sass
   # All callback methods are of the form `on_#{name}`,
   # and they all take a block that's called when the given action occurs.
   #
+  # Note that this class proxies almost all methods to its {Sass::Plugin::Compiler} instance.
+  # See \{#compiler}.
+  #
   # @example Using a callback
   #   Sass::Plugin.on_updating_stylesheet do |template, css|
   #     puts "Compiling #{template} to #{css}"
@@ -28,8 +30,9 @@ module Sass
   #     #=> Compiling app/sass/screen.scss to public/stylesheets/screen.css
   #     #=> Compiling app/sass/print.scss to public/stylesheets/print.css
   #     #=> Compiling app/sass/ie.scss to public/stylesheets/ie.css
+  # @see Sass::Plugin::Compiler
   module Plugin
-    include Haml::Util
+    extend self
 
     @checked_for_updates = false
 
@@ -50,6 +53,15 @@ module Sass
       update_stylesheets
     end
 
+    # Returns the singleton compiler instance.
+    # This compiler has been pre-configured according
+    # to the plugin configuration.
+    #
+    # @return [Sass::Plugin::Compiler]
+    def compiler
+      @compiler ||= Compiler.new
+    end
+
     # Updates out-of-date stylesheets.
     #
     # Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
@@ -65,29 +77,7 @@ module Sass
     #   the second is the location of the CSS file that it should be compiled to.
     def update_stylesheets(individual_files = [])
       return if options[:never_update]
-
-      run_updating_stylesheets individual_files
-
-      individual_files.each {|t, c| update_stylesheet(t, c)}
-
-      @checked_for_updates = true
-      staleness_checker = StalenessChecker.new
-
-      template_location_array.each do |template_location, css_location|
-
-        Dir.glob(File.join(template_location, "**", "*.s[ca]ss")).sort.each do |file|
-          # Get the relative path to the file
-          name = file.sub(template_location.sub(/\/*$/, '/'), "")
-          css = css_filename(name, css_location)
-
-          next if forbid_update?(name)
-          if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
-            update_stylesheet file, css
-          else
-            run_not_updating_stylesheet file, css
-          end
-        end
-      end
+      compiler.update_stylesheets(individual_files)
     end
 
     # Updates all stylesheets, even those that aren't out-of-date.
@@ -111,156 +101,18 @@ module Sass
       self.options = old_options
     end
 
-    # Watches the template directory (or directories)
-    # and updates the CSS files whenever the related Sass/SCSS files change.
-    # `watch` never returns.
-    #
-    # Whenever a change is detected to a Sass/SCSS file in
-    # {file:SASS_REFERENCE.md#template_location-option `:template_location`},
-    # the corresponding CSS file in {file:SASS_REFERENCE.md#css_location-option `:css_location`}
-    # will be recompiled.
-    # The CSS files of any Sass/SCSS files that import the changed file will also be recompiled.
-    #
-    # Before the watching starts in earnest, `watch` calls \{#update\_stylesheets}.
+    # All other method invocations are proxied to the \{#compiler}.
     #
-    # Note that `watch` uses the [FSSM](http://github.com/ttilley/fssm) library
-    # to monitor the filesystem for changes.
-    # FSSM isn't loaded until `watch` is run.
-    # The version of FSSM distributed with Sass is loaded by default,
-    # but if another version has already been loaded that will be used instead.
-    #
-    # @param individual_files [Array<(String, String)>]
-    #   A list of files to watch for updates
-    #   **in addition to those specified by the
-    #   {file:SASS_REFERENCE.md#template_location-option `:template_location` option}.**
-    #   The first string in each pair is the location of the Sass/SCSS file,
-    #   the second is the location of the CSS file that it should be compiled to.
-    def watch(individual_files = [])
-      update_stylesheets(individual_files)
-
-      begin
-        require 'fssm'
-      rescue LoadError => e
-        e.message << "\n" <<
-          if File.exists?(scope(".git"))
-            'Run "git submodule update --init" to get the recommended version.'
-          else
-            'Run "gem install fssm" to get it.'
-          end
-        raise e
-      end
-
-      unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
-        # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
-        # but it also isn't smart enough to switch to polling itself.
-        require 'fssm/backends/polling'
-        Haml::Util.silence_warnings do
-          FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
-        end
-      end
-
-      # TODO: Keep better track of what depends on what
-      # so we don't have to run a global update every time anything changes.
-      FSSM.monitor do |mon|
-        template_location_array.each do |template_location, css_location|
-          mon.path template_location do |path|
-            path.glob '**/*.s[ac]ss'
-
-            path.update do |base, relative|
-              run_template_modified File.join(base, relative)
-              update_stylesheets(individual_files)
-            end
-
-            path.create do |base, relative|
-              run_template_created File.join(base, relative)
-              update_stylesheets(individual_files)
-            end
-
-            path.delete do |base, relative|
-              run_template_deleted File.join(base, relative)
-              css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
-              try_delete_css css
-              update_stylesheets(individual_files)
-            end
-          end
-        end
-
-        individual_files.each do |template, css|
-          mon.file template do |path|
-            path.update do
-              run_template_modified template
-              update_stylesheets(individual_files)
-            end
-
-            path.create do
-              run_template_created template
-              update_stylesheets(individual_files)
-            end
-
-            path.delete do
-              run_template_deleted template
-              try_delete_css css
-              update_stylesheets(individual_files)
-            end
-          end
-        end
-      end
-    end
-
-    private
-
-    def update_stylesheet(filename, css)
-      dir = File.dirname(css)
-      unless File.exists?(dir)
-        run_creating_directory dir
-        FileUtils.mkdir_p dir
-      end
-
-      begin
-        result = Sass::Files.tree_for(filename, engine_options(:css_filename => css, :filename => filename)).render
-      rescue Exception => e
-        run_compilation_error e, filename, css
-        result = Sass::SyntaxError.exception_to_css(e, options)
+    # @see #compiler
+    # @see Sass::Plugin::Compiler
+    def method_missing(method, *args, &block)
+      if compiler.respond_to?(method)
+        compiler.send(method, *args, &block)
       else
-        run_updating_stylesheet filename, css
+        super
       end
-
-      # Finally, write the file
-      flag = 'w'
-      flag = 'wb' if Haml::Util.windows? && options[:unix_newlines]
-      File.open(css, flag) {|file| file.print(result)}
     end
 
-    def try_delete_css(css)
-      return unless File.exists?(css)
-      run_deleting_css css
-      File.delete css
-    end
-
-    def load_paths(opts = options)
-      (opts[:load_paths] || []) + template_locations
-    end
-
-    def template_locations
-      template_location_array.to_a.map {|l| l.first}
-    end
-
-    def css_locations
-      template_location_array.to_a.map {|l| l.last}
-    end
-
-    def css_filename(name, path)
-      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
-    end
-
-    def forbid_update?(name)
-      name.sub(/^.*\//, '')[0] == ?_
-    end
-
-    # Compass expects this to exist
-    def stylesheet_needs_update?(css_file, template_file)
-      StalenessChecker.stylesheet_needs_update?(css_file, template_file)
-    end
   end
 end
 

data/lib/sass/script/node.rb

@@ -68,14 +68,14 @@ module Sass::Script
     #
     # @return [Array<Node>]
     def children
-      raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #children.")
+      Haml::Util.abstract(self)
     end
 
     # Returns the text of this SassScript expression.
     #
     # @return [String]
     def to_sass(opts = {})
-      raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #to_sass.")
+      Haml::Util.abstract(self)
     end
 
     protected
@@ -95,7 +95,7 @@ module Sass::Script
     # @return [Literal] The SassScript object that is the value of the SassScript
     # @see #perform
     def _perform(environment)
-      raise NotImplementedError.new("All subclasses of Sass::Script::Node must override #_perform.")
+      Haml::Util.abstract(self)
     end
   end
 end

data/lib/sass/selector/simple.rb

@@ -22,7 +22,7 @@ module Sass
       #
       # @return [Array<String, Sass::Script::Node>]
       def to_a
-        raise NotImplementedError.new("All subclasses of Sass::Selector::Simple must override #to_a.")
+        Haml::Util.abstract(self)
       end
 
       # Returns a string representation of the node.

data/lib/sass/tree/import_node.rb

@@ -17,15 +17,12 @@ module Sass
 
       def invisible?; to_s.empty?; end
 
-      # Returns the resolved name of the imported file,
-      # as returned by \{Sass::Files#find\_file\_to\_import}.
+      # Returns the imported file.
       #
-      # @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 file could be found.
-      def full_filename
-        @full_filename ||= import
+      # @return [Sass::Engine]
+      # @raise [Sass::SyntaxError] If no file could be found to import.
+      def imported_file
+        @imported_file ||= import
       end
 
       # @see Node#to_sass
@@ -43,6 +40,17 @@ module Sass
         super.first
       end
 
+      # Returns whether or not this import should emit a CSS @import declaration
+      #
+      # @return [Boolean] Whether or not this is a simple CSS @import declaration.
+      def css_import?
+        if @imported_filename =~ /\.css$/
+          @imported_filename
+        elsif imported_file.is_a?(String) && imported_file =~ /\.css$/
+          imported_file
+        end
+      end
+
       protected
 
       # @see Node#_cssize
@@ -60,7 +68,9 @@ module Sass
       # @param environment [Sass::Environment] The lexical environment containing
       #   variable and mixin values
       def _perform(environment)
-        return DirectiveNode.new("@import url(#{full_filename})") if full_filename =~ /\.css$/
+        if path = css_import?
+          return DirectiveNode.new("@import url(#{path})")
+        end
         super
       end
 
@@ -70,14 +80,12 @@ module Sass
       #   variable and mixin values
       def perform!(environment)
         environment.push_frame(:filename => @filename, :line => @line)
-        options = @options.dup
-        options.delete(:syntax)
-        root = Sass::Files.tree_for(full_filename, options)
-        @template = root.template
+        # TODO: re-enable caching
+        root = imported_file.to_tree
         self.children = root.children
         self.children = perform_children(environment)
       rescue Sass::SyntaxError => e
-        e.modify_backtrace(:filename => full_filename)
+        e.modify_backtrace(:filename => imported_file.options[:filename])
         e.add_backtrace(:filename => @filename, :line => @line)
         raise e
       ensure
@@ -86,15 +94,29 @@ module Sass
 
       private
 
-      def import_paths
-        paths = (@options[:load_paths] || []).dup
-        paths.unshift(File.dirname(@options[:filename])) if @options[:filename]
-        paths
-      end
-
       def import
-        Sass::Files.find_file_to_import(@imported_filename, import_paths)
-      rescue Exception => e
+        paths = @options[:load_paths]
+
+        if @options[:importer]
+          f = @options[:importer].find_relative(
+            @imported_filename, @options[:filename], @options.dup)
+          return f if f
+        end
+
+        paths.each do |p|
+          if f = p.find(@imported_filename, @options.dup)
+            return f
+          end
+        end
+
+        message = "File to import not found or unreadable: #{@imported_filename}.\n"
+        if paths.size == 1
+          message << "Load path: #{paths.first}"
+        else
+          message << "Load paths:\n  " << paths.join("\n  ")
+        end
+        raise SyntaxError.new(message)
+      rescue SyntaxError => e
         raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
       end
     end

data/lib/sass/tree/node.rb

@@ -244,6 +244,21 @@ module Sass
         to_src(tabs, opts, :scss)
       end
 
+      # Names of options that are saved when the node is serialized and cached.
+      SAVED_OPTIONS = [:importer]
+
+      # Ensures that only {SAVED_OPTIONS} get saved.
+      def _around_dump
+        old_options = @options
+        @options = {}
+        SAVED_OPTIONS.each do |opt|
+          @options[opt] = old_options[opt]
+        end
+        yield
+      ensure
+        options = old_options
+      end
+
       protected
 
       # Computes the CSS corresponding to this particular Sass node.
@@ -258,7 +273,7 @@ module Sass
       # @see #to_s
       # @see Sass::Tree
       def _to_s
-        raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #_to_s or #to_s.")
+        Haml::Util.abstract(self)
       end
 
       # Converts this static Sass node into a static CSS node,
@@ -383,7 +398,7 @@ module Sass
       # @param fmt [Symbol] `:sass` or `:scss`
       # @return [String] The Sass or SCSS code corresponding to the node
       def to_src(tabs, opts, fmt)
-        raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #to_#{fmt}.")
+        Haml::Util.abstract(self)
       end
 
       # Converts the children of this node to a Sass or SCSS string.

data/lib/sass.rb

@@ -18,6 +18,49 @@ module Sass
   # A more fine-grained representation is available from {Haml::Version#version Sass.version}.
   # @api public
   VERSION = version[:string] unless defined?(Sass::VERSION)
+
+  # Compile a Sass or SCSS string to CSS.
+  # Defaults to SCSS.
+  #
+  # @param contents [String] The contents of the Sass file.
+  # @param options [{Symbol => Object}] An options hash;
+  #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+  # @raise [Sass::SyntaxError] if there's an error in the document
+  # @raise [Encoding::UndefinedConversionError] if the source encoding
+  #   cannot be converted to UTF-8
+  # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
+  def self.compile(contents, options = {})
+    options[:syntax] ||= :scss
+    Engine.new(contents, options).to_css
+  end
+
+  # Compile a file on disk to CSS.
+  #
+  # @param filename [String] The path to the Sass, SCSS, or CSS file on disk.
+  # @param options [{Symbol => Object}] An options hash;
+  #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+  # @raise [Sass::SyntaxError] if there's an error in the document
+  # @raise [Encoding::UndefinedConversionError] if the source encoding
+  #   cannot be converted to UTF-8
+  # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
+  #
+  # @overload compile_file(filename, options = {})
+  #   @return [String] The compiled CSS.
+  #
+  # @overload compile_file(filename, css_filename, options = {})
+  #   @param css_filename [String] The location to which to write the compiled CSS.
+  def self.compile_file(filename, *args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    css_filename ||= args.shift
+    options[:css_filename] = css_filename
+    result = Sass::Files.engine_for(filename, options).render
+    if css_filename
+      open(css_filename,"w") {|css_file| css_file.write(result) }
+      nil
+    else
+      result
+    end
+  end
 end
 
 require 'haml/util'

data/test/haml/util_test.rb

@@ -5,6 +5,19 @@ require 'pathname'
 class UtilTest < Test::Unit::TestCase
   include Haml::Util
 
+  class Dumpable
+    attr_reader :arr
+    def initialize; @arr = []; end
+    def _before_dump; @arr << :before; end
+    def _after_dump; @arr << :after; end
+    def _around_dump
+      @arr << :around_before
+      yield
+      @arr << :around_after
+    end
+    def _after_load; @arr << :loaded; end
+  end
+
   def test_scope
     assert(File.exist?(scope("Rakefile")))
   end
@@ -240,6 +253,25 @@ class UtilTest < Test::Unit::TestCase
     assert(!version_gt(v2, v1), "Expected #{v2} = #{v1}")
   end
 
+  def test_dump_and_load
+    obj = Dumpable.new
+    data = dump(obj)
+    assert_equal([:before, :around_before, :around_after, :after], obj.arr)
+    obj2 = load(data)
+    assert_equal([:before, :around_before, :loaded], obj2.arr)
+  end
+
+  class FooBar
+    def foo
+      Haml::Util.abstract(self)
+    end
+  end
+
+  def test_abstract
+    assert_raise_message(NotImplementedError,
+      "UtilTest::FooBar must implement #foo") {FooBar.new.foo}
+  end
+
   def test_def_static_method
     klass = Class.new
     def_static_method(klass, :static_method, [:arg1, :arg2],

data/test/sass/cache_test.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'sass/engine'
+
+class CacheTest < Test::Unit::TestCase
+  @@cache_dir = "tmp/file_cache"
+
+  def setup
+    FileUtils.mkdir_p @@cache_dir
+  end
+
+  def teardown
+    FileUtils.rm_rf @@cache_dir
+  end
+
+  def test_file_cache_writes_a_file
+    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+  end
+
+  def test_file_cache_reads_a_file
+    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_kind_of Sass::Tree::RootNode, file_store.retrieve("asdf/foo.scssc", "fakesha1")
+  end
+
+  def test_file_cache_miss_returns_nil
+    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
+  end
+
+  def test_sha_change_invalidates_cache_and_cleans_up
+    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    assert_nil file_store.retrieve("asdf/foo.scssc", "differentsha1")
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+  end
+
+  def test_version_change_invalidates_cache_and_cleans_up
+    file_store = Sass::FileCacheStore.new(@@cache_dir)
+    assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    file_store.store("asdf/foo.scssc", "fakesha1", root_node)
+    assert File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    real_version = Sass::VERSION
+    begin
+      Sass::VERSION.replace("a different version")
+      assert_nil file_store.retrieve("asdf/foo.scssc", "fakesha1")
+      assert !File.exists?("#{@@cache_dir}/asdf/foo.scssc")
+    ensure
+      Sass::VERSION.replace(real_version)
+    end
+  end
+
+  private
+  def root_node
+    Sass::Engine.new(<<-SCSS, :syntax => :scss).to_tree
+      @mixin color($c) { color: $c}
+      div { @include color(red); }
+    SCSS
+  end
+end