oreorenasass 3.4.4 → 3.4.5

data/lib/sass/importers/base.rb

@@ -15,9 +15,13 @@ module Sass
     # They should also implement the \{#find\_relative} method.
     #
     # Importers should be serializable via `Marshal.dump`.
+    # In addition to the standard `_dump` and `_load` methods,
+    # importers can define `_before_dump`, `_after_dump`, `_around_dump`,
+    # and `_after_load` methods as per {Sass::Util#dump} and {Sass::Util#load}.
     #
     # @abstract
     class Base
+
       # Find a Sass file relative to another file.
       # Importers without a notion of "relative paths"
       # should just return nil here.
@@ -118,34 +122,6 @@ module Sass
         Sass::Util.abstract(self)
       end
 
-      # Get the publicly-visible URL for an imported file. This URL is used by
-      # source maps to link to the source stylesheet. This may return `nil` to
-      # indicate that no public URL is available; however, this will cause
-      # sourcemap generation to fail if any CSS is generated from files imported
-      # from this importer.
-      #
-      # If an absolute "file:" URI can be produced for an imported file, that
-      # should be preferred to returning `nil`. However, a URL relative to
-      # `sourcemap_directory` should be preferred over an absolute "file:" URI.
-      #
-      # @param uri [String] A URI known to be valid for this importer.
-      # @param sourcemap_directory [String, NilClass] The absolute path to a
-      #   directory on disk where the sourcemap will be saved. If uri refers to
-      #   a file on disk that's accessible relative to sourcemap_directory, this
-      #   may return a relative URL. This may be `nil` if the sourcemap's
-      #   eventual location is unknown.
-      # @return [String?] The publicly-visible URL for this file, or `nil`
-      #   indicating that no publicly-visible URL exists. This should be
-      #   appropriately URL-escaped.
-      def public_url(uri, sourcemap_directory)
-        return if @public_url_warning_issued
-        @public_url_warning_issued = true
-        Sass::Util.sass_warn <<WARNING
-WARNING: #{self.class.name} should define the #public_url method.
-WARNING
-        nil
-      end
-
       # A string representation of the importer.
       # Should be overridden by subclasses.
       #
@@ -156,27 +132,8 @@ WARNING
       def to_s
         Sass::Util.abstract(self)
       end
-
-      # If the importer is based on files on the local filesystem
-      # this method should return folders which should be watched
-      # for changes.
-      #
-      # @return [Array<String>] List of absolute paths of directories to watch
-      def directories_to_watch
-        []
-      end
-
-      # If this importer is based on files on the local filesystem This method
-      # should return true if the file, when changed, should trigger a
-      # recompile.
-      #
-      # It is acceptable for non-sass files to be watched and trigger a recompile.
-      #
-      # @param filename [String] The absolute filename for a file that has changed.
-      # @return [Boolean] When the file changed should cause a recompile.
-      def watched_file?(filename)
-        false
-      end
     end
   end
 end
+
+      

data/lib/sass/importers/filesystem.rb

@@ -1,3 +1,4 @@
+require 'pathname'
 require 'set'
 
 module Sass
@@ -5,6 +6,7 @@ module Sass
     # The default importer, used for any strings found in the load path.
     # Simply loads Sass files from the filesystem using the default logic.
     class Filesystem < Base
+
       attr_accessor :root
 
       # Creates a new filesystem importer that imports files relative to a given path.
@@ -37,7 +39,7 @@ module Sass
       # @see Base#key
       def key(name, options)
         [self.class.name + ":" + File.dirname(File.expand_path(name)),
-         File.basename(name)]
+          File.basename(name)]
       end
 
       # @see Base#to_s
@@ -53,31 +55,6 @@ module Sass
         root.eql?(other.root)
       end
 
-      # @see Base#directories_to_watch
-      def directories_to_watch
-        [root]
-      end
-
-      # @see Base#watched_file?
-      def watched_file?(filename)
-        filename =~ /\.s[ac]ss$/ &&
-          filename.start_with?(root + File::SEPARATOR)
-      end
-
-      def public_url(name, sourcemap_directory)
-        file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
-        if sourcemap_directory.nil?
-          Sass::Util.file_uri_from_path(file_pathname)
-        else
-          sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
-          begin
-            Sass::Util.file_uri_from_path(file_pathname.relative_path_from(sourcemap_pathname))
-          rescue ArgumentError # when a relative path cannot be constructed
-            Sass::Util.file_uri_from_path(file_pathname)
-          end
-        end
-      end
-
       protected
 
       # If a full uri is passed, this removes the root from it
