haml-edge 3.1.73 → 3.1.74

data/lib/sass/plugin/configuration.rb

@@ -2,220 +2,122 @@
 # so that we can load it independently in Rails 3,
 # where the full plugin stuff is lazy-loaded.
 
-require 'sass/callbacks'
-
 module Sass
   module Plugin
-    include Sass::Callbacks
-    extend self
-
-    # Register a callback to be run before stylesheets are mass-updated.
-    # This is run whenever \{#update\_stylesheets} is called,
-    # unless the \{file:SASS_REFERENCE.md#never_update-option `:never_update` option}
-    # is enabled.
-    #
-    # @yield [individual_files]
-    # @yieldparam individual_files [<(String, String)>]
-    #   Individual files to be updated, in addition to the directories
-    #   specified in the options.
-    #   The first element of each pair is the source file,
-    #   the second is the target CSS file.
-    define_callback :updating_stylesheets
-
-    # Register a callback to be run before a single stylesheet is updated.
-    # The callback is only run if the stylesheet is guaranteed to be updated;
-    # if the CSS file is fresh, this won't be run.
-    #
-    # Even if the \{file:SASS_REFERENCE.md#full_exception-option `:full_exception` option}
-    # is enabled, this callback won't be run
-    # when an exception CSS file is being written.
-    # To run an action for those files, use \{#on\_compilation\_error}.
-    #
-    # @yield [template, css]
-    # @yieldparam template [String]
-    #   The location of the Sass/SCSS file being updated.
-    # @yieldparam css [String]
-    #   The location of the CSS file being generated.
-    define_callback :updating_stylesheet
-
-    # Register a callback to be run when Sass decides not to update a stylesheet.
-    # In particular, the callback is run when Sass finds that
-    # the template file and none of its dependencies
-    # have been modified since the last compilation.
-    #
-    # Note that this is **not** run when the
-    # \{file:SASS_REFERENCE.md#never-update_option `:never_update` option} is set,
-    # nor when Sass decides not to compile a partial.
-    #
-    # @yield [template, css]
-    # @yieldparam template [String]
-    #   The location of the Sass/SCSS file not being updated.
-    # @yieldparam css [String]
-    #   The location of the CSS file not being generated.
-    define_callback :not_updating_stylesheet
-
-    # Register a callback to be run when there's an error
-    # compiling a Sass file.
-    # This could include not only errors in the Sass document,
-    # but also errors accessing the file at all.
-    #
-    # @yield [error, template, css]
-    # @yieldparam error [Exception] The exception that was raised.
-    # @yieldparam template [String]
-    #   The location of the Sass/SCSS file being updated.
-    # @yieldparam css [String]
-    #   The location of the CSS file being generated.
-    define_callback :compilation_error
-
-    # Register a callback to be run when Sass creates a directory
-    # into which to put CSS files.
-    #
-    # Note that even if multiple levels of directories need to be created,
-    # the callback may only be run once.
-    # For example, if "foo/" exists and "foo/bar/baz/" needs to be created,
-    # this may only be run for "foo/bar/baz/".
-    # This is not a guarantee, however;
-    # it may also be run for "foo/bar/".
-    #
-    # @yield [dirname]
-    # @yieldparam dirname [String]
-    #   The location of the directory that was created.
-    define_callback :creating_directory
-
-    # Register a callback to be run when Sass detects
-    # that a template has been modified.
-    # This is only run when using \{#watch}.
-    #
-    # @yield [template]
-    # @yieldparam template [String]
-    #   The location of the template that was modified.
-    define_callback :template_modified
-
-    # Register a callback to be run when Sass detects
-    # that a new template has been created.
-    # This is only run when using \{#watch}.
-    #
-    # @yield [template]
-    # @yieldparam template [String]
-    #   The location of the template that was created.
-    define_callback :template_created
-
-    # Register a callback to be run when Sass detects
-    # that a template has been deleted.
-    # This is only run when using \{#watch}.
-    #
-    # @yield [template]
-    # @yieldparam template [String]
-    #   The location of the template that was deleted.
-    define_callback :template_deleted
-
-    # Register a callback to be run when Sass deletes a CSS file.
-    # This happens when the corresponding Sass/SCSS file has been deleted.
-    #
-    # @yield [filename]
-    # @yieldparam filename [String]
-    #   The location of the CSS file that was deleted.
-    define_callback :deleting_css
-
-    @options = {:full_exception => true}
-
-    # An options hash.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @return [{Symbol => Object}]
-    attr_reader :options
-
-    # Sets the options hash.
-    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    #
-    # @param value [{Symbol => Object}] The options hash
-    def options=(value)
-      @options.merge!(value)
-    end
-
-    # Non-destructively modifies \{#options} so that default values are properly set.
-    #
-    # @param additional_options [{Symbol => Object}] An options hash with which to merge \{#options}
-    # @return [{Symbol => Object}] The modified options hash
-    def engine_options(additional_options = {})
-      opts = options.dup.merge(additional_options)
-      opts[:load_paths] = load_paths(opts)
-      opts
-    end
-
-    # Adds a new template-location/css-location mapping.
-    # This means that Sass/SCSS files in `template_location`
-    # will be compiled to CSS files in `css_location`.
-    #
-    # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-    # since the option can be in multiple formats.
-    #
-    # Note that this method will change `options[:template_location]`
-    # to be in the Array format.
-    # This means that even if `options[:template_location]`
-    # had previously been a Hash or a String,
-    # it will now be an Array.
-    #
-    # @param template_location [String] The location where Sass/SCSS files will be.
-    # @param css_location [String] The location where compiled CSS files will go.
-    def add_template_location(template_location, css_location = options[:css_location])
-      normalize_template_location!
-      template_location_array << [template_location, css_location]
-    end
-
-    # Removes a template-location/css-location mapping.
-    # This means that Sass/SCSS files in `template_location`
-    # will no longer be compiled to CSS files in `css_location`.
-    #
-    # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-    # since the option can be in multiple formats.
-    #
-    # Note that this method will change `options[:template_location]`
-    # to be in the Array format.
-    # This means that even if `options[:template_location]`
-    # had previously been a Hash or a String,
-    # it will now be an Array.
-    #
-    # @param template_location [String]
-    #   The location where Sass/SCSS files were,
-    #   which is now going to be ignored.
-    # @param css_location [String]
-    #   The location where compiled CSS files went, but will no longer go.
-    # @return [Boolean]
-    #   Non-`nil` if the given mapping already existed and was removed,
-    #   or `nil` if nothing was changed.
-    def remove_template_location(template_location, css_location = options[:css_location])
-      normalize_template_location!
-      template_location_array.delete([template_location, css_location])
-    end
-
-    # Returns the template locations configured for Sass
-    # as an array of `[template_location, css_location]` pairs.
-    # See the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
-    # for details.
-    #
-    # @return [Array<(String, String)>]
-    #   An array of `[template_location, css_location]` pairs.
-    def template_location_array
-      old_template_location = options[:template_location]
-      normalize_template_location!
-      options[:template_location]
-    ensure
-      options[:template_location] = old_template_location
-    end
-
-    private
-
-    def normalize_template_location!
-      return if options[:template_location].is_a?(Array)
-      options[:template_location] =
-        case options[:template_location]
-        when nil
-          css_location = options[:css_location] || './public/stylesheets'
-          [[File.join(css_location, 'sass'), css_location]]
-        when String; [[options[:template_location], options[:css_location]]]
-        else; options[:template_location].to_a
-        end
+    module Configuration
+
+      # Returns the default options for a {Sass::Plugin::Compiler}.
+      #
+      # @return [{Symbol => Object}]
+      def default_options
+        @default_options ||= {
+          :css_location       => './public/stylesheets',
+          :always_update      => false,
+          :always_check       => true,
+          :full_exception     => true,
+          :cache_location     => ".sass-cache"
+        }.freeze
+      end
+
+      # Resets the options and {Sass::Callbacks::InstanceMethods#clear_callbacks! clears all callbacks}.
+      def reset!
+        @options = nil
+        clear_callbacks!
+      end
+
+      # An options hash.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [{Symbol => Object}]
+      def options
+        @options ||= default_options.dup
+        @options[:cache_store] ||= Sass::FileCacheStore.new(@options[:cache_location])
+        @options
+      end
+
+      # Sets the options hash.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # See {Sass::Plugin::Configuration#reset!}
+      # @deprecated Instead, modify the options hash in-place.
+      # @param value [{Symbol => Object}] The options hash
+      def options=(value)
+        Haml::Util.haml_warn("Setting Sass::Plugin.options is deprecated " +
+                             "and will be removed in a future release.")
+        options.merge!(value)
+      end
+
+      # Adds a new template-location/css-location mapping.
+      # This means that Sass/SCSS files in `template_location`
+      # will be compiled to CSS files in `css_location`.
+      #
+      # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # since the option can be in multiple formats.
+      #
+      # Note that this method will change `options[:template_location]`
+      # to be in the Array format.
+      # This means that even if `options[:template_location]`
+      # had previously been a Hash or a String,
+      # it will now be an Array.
+      #
+      # @param template_location [String] The location where Sass/SCSS files will be.
+      # @param css_location [String] The location where compiled CSS files will go.
+      def add_template_location(template_location, css_location = options[:css_location])
+        normalize_template_location!
+        template_location_array << [template_location, css_location]
+      end
+
+      # Removes a template-location/css-location mapping.
+      # This means that Sass/SCSS files in `template_location`
+      # will no longer be compiled to CSS files in `css_location`.
+      #
+      # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # since the option can be in multiple formats.
+      #
+      # Note that this method will change `options[:template_location]`
+      # to be in the Array format.
+      # This means that even if `options[:template_location]`
+      # had previously been a Hash or a String,
+      # it will now be an Array.
+      #
+      # @param template_location [String]
+      #   The location where Sass/SCSS files were,
+      #   which is now going to be ignored.
+      # @param css_location [String]
+      #   The location where compiled CSS files went, but will no longer go.
+      # @return [Boolean]
+      #   Non-`nil` if the given mapping already existed and was removed,
+      #   or `nil` if nothing was changed.
+      def remove_template_location(template_location, css_location = options[:css_location])
+        normalize_template_location!
+        template_location_array.delete([template_location, css_location])
+      end
+
+      # Returns the template locations configured for Sass
+      # as an array of `[template_location, css_location]` pairs.
+      # See the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # for details.
+      #
+      # @return [Array<(String, String)>]
+      #   An array of `[template_location, css_location]` pairs.
+      def template_location_array
+        old_template_location = options[:template_location]
+        normalize_template_location!
+        options[:template_location]
+      ensure
+        options[:template_location] = old_template_location
+      end
+
+      private
+
+      def normalize_template_location!
+        return if options[:template_location].is_a?(Array)
+        options[:template_location] =
+          case options[:template_location]
+          when nil; [[File.join(options[:css_location], 'sass'), options[:css_location]]]
+          when String; [[options[:template_location], options[:css_location]]]
+          else; options[:template_location].to_a
+          end
+      end
     end
   end
 end

