brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/logger.rb

@@ -0,0 +1,12 @@
+module Sass::Logger; end
+
+require "sass/logger/log_level"
+require "sass/logger/base"
+
+module Sass
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = Sass::Logger::Base.new
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/logger/base.rb

@@ -0,0 +1,30 @@
+require 'sass/logger/log_level'
+
+class Sass::Logger::Base
+  include Sass::Logger::LogLevel
+
+  attr_accessor :log_level
+  attr_accessor :disabled
+
+  log_level :trace
+  log_level :debug
+  log_level :info
+  log_level :warn
+  log_level :error
+
+  def initialize(log_level = :debug)
+    self.log_level = log_level
+  end
+
+  def logging_level?(level)
+    !disabled && self.class.log_level?(level, log_level)
+  end
+
+  def log(level, message)
+    _log(level, message) if logging_level?(level)
+  end
+
+  def _log(level, message)
+    Kernel.warn(message)
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/logger/log_level.rb

@@ -0,0 +1,45 @@
+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_level?(level, min_level)
+          log_levels[level] >= log_levels[min_level]
+        end
+
+        def log_level(name, options = {})
+          if options[:prepend]
+            level = log_levels.values.min
+            level = level.nil? ? 0 : level - 1
+          else
+            level = log_levels.values.max
+            level = level.nil? ? 0 : level + 1
+          end
+          log_levels.update(name => level)
+          define_logger(name)
+        end
+
+        def define_logger(name, options = {})
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(message)
+              #{options.fetch(:to, :log)}(#{name.inspect}, message)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/media.rb

@@ -0,0 +1,210 @@
+# A namespace for the `@media` query parse tree.
+module Sass::Media
+  # A comma-separated list of queries.
+  #
+  #     media_query [ ',' S* media_query ]*
+  class QueryList
+    # The queries contained in this list.
+    #
+    # @return [Array<Query>]
+    attr_accessor :queries
+
+    # @param queries [Array<Query>] See \{#queries}
+    def initialize(queries)
+      @queries = queries
+    end
+
+    # Merges this query list with another. The returned query list
+    # queries for the intersection between the two inputs.
+    #
+    # Both query lists should be resolved.
+    #
+    # @param other [QueryList]
+    # @return [QueryList?] The merged list, or nil if there is no intersection.
+    def merge(other)
+      new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact
+      return if new_queries.empty?
+      QueryList.new(new_queries)
+    end
+
+    # Returns the CSS for the media query list.
+    #
+    # @return [String]
+    def to_css
+      queries.map {|q| q.to_css}.join(', ')
+    end
+
+    # Returns the Sass/SCSS code for the media query list.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options)
+      queries.map {|q| q.to_src(options)}.join(', ')
+    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.
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    def to_a
+      Sass::Util.intersperse(queries.map {|q| q.to_a}, ', ').flatten
+    end
+
+    # Returns a deep copy of this query list and all its children.
+    #
+    # @return [QueryList]
+    def deep_copy
+      QueryList.new(queries.map {|q| q.deep_copy})
+    end
+  end
+
+  # A single media query.
+  #
+  #     [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
+  class Query
+    # The modifier for the query.
+    #
+    # When parsed as Sass code, this contains strings and SassScript nodes. When
+    # parsed as CSS, it contains a single string (accessible via
+    # \{#resolved_modifier}).
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :modifier
+
+    # The type of the query (e.g. `"screen"` or `"print"`).
+    #
+    # When parsed as Sass code, this contains strings and SassScript nodes. When
+    # parsed as CSS, it contains a single string (accessible via
+    # \{#resolved_type}).
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :type
+
+    # The trailing expressions in the query.
+    #
+    # 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>>]
+    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}
+    def initialize(modifier, type, expressions)
+      @modifier = modifier
+      @type = type
+      @expressions = expressions
+    end
+
+    # See \{#modifier}.
+    # @return [String]
+    def resolved_modifier
+      # modifier should contain only a single string
+      modifier.first || ''
+    end
+
+    # See \{#type}.
+    # @return [String]
+    def resolved_type
+      # type should contain only a single string
+      type.first || ''
+    end
+
+    # Merges this query with another. The returned query queries for
+    # the intersection between the two inputs.
+    #
+    # Both queries should be resolved.
+    #
+    # @param other [Query]
+    # @return [Query?] The merged query, or nil if there is no intersection.
+    def merge(other)
+      m1, t1 = resolved_modifier.downcase, resolved_type.downcase
+      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')
+        return if t1 == t2
+        type = m1 == 'not' ? t2 : t1
+        mod = m1 == 'not' ? m2 : m1
+      elsif m1 == 'not' && m2 == 'not'
+        # CSS has no way of representing "neither screen nor print"
+        return unless t1 == t2
+        type = t1
+        mod = 'not'
+      elsif t1 != t2
+        return
+      else # t1 == t2, neither m1 nor m2 are "not"
+        type = t1
+        mod = m1.empty? ? m2 : m1
+      end
+      Query.new([mod], [type], other.expressions + expressions)
+    end
+
+    # Returns the CSS for the media query.
+    #
+    # @return [String]
+    def to_css
+      css = ''
+      css << resolved_modifier
+      css << ' ' unless resolved_modifier.empty?
+      css << resolved_type
+      css << ' and ' unless resolved_type.empty? || expressions.empty?
+      css << expressions.map do |e|
+        # 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
+      end.join(' and ')
+      css
+    end
+
+    # Returns the Sass/SCSS code for the media query.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options)
+      src = ''
+      src << Sass::Media._interp_to_src(modifier, options)
+      src << ' ' unless modifier.empty?
+      src << Sass::Media._interp_to_src(type, options)
+      src << ' and ' unless type.empty? || expressions.empty?
+      src << expressions.map do |e|
+        Sass::Media._interp_to_src(e, options)
+      end.join(' and ')
+      src
+    end
+
+    # @see \{MediaQuery#to\_a}
+    def to_a
+      res = []
+      res += modifier
+      res << ' ' unless modifier.empty?
+      res += type
+      res << ' and ' unless type.empty? || expressions.empty?
+      res += Sass::Util.intersperse(expressions, ' and ').flatten
+      res
+    end
+
+    # Returns a deep copy of this query and all its children.
+    #
+    # @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}})
+    end
+  end
+
+  # Converts an interpolation array to source.
+  #
+  # @param interp [Array<String, Sass::Script::Tree::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
+  end
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/plugin.rb