@@ -121,7 +98,7 @@ module Sass
         end
 
         # JRuby chokes when trying to import files from JARs when the path starts with './'.
-        ret.map {|f, s| [f.sub(/^\.\//, ''), s]}
+        ret.map {|f, s| [f.sub(%r{^\./}, ''), s]}
       end
 
       def escape_glob_characters(name)
@@ -130,7 +107,7 @@ module Sass
         end
       end
 
-      REDUNDANT_DIRECTORY = /#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}/
+      REDUNDANT_DIRECTORY = %r{#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}}
       # Given a base directory and an `@import`ed name,
       # finds an existant file that matches the name.
       #
@@ -138,16 +115,14 @@ module Sass
       # @param name [String] The filename to search for.
       # @return [(String, Symbol)] A filename-syntax pair.
       def find_real_file(dir, name, options)
-        # On windows 'dir' or 'name' can be in native File::ALT_SEPARATOR form.
+        # on windows 'dir' can be in native File::ALT_SEPARATOR form
         dir = dir.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
-        name = name.gsub(File::ALT_SEPARATOR, File::SEPARATOR) unless File::ALT_SEPARATOR.nil?
 
         found = possible_files(remove_root(name)).map do |f, s|
-          path = (dir == "." || Sass::Util.pathname(f).absolute?) ? f :
-            "#{escape_glob_characters(dir)}/#{f}"
+          path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{escape_glob_characters(dir)}/#{f}"
           Dir[path].map do |full_path|
             full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
-            [Sass::Util.cleanpath(full_path).to_s, s]
+            [Pathname.new(full_path).cleanpath.to_s, s]
           end
         end
         found = Sass::Util.flatten(found, 1)
@@ -155,20 +130,20 @@ module Sass
 
         if found.size > 1 && !@same_name_warnings.include?(found.first.first)
           found.each {|(f, _)| @same_name_warnings << f}
-          relative_to = Sass::Util.pathname(dir)
-          if options[:_from_import_node]
+          relative_to = Pathname.new(dir)
+          if options[:_line]
             # If _line exists, we're here due to an actual import in an
             # import_node and we want to print a warning for a user writing an
             # ambiguous import.
-            candidates = found.map do |(f, _)|
-              "  " + Sass::Util.pathname(f).relative_path_from(relative_to).to_s
-            end.join("\n")
-            raise Sass::SyntaxError.new(<<MESSAGE)
-It's not clear which file to import for '@import "#{name}"'.
-Candidates:
+            candidates = found.map {|(f, _)| "    " + Pathname.new(f).relative_path_from(relative_to).to_s}.join("\n")
+            Sass::Util.sass_warn <<WARNING
+WARNING: On line #{options[:_line]}#{" of #{options[:filename]}" if options[:filename]}:
+  It's not clear which file to import for '@import "#{name}"'.
+  Candidates:
 #{candidates}
-Please delete or rename all but one of these files.
-MESSAGE
+  For now I'll choose #{File.basename found.first.first}.
+  This will be an error in future versions of Sass.
+WARNING
           else
             # Otherwise, we're here via StalenessChecker, and we want to print a
             # warning for a user running `sass --watch` with two ambiguous files.
@@ -188,7 +163,7 @@ WARNING
       def split(name)
         extension = nil
         dirname, basename = File.dirname(name), File.basename(name)
-        if basename =~ /^(.*)\.(#{extensions.keys.map {|e| Regexp.escape(e)}.join('|')})$/
+        if basename =~ /^(.*)\.(#{extensions.keys.map{|e| Regexp.escape(e)}.join('|')})$/
           basename = $1
           extension = $2
         end

data/lib/sass/logger.rb

@@ -1,9 +1,12 @@
-module Sass::Logger; end
+module Sass::Logger
+
+end
 
 require "sass/logger/log_level"
 require "sass/logger/base"
 
 module Sass
+
   class << self
     attr_accessor :logger
   end

data/lib/sass/logger/base.rb

@@ -1,6 +1,7 @@
 require 'sass/logger/log_level'
 
 class Sass::Logger::Base
+  
   include Sass::Logger::LogLevel
 
   attr_accessor :log_level
@@ -21,10 +22,11 @@ class Sass::Logger::Base
   end
 
   def log(level, message)
-    _log(level, message) if logging_level?(level)
+    self._log(level, message) if logging_level?(level)
   end
 
   def _log(level, message)
-    Kernel.warn(message)
+    Kernel::warn(message)
   end
+
 end

data/lib/sass/logger/log_level.rb

@@ -1,21 +1,24 @@
 module Sass
   module Logger
     module LogLevel
+
       def self.included(base)
         base.extend(ClassMethods)
       end
-
+      
       module ClassMethods
         def inherited(subclass)
           subclass.log_levels = subclass.superclass.log_levels.dup
         end
 
-        attr_writer :log_levels
-
         def log_levels
           @log_levels ||= {}
         end
 
+        def log_levels=(levels)
+          @log_levels = levels
+        end
+
         def log_level?(level, min_level)
           log_levels[level] >= log_levels[min_level]
         end
@@ -40,6 +43,7 @@ module Sass
           RUBY
         end
       end
+      
     end
   end
 end

data/lib/sass/media.rb

@@ -2,7 +2,7 @@
 module Sass::Media
   # A comma-separated list of queries.
   #
-  #     media_query [ ',' S* media_query ]*
+  #   media_query [ ',' S* media_query ]*
   class QueryList
     # The queries contained in this list.
     #
@@ -43,11 +43,11 @@ module Sass::Media
     end
 
     # Returns a representation of the query as an array of strings and
-    # potentially {Sass::Script::Tree::Node}s (if there's interpolation in it).
-    # When the interpolation is resolved and the strings are joined together,
-    # this will be the string representation of this query.
+    # potentially {Sass::Script::Node}s (if there's interpolation in it). When
+    # the interpolation is resolved and the strings are joined together, this
+    # will be the string representation of this query.
     #
-    # @return [Array<String, Sass::Script::Tree::Node>]
+    # @return [Array<String, Sass::Script::Node>]
     def to_a
       Sass::Util.intersperse(queries.map {|q| q.to_a}, ', ').flatten
     end
@@ -62,7 +62,7 @@ module Sass::Media
 
   # A single media query.
   #
-  #     [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
+  #   [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
   class Query
     # The modifier for the query.
     #
@@ -70,7 +70,7 @@ module Sass::Media
     # parsed as CSS, it contains a single string (accessible via
     # \{#resolved_modifier}).
     #
-    # @return [Array<String, Sass::Script::Tree::Node>]
+    # @return [Array<String, Sass::Script::Node>]
     attr_accessor :modifier
 
     # The type of the query (e.g. `"screen"` or `"print"`).
@@ -79,7 +79,7 @@ module Sass::Media
     # parsed as CSS, it contains a single string (accessible via
     # \{#resolved_type}).
     #
-    # @return [Array<String, Sass::Script::Tree::Node>]
+    # @return [Array<String, Sass::Script::Node>]
     attr_accessor :type
 
     # The trailing expressions in the query.
@@ -87,12 +87,12 @@ module Sass::Media
     # When parsed as Sass code, each expression contains strings and SassScript
     # nodes. When parsed as CSS, each one contains a single string.
     #
-    # @return [Array<Array<String, Sass::Script::Tree::Node>>]
+    # @return [Array<Array<String, Sass::Script::Node>>]
     attr_accessor :expressions
 
-    # @param modifier [Array<String, Sass::Script::Tree::Node>] See \{#modifier}
-    # @param type [Array<String, Sass::Script::Tree::Node>] See \{#type}
-    # @param expressions [Array<Array<String, Sass::Script::Tree::Node>>] See \{#expressions}
+    # @param modifier [Array<String, Sass::Script::Node>] See \{#modifier}
+    # @param type [Array<String, Sass::Script::Node>] See \{#type}
+    # @param expressions [Array<Array<String, Sass::Script::Node>>] See \{#expressions}
     def initialize(modifier, type, expressions)
       @modifier = modifier
       @type = type
@@ -125,7 +125,7 @@ module Sass::Media
       m2, t2 = other.resolved_modifier.downcase, other.resolved_type.downcase
       t1 = t2 if t1.empty?
       t2 = t1 if t2.empty?
-      if (m1 == 'not') ^ (m2 == 'not')
+      if ((m1 == 'not') ^ (m2 == 'not'))
         return if t1 == t2
         type = m1 == 'not' ? t2 : t1
         mod = m1 == 'not' ? m2 : m1
@@ -140,7 +140,7 @@ module Sass::Media
         type = t1
         mod = m1.empty? ? m2 : m1
       end
-      Query.new([mod], [type], other.expressions + expressions)
+      return Query.new([mod], [type], other.expressions + expressions)
     end
 
     # Returns the CSS for the media query.
@@ -156,7 +156,7 @@ module Sass::Media
         # It's possible for there to be script nodes in Expressions even when
         # we're converting to CSS in the case where we parsed the document as
         # CSS originally (as in css_test.rb).
-        e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.to_sass : c.to_s}.join
+        e.map {|c| c.is_a?(Sass::Script::Node) ? c.to_sass : c.to_s}.join
       end.join(' and ')
       css
     end
@@ -193,18 +193,21 @@ module Sass::Media
     # @return [Query]
     def deep_copy
       Query.new(
-        modifier.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
-        type.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c},
-        expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}})
+        modifier.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
+        expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}})
     end
   end
 
   # Converts an interpolation array to source.
   #