data/lib/sass/plugin/merb.rb

@@ -1,21 +1,32 @@
 unless defined?(Sass::MERB_LOADED)
   Sass::MERB_LOADED = true
 
-  version = Merb::VERSION.split('.').map { |n| n.to_i }
-  if version[0] <= 0 && version[1] < 5
-    root = MERB_ROOT
-    env  = MERB_ENV
-  else
-    root = Merb.root.to_s
-    env  = Merb.environment
+  module Sass::Plugin::Configuration
+    # Different default options in a m envirionment.
+    def default_options
+      @default_options ||= begin
+        version = Merb::VERSION.split('.').map { |n| n.to_i }
+        if version[0] <= 0 && version[1] < 5
+          root = MERB_ROOT
+          env  = MERB_ENV
+        else
+          root = Merb.root.to_s
+          env  = Merb.environment
+        end
+
+        {
+          :always_update      => false,
+          :template_location => root + '/public/stylesheets/sass',
+          :css_location      => root + '/public/stylesheets',
+          :cache_location    => root + '/tmp/sass-cache',
+          :always_check      => env != "production",
+          :quiet             => env != "production",
+          :full_exception    => env != "production"
+        }.freeze
+      end
+    end
   end
 
-  Sass::Plugin.options.merge!(:template_location => root + '/public/stylesheets/sass',
-                              :css_location      => root + '/public/stylesheets',
-                              :cache_location    => root + '/tmp/sass-cache',
-                              :always_check      => env != "production",
-                              :quiet             => env != "production",
-                              :full_exception    => env != "production")
   config = Merb::Plugins.config[:sass] || Merb::Plugins.config["sass"] || {}
 
   if defined? config.symbolize_keys!