@@ -0,0 +1,134 @@
+require 'fileutils'
+
+require 'sass'
+require 'sass/plugin/compiler'
+
+module Sass
+  # 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
+  # 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}.
+  # Other frameworks must enable it explicitly; see {Sass::Plugin::Rack}.
+  #
+  # This module has a large set of callbacks available
+  # to allow users to run code (such as logging) when certain things happen.
+  # 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}"
+  #   end
+  #   Sass::Plugin.update_stylesheets
+  #     #=> 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
+    extend self
+
+    @checked_for_updates = false
+
+    # Whether or not Sass has **ever** checked if the stylesheets need to be updated
+    # (in this Ruby instance).
+    #
+    # @return [Boolean]
+    attr_accessor :checked_for_updates
+
+    # Same as \{#update\_stylesheets}, but respects \{#checked\_for\_updates}
+    # and the {file:SASS_REFERENCE.md#always_update-option `:always_update`}
+    # and {file:SASS_REFERENCE.md#always_check-option `:always_check`} options.
+    #
+    # @see #update_stylesheets
+    def check_for_updates
+      return unless !Sass::Plugin.checked_for_updates ||
+          Sass::Plugin.options[:always_update] || Sass::Plugin.options[:always_check]
+      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`}
+    # 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)>]
+    #   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.
+    def update_stylesheets(individual_files = [])
+      return if options[:never_update]
+      compiler.update_stylesheets(individual_files)
+    end
+
+    # Updates all stylesheets, even those that aren't out-of-date.
+    # Ignores the cache.
+    #
+    # @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.
+    # @see #update_stylesheets
+    def force_update_stylesheets(individual_files = [])
+      Compiler.new(
+        options.dup.merge(
+          :never_update => false,
+          :always_update => true,
+          :cache => false)).update_stylesheets(individual_files)
+    end
+
+    # All other method invocations are proxied to the \{#compiler}.
+    #
+    # @see #compiler
+    # @see Sass::Plugin::Compiler
+    def method_missing(method, *args, &block)
+      if compiler.respond_to?(method)
+        compiler.send(method, *args, &block)
+      else
+        super
+      end
+    end
+
+    # For parity with method_missing
+    def respond_to?(method)
+      super || compiler.respond_to?(method)
+    end
+
+    # There's a small speedup by not using method missing for frequently delegated methods.
+    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?
+elsif defined?(Merb::Plugins)
+  require 'sass/plugin/merb'
+else
+  require 'sass/plugin/generic'
+end

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/plugin/compiler.rb

@@ -0,0 +1,582 @@
+require 'fileutils'
+
+require 'sass'
+# XXX CE: is this still necessary now that we have the compiler class?
+require 'sass/callbacks'
+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.
+  #
+  # {Sass::Plugin} uses this class to update stylesheets for a single application.
+  # Unlike {Sass::Plugin}, though, the Compiler class has no global state,
+  # and so multiple instances may be created and used independently.
+  #
+  # If you need to compile a Sass string into CSS,
+  # please see the {Sass::Engine} class.
+  #
+  # Unlike {Sass::Plugin}, this class doesn't keep track of
+  # whether or how many times a stylesheet should be updated.
+  # Therefore, the following `Sass::Plugin` options are ignored by the Compiler:
+  #
+  # * `:never_update`
+  # * `:always_check`
+  class Compiler
+    include Configuration
+    extend Sass::Callbacks
+
+    # Creates a new compiler.
+    #
+    # @param opts [{Symbol => Object}]
+    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    def initialize(opts = {})
+      @watched_files = Set.new
+      options.merge!(opts)
+    end
+
+    # 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 [files]
+    # @yieldparam files [<(String, String, String)>]
+    #   Individual files to be updated. Files in directories specified are included in this list.
+    #   The first element of each pair is the source file,
+    #   the second is the target CSS file,
+    #   the third is the target sourcemap 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.
+    #
+    # 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]
+    # @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.
+    #
+    # 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.
+    #
+    # @yield [template, css, sourcemap]
+    # @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
+
+    # 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
+    # and when the compiler cleans the output files.
+    #
+    # @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`}
+    # 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])>]
+    #   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 = [])
+      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 engine_options[:sourcemap] == :none
+          tuple[0..1]
+        elsif tuple.size < 3
+          [tuple[0], tuple[1], Sass::Util.sourcemap_name(tuple[1])]
+        else
+          tuple.dup
+        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.relative_path_from(file, template_location).to_s
+          css = css_filename(name, css_location)
+          sourcemap = Sass::Util.sourcemap_name(css) unless engine_options[:sourcemap] == :none
+          files << [file, css, sourcemap]
+        end
+      end
+      files
+    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}.
+    #
+    # Note that `watch` uses the [Listen](http://github.com/guard/listen) library
+    # to monitor the filesystem for changes.
+    # Listen isn't loaded until `watch` is run.
+    # 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
+    #   **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 = {})
+      @inferred_directories = []
+      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, _, _)|
+        source = File.expand_path(source)
+        @watched_files << Sass::Util.realpath(source).to_s
+        @inferred_directories << File.dirname(source)
+      end
+
+      directories += @inferred_directories
+      directories = remove_redundant_directories(directories)
+
+      # 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)}
+      end
+
+      # 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 = create_listener(*listener_args) do |modified, added, removed|
+        on_file_changed(individual_files, modified, added, removed)
+        yield(modified, added, removed) if block_given?
+      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)
+      end
+
+      listen_to(listener)
+    end
+
+    # Non-destructively modifies \{#options} so that default values are properly set,
+    # and returns the result.
+    #
+    # @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.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
+
+    # Compass expects this to exist
+    def stylesheet_needs_update?(css_file, template_file)
+      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)
+        end
+      else
+        Listen::Listener.new(*args, &block)
+      end
+    end
+
+    def listen_to(listener)
+      if Sass::Util.listen_geq_2?
+        listener.map {|l| l.start}
+        sleep
+      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|
+        next unless watched_file?(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)
+            next unless child_of_directory?(sass_dir, f)
+            remainder = f[(sass_dir.size + 1)..-1]
+            try_delete_css(css_filename(remainder, css_dir))
+            break
+          end
+        end
+      end
+
+      return unless 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
+
+    def update_stylesheet(filename, css, sourcemap)
+      dir = File.dirname(css)
+      unless File.exist?(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
+        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)
+      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
+    end
+
+    def write_file(fileName, content)
+      flag = 'w'
+      flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
+      File.open(fileName, 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)
+
+      return unless File.exist?(map)
+
+      run_deleting_sourcemap map
+      File.delete map
+    end
+
+    def watched_file?(file)
+      @watched_files.include?(file) ||
+        normalized_load_paths.any? {|lp| lp.watched_file?(file)} ||
+        @inferred_directories.any? {|d| sass_file_in_directory?(d, file)}
+    end
+
+    def sass_file_in_directory?(directory, filename)
+      filename =~ /\.s[ac]ss$/ && filename.start_with?(directory + File::SEPARATOR)
+    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]
+    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}#{File::SEPARATOR unless path.end_with?(File::SEPARATOR)}#{name}".
+        gsub(/\.s[ac]ss$/, '.css')
+    end
+
+    def relative_to_pwd(f)
+      Sass::Util.relative_path_from(f, 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
+    end
+  end
+end