-  # @param interp [Array<String, Sass::Script::Tree::Node>] The interpolation array to convert.
+  # @param [Array<String, Sass::Script::Node>] The interpolation array to convert.
   # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
   # @return [String]
   def self._interp_to_src(interp, options)
-    interp.map {|r| r.is_a?(String) ? r : r.to_sass(options)}.join
+    interp.map do |r|
+      next r if r.is_a?(String)
+      "\#{#{r.to_sass(options)}}"
+    end.join
   end
 end

data/lib/sass/plugin.rb

@@ -11,8 +11,7 @@ module Sass
   # This module is used as the primary interface with Sass
   # when it's used as a plugin for various frameworks.
   # All Rack-enabled frameworks are supported out of the box.
-  # The plugin is
-  # {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
+  # The plugin is {file:SASS_REFERENCE.md#rails_merb_plugin automatically activated for Rails and Merb}.
   # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
   #
   # This module has a large set of callbacks available
@@ -33,6 +32,7 @@ module Sass
   #     #=> Compiling app/sass/ie.scss to public/stylesheets/ie.css
   # @see Sass::Plugin::Compiler
   module Plugin
+    include Sass::Util
     extend self
 
     @checked_for_updates = false
@@ -65,8 +65,7 @@ module Sass
 
     # Updates out-of-date stylesheets.
     #