data/lib/sass/plugin/rails.rb

@@ -1,13 +1,22 @@
 unless defined?(Sass::RAILS_LOADED)
   Sass::RAILS_LOADED = true
 
-  # Reverse-merging (we're in Rails, anyway) so we dont' clobber what's already been defined further up-stream
-  Sass::Plugin.options.reverse_merge!(:template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
-                                      :css_location      => Haml::Util.rails_root + '/public/stylesheets',
-                                      :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
-                                      :always_check      => Haml::Util.rails_env == "development",
-                                      :quiet             => Haml::Util.rails_env != "production",
-                                      :full_exception    => Haml::Util.rails_env != "production")
+  module Sass::Plugin::Configuration
+    # Different default options in a rails envirionment.
+    def default_options
+      @default_options ||= {
+        :always_update      => false,
+        :template_location => Haml::Util.rails_root + '/public/stylesheets/sass',
+        :css_location      => Haml::Util.rails_root + '/public/stylesheets',
+        :cache_location    => Haml::Util.rails_root + '/tmp/sass-cache',
+        :always_check      => Haml::Util.rails_env == "development",
+        :quiet             => Haml::Util.rails_env != "production",
+        :full_exception    => Haml::Util.rails_env != "production"
+      }.freeze
+    end
+  end
+
+  Sass::Plugin.options.reverse_merge!(Sass::Plugin.default_options)
 
   if defined?(ActionController::Metal)
     # Rails >= 3.0

