haml 3.0.25 → 3.1.0.alpha.2

data/lib/sass/plugin/configuration.rb

@@ -1,221 +0,0 @@
-# We keep configuration in its own self-contained file
-# 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
-    end
-  end
-end

data/lib/sass/plugin/generic.rb

@@ -1,15 +0,0 @@
-# The reason some options are declared here rather than in sass/plugin/configuration.rb
-# is that otherwise they'd clobber the Rails-specific options.
-# Since Rails' options are lazy-loaded in Rails 3,
-# they're reverse-merged with the default options
-# so that user configuration is preserved.
-# This means that defaults that differ from Rails'
-# must be declared here.
-
-unless defined?(Sass::GENERIC_LOADED)
-  Sass::GENERIC_LOADED = true
-
-  Sass::Plugin.options.merge!(:css_location   => './public/stylesheets',
-                              :always_update  => false,
-                              :always_check   => true)
-end

data/lib/sass/plugin/merb.rb

@@ -1,37 +0,0 @@
-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
-  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!
-    config.symbolize_keys!
-  end
-
-  Sass::Plugin.options.merge!(config)
-
-  require 'sass/plugin/rack'
-  class Sass::Plugin::MerbBootLoader < Merb::BootLoader
-    after Merb::BootLoader::RackUpApplication
-
-    def self.run
-      # Apparently there's no better way than this to add Sass
-      # to Merb's Rack stack.
-      Merb::Config[:app] = Sass::Plugin::Rack.new(Merb::Config[:app])
-    end
-  end
-end

data/lib/sass/plugin/rack.rb

@@ -1,47 +0,0 @@
-module Sass
-  module Plugin
-    # Rack middleware for compiling Sass code.
-    #
-    # ## Activate
-    #
-    #     require 'sass/plugin/rack'
-    #     use Sass::Plugin::Rack
-    #
-    # ## Customize
-    #
-    #     Sass::Plugin.options.merge(
-    #       :cache_location => './tmp/sass-cache',
-    #       :never_update => environment != :production,
-    #       :full_exception => environment != :production)
-    #
-    # {file:SASS_REFERENCE.md#options See the Reference for more options}.
-    #
-    # ## Use
-    #
-    # Put your Sass files in `public/stylesheets/sass`.
-    # Your CSS will be generated in `public/stylesheets`,
-    # and regenerated every request if necessary.
-    # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
-    # That's all there is to it!
-    class Rack
-      # Initialize the middleware.
-      #
-      # @param app [#call] The Rack application
-      def initialize(app)
-        @app = app
-      end
-
-      # Process a request, checking the Sass stylesheets for changes
-      # and updating them if necessary.
-      #
-      # @param env The Rack request environment
-      # @return [(#to_i, {String => String}, Object)] The Rack response
-      def call(env)
-        Sass::Plugin.check_for_updates
-        @app.call(env)
-      end
-    end
-  end
-end
-
-require 'sass/plugin'

data/lib/sass/plugin/rails.rb

@@ -1,32 +0,0 @@
-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")
-
-  if defined?(ActionController::Metal)
-    # Rails >= 3.0
-    require 'sass/plugin/rack'
-    Rails.configuration.middleware.use(Sass::Plugin::Rack)
-  elsif defined?(ActionController::Dispatcher) &&
-      defined?(ActionController::Dispatcher.middleware)
-    # Rails >= 2.3
-    require 'sass/plugin/rack'
-    ActionController::Dispatcher.middleware.use(Sass::Plugin::Rack)
-  else
-    module ActionController
-      class Base
-        alias_method :sass_old_process, :process
-        def process(*args)
-          Sass::Plugin.check_for_updates
-          sass_old_process(*args)
-        end
-      end
-    end
-  end
-end

data/lib/sass/plugin/staleness_checker.rb

@@ -1,123 +0,0 @@
-module Sass
-  module Plugin
-    # The class handles `.s[ca]ss` file staleness checks via their mtime timestamps.
-    #
-    # To speed things up two level of caches are employed:
-    #
-    # * 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.
-    #   These are only used by a single StalenessChecker instance.
-    #
-    # Usage:
-    #
-    # * For a one-off staleness check of a single `.s[ca]ss` file,
-    #   the class-level {stylesheet_needs_update?} method
-    #   should be used.
-    # * For a series of staleness checks (e.g. checking all files for staleness)
-    #   a StalenessChecker instance should be created,
-    #   and the instance-level \{#stylesheet\_needs\_update?} method should be used.
-    #   the caches should make the whole process significantly faster.
-    #   *WARNING*: It is important not to retain the instance for too long,
-    #   as its instance-level caches are never explicitly expired.
-    class StalenessChecker
-      DELETED             = 1.0/0.0 # positive Infinity
-      @dependencies_cache = {}
-
-      class << self
-        # @private
-        attr_accessor :dependencies_cache
-      end
-
-      # Creates a new StalenessChecker
-      # for checking the staleness of several stylesheets at once.
-      def initialize
-        @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 = {}, {}
-      end
-
-      # Returns whether or not a given CSS file is out of date
-      # and needs to be regenerated.
-      #
-      # @param css_file [String] The location of the CSS file to check.
-      # @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)
-
-        css_mtime == DELETED || dependency_updated?(css_mtime).call(template_file)
-      end
-
-      # Returns whether or not a given CSS file is out of date
-      # and needs to be regenerated.
-      #
-      # The distinction between this method and the instance-level \{#stylesheet\_needs\_update?}
-      # is that the instance method preserves mtime and stale-dependency caches,
-      # so it's better to use when checking multiple stylesheets at once.
-      #
-      # @param css_file [String] The location of the CSS file to check.
-      # @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)
-      end
-
-      private
-
-      def dependencies_stale?(template_file, css_mtime)
-        timestamps = @dependencies_stale[template_file] ||= {}
-        timestamps.each_pair do |checked_css_mtime, is_stale|
-          if checked_css_mtime <= css_mtime && !is_stale
-            return false
-          elsif checked_css_mtime > css_mtime && is_stale
-            return true
-          end
-        end
-        timestamps[css_mtime] = dependencies(template_file).any?(&dependency_updated?(css_mtime))
-      end
-
-      def mtime(filename)
-        @mtimes[filename] ||= begin
-          File.mtime(filename).to_i
-        rescue Errno::ENOENT
-          @dependencies.delete(filename)
-          DELETED
-        end
-      end
-
-      def dependencies(filename)
-        stored_mtime, dependencies = @dependencies[filename]
-
-        if !stored_mtime || stored_mtime < mtime(filename)
-          @dependencies[filename] = [mtime(filename), dependencies = compute_dependencies(filename)]
-        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
-        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$/
-        end.compact
-      rescue Sass::SyntaxError => e
-        [] # If the file has an error, we assume it has no dependencies
-      end
-    end
-  end
-end