-    # Checks each Sass/SCSS file in
-    # {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+    # Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
     # to see if it's been modified more recently than the corresponding CSS file
     # in {file:SASS_REFERENCE.md#css_location-option `:css_location`}.
     # If it has, it updates the CSS file.
@@ -120,12 +119,13 @@ module Sass
     def options
       compiler.options
     end
+
   end
 end
 
-if defined?(ActionController)
-  # On Rails 3+ the rails plugin is loaded at the right time in railtie.rb
-  require 'sass/plugin/rails' unless Sass::Util.ap_geq_3?
+# On Rails 3+ the rails plugin is loaded at the right time in railtie.rb
+if defined?(ActionController) && !Sass::Util.ap_geq_3?
+  require 'sass/plugin/rails'
 elsif defined?(Merb::Plugins)
   require 'sass/plugin/merb'
 else

data/lib/sass/plugin/compiler.rb

@@ -7,6 +7,7 @@ require 'sass/plugin/configuration'
 require 'sass/plugin/staleness_checker'
 
 module Sass::Plugin
+
   # The Compiler class handles compilation of multiple files and/or directories,
   # including checking which CSS files are out-of-date and need to be updated
   # and calling Sass to perform the compilation on those files.
@@ -25,41 +26,31 @@ module Sass::Plugin
   # * `:never_update`
   # * `:always_check`
   class Compiler
+    include Sass::Util
     include Configuration
     extend Sass::Callbacks
 
     # Creates a new compiler.
     #
-    # @param opts [{Symbol => Object}]
+    # @param options [{Symbol => Object}]
     #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    def initialize(opts = {})
-      options.merge!(opts)
+    def initialize(options = {})
+      self.options.merge!(options)
     end
 
-    # Register a callback to be run before stylesheets are mass-updated.
+    # Register a callback to be run after 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 [files]
-    # @yieldparam files [<(String, String, String)>]
-    #   Individual files to be updated. Files in directories specified are included in this list.
+    # @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,
-    #   the third is the target sourcemap file.
+    #   the second is the target CSS file.
     define_callback :updating_stylesheets
 