data/lib/sass/plugin/staleness_checker.rb

@@ -6,8 +6,9 @@ module Sass
     #
     # * A class-level dependency cache which stores @import paths for each file.
     #   This is a long-lived cache that is reused by every StalenessChecker instance.
-    # * Two short-lived instance-level caches, one for file mtimes
-    #   and one for whether a file is stale during this particular run.
+    # * Three short-lived instance-level caches, one for file mtimes,
+    #   one for whether a file is stale during this particular run.
+    #   and one for the parse tree for a file.
     #   These are only used by a single StalenessChecker instance.
     #
     # Usage:
@@ -26,19 +27,24 @@ module Sass
       @dependencies_cache = {}
 
       class << self
+        # TODO: attach this to a compiler instance.
         # @private
         attr_accessor :dependencies_cache
       end
 
       # Creates a new StalenessChecker
       # for checking the staleness of several stylesheets at once.
-      def initialize
+      #
+      # @param options [{Symbol => Object}]
+      #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      def initialize(options)
         @dependencies = self.class.dependencies_cache
 
         # Entries in the following instance-level caches are never explicitly expired.
         # Instead they are supposed to automaticaly go out of scope when a series of staleness checks
         # (this instance of StalenessChecker was created for) is finished.
-        @mtimes, @dependencies_stale = {}, {}
+        @mtimes, @dependencies_stale, @parse_trees = {}, {}, {}
+        @options = Sass::Engine.normalize_options(options)
       end
 
       # Returns whether or not a given CSS file is out of date
@@ -48,9 +54,15 @@ module Sass
       # @param template_file [String] The location of the Sass or SCSS template
       #   that is compiled to `css_file`.
       def stylesheet_needs_update?(css_file, template_file)
-        template_file, css_mtime = File.expand_path(template_file), mtime(css_file)
+        template_file = File.expand_path(template_file)
+        begin
+          css_mtime = File.mtime(css_file).to_i
+        rescue Errno::ENOENT
+          return true
+        end
 
-        css_mtime == DELETED || dependency_updated?(css_mtime).call(template_file)
+        dependency_updated?(css_mtime).call(
+          template_file, @options[:filesystem_importer].new("."))
       end
 
       # Returns whether or not a given CSS file is out of date
@@ -64,13 +76,13 @@ module Sass
       # @param template_file [String] The location of the Sass or SCSS template
       #   that is compiled to `css_file`.
       def self.stylesheet_needs_update?(css_file, template_file)
-        new.stylesheet_needs_update?(css_file, template_file)
+        new(Plugin.engine_options).stylesheet_needs_update?(css_file, template_file)
       end
 
       private
 
-      def dependencies_stale?(template_file, css_mtime)
-        timestamps = @dependencies_stale[template_file] ||= {}
+      def dependencies_stale?(uri, importer, css_mtime)
+        timestamps = @dependencies_stale[[uri, importer]] ||= {}
         timestamps.each_pair do |checked_css_mtime, is_stale|
           if checked_css_mtime <= css_mtime && !is_stale
             return false
@@ -78,45 +90,55 @@ module Sass
             return true
           end
         end
-        timestamps[css_mtime] = dependencies(template_file).any?(&dependency_updated?(css_mtime))
+        timestamps[css_mtime] = dependencies(uri, importer).any?(&dependency_updated?(css_mtime))
+      rescue Sass::SyntaxError
+        # If there's an error finding dependencies, default to recompiling.
+        true
       end
 
-      def mtime(filename)
-        @mtimes[filename] ||= begin
-          File.mtime(filename).to_i
-        rescue Errno::ENOENT
-          @dependencies.delete(filename)
-          DELETED
-        end
+      def mtime(uri, importer)
+        @mtimes[[uri, importer]] ||=
+          begin
+            mtime = importer.mtime(uri, @options)
+            if mtime.nil?
+              @dependencies.delete([uri, importer])
+              DELETED
+            else
+              mtime.to_i
+            end
+          end
       end
 
-      def dependencies(filename)
-        stored_mtime, dependencies = @dependencies[filename]
+      def dependencies(uri, importer)
+        stored_mtime, dependencies = @dependencies[[uri, importer]]
 
-        if !stored_mtime || stored_mtime < mtime(filename)
-          @dependencies[filename] = [mtime(filename), dependencies = compute_dependencies(filename)]
+        if !stored_mtime || stored_mtime < mtime(uri, importer)
+          dependencies = compute_dependencies(uri, importer)
+          @dependencies[[uri, importer]] = [mtime(uri, importer), dependencies]
         end
 
         dependencies
       end
 
       def dependency_updated?(css_mtime)
-        lambda do |dep|
-          begin
-            mtime(dep) > css_mtime || dependencies_stale?(dep, css_mtime)
-          rescue Sass::SyntaxError
-            # If there's an error finding depenencies, default to recompiling.
-            true
-          end
+        lambda do |uri, importer|
+          mtime(uri, importer) > css_mtime ||
+            dependencies_stale?(uri, importer, css_mtime)
         end
       end
 
-      def compute_dependencies(filename)
-        Files.tree_for(filename, Plugin.engine_options).grep(Tree::ImportNode) do |n|
-          File.expand_path(n.full_filename) unless n.full_filename =~ /\.css$/
+      def compute_dependencies(uri, importer)
+        tree(uri, importer).grep(Tree::ImportNode) do |n|
+          next if n.css_import?
+          file = n.imported_file
+          key = [file.options[:filename], file.options[:importer]]
+          @parse_trees[key] = file.to_tree
+          key
         end.compact
-      rescue Sass::SyntaxError => e
-        [] # If the file has an error, we assume it has no dependencies
+      end
+
+      def tree(uri, importer)
+        @parse_trees[[uri, importer]] ||= importer.find(uri, @options).to_tree
       end
     end
   end