-    # Register a callback to be run after 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 [updated_files]
-    # @yieldparam updated_files [<(String, String)>]
-    #   Individual files that were updated.
-    #   The first element of each pair is the source file, the second is the target CSS file.
-    define_callback :updated_stylesheets
-
     # Register a callback to be run after a single stylesheet is updated.
     # The callback is only run if the stylesheet is really updated;
     # if the CSS file is fresh, this won't be run.
@@ -69,29 +60,35 @@ module Sass::Plugin
     # when an exception CSS file is being written.
     # To run an action for those files, use \{#on\_compilation\_error}.
     #
-    # @yield [template, css, sourcemap]
+    # @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.
-    # @yieldparam sourcemap [String]
-    #   The location of the sourcemap being generated, if any.
     define_callback :updated_stylesheet
 
-    # Register a callback to be run when compilation starts.
+    # 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.
     #
-    # In combination with on_updated_stylesheet, this could be used
-    # to collect compilation statistics like timing or to take a
-    # diff of the changes to the output file.
+    # 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, sourcemap]
+    # @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.
-    # @yieldparam sourcemap [String]
-    #   The location of the sourcemap being generated, if any.
-    define_callback :compilation_starting
+    define_callback :updating_stylesheet
+
+    def on_updating_stylesheet_with_deprecation_warning(&block)
+      Sass::Util.sass_warn("Sass::Compiler#on_updating_stylesheet callback is deprecated and will be removed in a future release. Use Sass::Compiler#on_updated_stylesheet instead, which is run after stylesheet compilation.")
+      on_updating_stylesheet_without_deprecation_warning(&block)
+    end
+    alias_method :on_updating_stylesheet_without_deprecation_warning, :on_updating_stylesheet
+    alias_method :on_updating_stylesheet, :on_updating_stylesheet_with_deprecation_warning
 
     # Register a callback to be run when Sass decides not to update a stylesheet.
     # In particular, the callback is run when Sass finds that
@@ -165,97 +162,49 @@ module Sass::Plugin
     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
-    # and when the compiler cleans the output files.
+    # 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
 
-    # Register a callback to be run when Sass deletes a sourcemap file.
-    # This happens when the corresponding Sass/SCSS file has been deleted
-    # and when the compiler cleans the output files.
-    #
-    # @yield [filename]
-    # @yieldparam filename [String]
-    #   The location of the sourcemap file that was deleted.
-    define_callback :deleting_sourcemap
-
     # Updates out-of-date stylesheets.
     #
-    # Checks each Sass/SCSS file in
-    # {file:SASS_REFERENCE.md#template_location-option `:template_location`}
+    # Checks each Sass/SCSS file in {file:SASS_REFERENCE.md#template_location-option `:template_location`}
     # to see if it's been modified more recently than the corresponding CSS file
     # in {file:SASS_REFERENCE.md#css_location-option `:css_location`}.
     # If it has, it updates the CSS file.
     #
-    # @param individual_files [Array<(String, String[, String])>]
+    # @param individual_files [Array<(String, String)>]
     #   A list of files to check 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.
-    #   The third string, if provided, is the location of the Sourcemap file.
     def update_stylesheets(individual_files = [])
+      individual_files = individual_files.dup
       Sass::Plugin.checked_for_updates = true
       staleness_checker = StalenessChecker.new(engine_options)
 
-      files = file_list(individual_files)
-      run_updating_stylesheets(files)
-
-      updated_stylesheets = []
-      files.each do |file, css, sourcemap|
-        # TODO: Does staleness_checker need to check the sourcemap file as well?
-        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
-          # XXX For consistency, this should return the sourcemap too, but it would
-          # XXX be an API change.
-          updated_stylesheets << [file, css]
-          update_stylesheet(file, css, sourcemap)
-        else
-          run_not_updating_stylesheet(file, css, sourcemap)
-        end
-      end
-      run_updated_stylesheets(updated_stylesheets)
-    end
-
-    # Construct a list of files that might need to be compiled
-    # from the provided individual_files and the template_locations.
-    #
-    # Note: this method does not cache the results as they can change
-    # across invocations when sass files are added or removed.
-    #
-    # @param individual_files [Array<(String, String[, String])>]
-    #   A list of files to check 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.
-    #   The third string, if provided, is the location of the Sourcemap file.
-    # @return [Array<(String, String, String)>]
-    #   A list of [sass_file, css_file, sourcemap_file] tuples similar
-    #   to what was passed in, but expanded to include the current state
-    #   of the directories being updated.
-    def file_list(individual_files = [])
-      files = individual_files.map do |tuple|
-        if tuple.size < 3
-          [tuple[0], tuple[1], Sass::Util.sourcemap_name(tuple[1])]
-        else
-          tuple
-        end
-      end
-
       template_location_array.each do |template_location, css_location|
         Sass::Util.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
           # Get the relative path to the file
-          name = Sass::Util.pathname(file).relative_path_from(
-            Sass::Util.pathname(template_location.to_s)).to_s
+          name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
           css = css_filename(name, css_location)
-          sourcemap = Sass::Util.sourcemap_name(css) unless engine_options[:sourcemap] == :none
-          files << [file, css, sourcemap]
+          individual_files << [file, css]
+        end
+      end
+
+      run_updating_stylesheets individual_files
+
+      individual_files.each do |file, css|
+        if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
+          update_stylesheet(file, css)
+        else
+          run_not_updating_stylesheet(file, css)
         end
       end
-      files
     end
 
     # Watches the template directory (or directories)
@@ -276,62 +225,73 @@ module Sass::Plugin
     # The version of Listen 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[, String])>]
-    #   A list of files to check for updates
+    # @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.
-    #   The third string, if provided, is the location of the Sourcemap file.
-    # @param options [Hash] The options that control how watching works.
-    # @option options [Boolean] :skip_initial_update
-    #   Don't do an initial update when starting the watcher when true
-    def watch(individual_files = [], options = {})
-      options, individual_files = individual_files, [] if individual_files.is_a?(Hash)
-      update_stylesheets(individual_files) unless options[:skip_initial_update]
-
-      directories = watched_paths
-      individual_files.each do |(source, _, _)|
-        directories << File.dirname(File.expand_path(source))
-      end
-      directories = remove_redundant_directories(directories)
+    def watch(individual_files = [])
+      update_stylesheets(individual_files)
+
+      load_listen!
 
-      # A Listen version prior to 2.0 will write a test file to a directory to
-      # see if a watcher supports watching that directory. That breaks horribly
-      # on read-only directories, so we filter those out.
-      unless Sass::Util.listen_geq_2?
-        directories = directories.select {|d| File.directory?(d) && File.writable?(d)}
+      template_paths = template_locations # cache the locations
+      individual_files_hash = individual_files.inject({}) do |h, files|
+        parent = File.dirname(files.first)
+        (h[parent] ||= []) << files unless template_paths.include?(parent)
+        h
       end
+      directories = template_paths + individual_files_hash.keys +
+        [{:relative_paths => true}]
 
       # TODO: Keep better track of what depends on what
       # so we don't have to run a global update every time anything changes.
-      # XXX The :additional_watch_paths option exists for Compass to use until
-      # a deprecated feature is removed. It may be removed without warning.
-      listener_args = directories +
-                      Array(options[:additional_watch_paths]) +
-                      [{:relative_paths => false}]
-
-      # The native windows listener is much slower than the polling option, according to
-      # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
-      poll = @options[:poll] || Sass::Util.windows?
-      if poll && Sass::Util.listen_geq_2?
-        # In Listen 2.0.0 and on, :force_polling is an option. In earlier
-        # versions, it's a method on the listener (called below).
-        listener_args.last[:force_polling] = true
-      end
+      listener = Listen::MultiListener.new(*directories) do |modified, added, removed|
+        modified.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+          else
+            next unless f =~ /\.s[ac]ss$/
+          end
+          run_template_modified(f)
+        end
 
-      listener = create_listener(*listener_args) do |modified, added, removed|
-        on_file_changed(individual_files, modified, added, removed)
-        yield(modified, added, removed) if block_given?
-      end
+        added.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+          else
+            next unless f =~ /\.s[ac]ss$/
+          end
+          run_template_created(f)
+        end
 
-      if poll && !Sass::Util.listen_geq_2?
-        # In Listen 2.0.0 and on, :force_polling is an option (set above). In
-        # earlier versions, it's a method on the listener.
-        listener.force_polling(true)
+        removed.each do |f|
+          parent = File.dirname(f)
+          if files = individual_files_hash[parent]
+            next unless files.first == f
+            try_delete_css files[1]
+          else
+            next unless f =~ /\.s[ac]ss$/
+            try_delete_css f.gsub(/\.s[ac]ss$/, '.css')
+          end
+          run_template_deleted(f)
+        end
+
+        update_stylesheets(individual_files)
       end
 
-      listen_to(listener)
+      # The native windows listener is much slower than the polling
+      # option, according to https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e#commitcomment-1295118
+      listener.force_polling(true) if @options[:poll] || Sass::Util.windows?
+
+      begin
+        listener.start
+      rescue Exception => e
+        raise e unless e.is_a?(Interrupt)
+      end
     end
 
     # Non-destructively modifies \{#options} so that default values are properly set,
@@ -342,8 +302,6 @@ module Sass::Plugin
     def engine_options(additional_options = {})
       opts = options.merge(additional_options)
       opts[:load_paths] = load_paths(opts)
-      options[:sourcemap] = :auto if options[:sourcemap] == true
-      options[:sourcemap] = :none if options[:sourcemap] == false
       opts
     end
 
@@ -352,186 +310,81 @@ module Sass::Plugin
       StalenessChecker.stylesheet_needs_update?(css_file, template_file)
     end
 
-    # Remove all output files that would be created by calling update_stylesheets, if they exist.
-    #
-    # This method runs the deleting_css and deleting_sourcemap callbacks for
-    # the files that are deleted.
-    #
-    # @param individual_files [Array<(String, String[, String])>]
-    #   A list of files to check 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.
-    #   The third string, if provided, is the location of the Sourcemap file.
-    def clean(individual_files = [])
-      file_list(individual_files).each do |(_, css_file, sourcemap_file)|
-        if File.exist?(css_file)
-          run_deleting_css css_file
-          File.delete(css_file)
-        end
-        if sourcemap_file && File.exist?(sourcemap_file)
-          run_deleting_sourcemap sourcemap_file
-          File.delete(sourcemap_file)
-        end
-      end
-      nil
-    end
-
     private
 
-    def create_listener(*args, &block)
-      Sass::Util.load_listen!
-      if Sass::Util.listen_geq_2?
-        # Work around guard/listen#243.
-        options = args.pop if args.last.is_a?(Hash)
-        args.map do |dir|
-          Listen.to(dir, options, &block)
+    def load_listen!
+      if defined?(gem)
+        begin
+          gem 'listen', '~> 0.7'
+          require 'listen'
+        rescue Gem::LoadError
+          dir = Sass::Util.scope("vendor/listen/lib")
+          $LOAD_PATH.unshift dir
+          begin
+            require 'listen'
+          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 listen" to get it.'
+              end
+            raise e
+          end
         end
       else
-        Listen::Listener.new(*args, &block)
-      end
-    end
-
-    def listen_to(listener)
-      if Sass::Util.listen_geq_2?
-        listener.map {|l| l.start}.each {|thread| thread.join}
-      else
-        listener.start!
-      end
-    rescue Interrupt
-      # Squelch Interrupt for clean exit from Listen::Listener
-    end
-
-    def remove_redundant_directories(directories)
-      dedupped = []
-      directories.each do |new_directory|
-        # no need to add a directory that is already watched.
-        next if dedupped.any? do |existing_directory|
-          child_of_directory?(existing_directory, new_directory)
-        end
-        # get rid of any sub directories of this new directory
-        dedupped.reject! do |existing_directory|
-          child_of_directory?(new_directory, existing_directory)
-        end
-        dedupped << new_directory
-      end
-      dedupped
-    end
-
-    def on_file_changed(individual_files, modified, added, removed)
-      recompile_required = false
-
-      modified.uniq.each do |f|
-        next unless watched_file?(f)
-        recompile_required = true
-        run_template_modified(relative_to_pwd(f))
-      end
-
-      added.uniq.each do |f|
-        next unless watched_file?(f)
-        recompile_required = true
-        run_template_created(relative_to_pwd(f))
-      end
-
-      removed.uniq.each do |f|
-        run_template_deleted(relative_to_pwd(f))
-        if (files = individual_files.find {|(source, _, _)| File.expand_path(source) == f})
-          recompile_required = true
-          # This was a file we were watching explicitly and compiling to a particular location.
-          # Delete the corresponding file.
-          try_delete_css files[1]
-        else
-          next unless watched_file?(f)
-          recompile_required = true
-          # Look for the sass directory that contained the sass file
-          # And try to remove the css file that corresponds to it
-          template_location_array.each do |(sass_dir, css_dir)|
-            sass_dir = File.expand_path(sass_dir)
-            if child_of_directory?(sass_dir, f)
-              remainder = f[(sass_dir.size + 1)..-1]
-              try_delete_css(css_filename(remainder, css_dir))
-              break
-            end
+        begin
+          require 'listen'
+        rescue LoadError => e
+          dir = Sass::Util.scope("vendor/listen/lib")
+          if $LOAD_PATH.include?(dir)
+            raise e unless File.exists?(scope(".git"))
+            e.message << "\n" <<
+              'Run "git submodule update --init" to get the recommended version.'
+          else
+            $LOAD_PATH.unshift dir
+            retry
           end
         end
       end
-
-      if recompile_required
-        # In case a file we're watching is removed and then recreated we
-        # prune out the non-existant files here.
-        watched_files_remaining = individual_files.select {|(source, _, _)| File.exist?(source)}
-        update_stylesheets(watched_files_remaining)
-      end
     end
 
-    def update_stylesheet(filename, css, sourcemap)
+    def update_stylesheet(filename, css)
       dir = File.dirname(css)
-      unless File.exist?(dir)
+      unless File.exists?(dir)
         run_creating_directory dir
         FileUtils.mkdir_p dir
       end
 
       begin
         File.read(filename) unless File.readable?(filename) # triggers an error for handling
-        engine_opts = engine_options(:css_filename => css,
-                                     :filename => filename,
-                                     :sourcemap_filename => sourcemap)
-        mapping = nil
-        run_compilation_starting(filename, css, sourcemap)
-        engine = Sass::Engine.for_file(filename, engine_opts)
-        if sourcemap
-          rendered, mapping = engine.render_with_sourcemap(File.basename(sourcemap))
-        else
-          rendered = engine.render
-        end
-      rescue StandardError => e
+        engine_opts = engine_options(:css_filename => css, :filename => filename)
+        result = Sass::Engine.for_file(filename, engine_opts).render
+      rescue Exception => e
         compilation_error_occured = true
-        run_compilation_error e, filename, css, sourcemap
-        raise e unless options[:full_exception]
-        rendered = Sass::SyntaxError.exception_to_css(e, options[:line] || 1)
+        run_compilation_error e, filename, css
+        result = Sass::SyntaxError.exception_to_css(e, options)
+      else
+        run_updating_stylesheet filename, css
       end
 
-      write_file(css, rendered)
-      if mapping
-        write_file(sourcemap, mapping.to_json(
-            :css_path => css, :sourcemap_path => sourcemap, :type => options[:sourcemap]))
-      end
-      run_updated_stylesheet(filename, css, sourcemap) unless compilation_error_occured
+      write_file(css, result)
+      run_updated_stylesheet(filename, css) unless compilation_error_occured
     end
 
-    def write_file(fileName, content)
+    def write_file(css, content)
       flag = 'w'
       flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
-      File.open(fileName, flag) do |file|
+      File.open(css, flag) do |file|
         file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
         file.print(content)
       end
     end
 
     def try_delete_css(css)
-      if File.exist?(css)
-        run_deleting_css css
-        File.delete css
-      end
-      map = Sass::Util.sourcemap_name(css)
-      if File.exist?(map)
-        run_deleting_sourcemap map
-        File.delete map
-      end
-    end
-
-    def watched_file?(file)
-      normalized_load_paths.find {|lp| lp.watched_file?(file)}
-    end
-
-    def watched_paths
-      @watched_paths ||= normalized_load_paths.map {|lp| lp.directories_to_watch}.compact.flatten
-    end
-
-    def normalized_load_paths
-      @normalized_load_paths ||=
-        Sass::Engine.normalize_options(:load_paths => load_paths)[:load_paths]
+      return unless File.exists?(css)
+      run_deleting_css css
+      File.delete css
     end
 
     def load_paths(opts = options)
@@ -547,19 +400,7 @@ module Sass::Plugin
     end
 
     def css_filename(name, path)
-      "#{path}#{File::SEPARATOR unless path.end_with?(File::SEPARATOR)}#{name}".
-        gsub(/\.s[ac]ss$/, '.css')
-    end
-
-    def relative_to_pwd(f)
-      Sass::Util.pathname(f).relative_path_from(Sass::Util.pathname(Dir.pwd)).to_s
-    rescue ArgumentError # when a relative path cannot be computed
-      f
-    end
-
-    def child_of_directory?(parent, child)
-      parent_dir = parent.end_with?(File::SEPARATOR) ? parent : (parent + File::SEPARATOR)
-      child.start_with?(parent_dir) || parent == child
+      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
     end
   end
 end