sass 3.1.0 → 3.3.0

data/lib/sass/plugin/compiler.rb

@@ -7,7 +7,6 @@ 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.
@@ -26,19 +25,18 @@ module Sass::Plugin
   # * `:never_update`
   # * `:always_check`
   class Compiler
-    include Sass::Util
     include Configuration
     extend Sass::Callbacks
 
     # Creates a new compiler.
     #
-    # @param options [{Symbol => Object}]
+    # @param opts [{Symbol => Object}]
     #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-    def initialize(options = {})
-      self.options.merge!(options)
+    def initialize(opts = {})
+      options.merge!(opts)
     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.
@@ -51,8 +49,8 @@ module Sass::Plugin
     #   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;
+    # 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}
@@ -60,12 +58,14 @@ 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]
+    # @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.
-    define_callback :updating_stylesheet
+    # @yieldparam sourcemap [String]
+    #   The location of the sourcemap being generated, if any.
+    define_callback :updated_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
@@ -146,9 +146,18 @@ module Sass::Plugin
     #   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.
+    #
+    # @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.
@@ -160,28 +169,26 @@ module Sass::Plugin
     #   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 = [])
-      run_updating_stylesheets individual_files
+      individual_files = individual_files.dup
       Sass::Plugin.checked_for_updates = true
       staleness_checker = StalenessChecker.new(engine_options)
 
-      individual_files.each do |t, c|
-        if options[:always_update] || staleness_checker.stylesheet_needs_update?(c, t)
-          update_stylesheet(t, c)
-        end
-      end
-
       template_location_array.each do |template_location, css_location|
-
-        Dir.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
+        Sass::Util.glob(File.join(template_location, "**", "[^_]*.s[ca]ss")).sort.each do |file|
           # Get the relative path to the file
           name = file.sub(template_location.to_s.sub(/\/*$/, '/'), "")
           css = css_filename(name, css_location)
+          sourcemap = Sass::Util.sourcemap_name(css) if engine_options[:sourcemap]
+          individual_files << [file, css, sourcemap]
+        end
+      end
 
-          if options[:always_update] || staleness_checker.stylesheet_needs_update?(css, file)
-            update_stylesheet file, css
-          else
-            run_not_updating_stylesheet file, css
-          end
+      individual_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)
+          update_stylesheet(file, css, sourcemap)
+        else
+          run_not_updating_stylesheet(file, css, sourcemap)
         end
       end
     end
@@ -198,10 +205,10 @@ module Sass::Plugin
     #
     # Before the watching starts in earnest, `watch` calls \{#update\_stylesheets}.
     #
-    # Note that `watch` uses the [FSSM](http://github.com/ttilley/fssm) library
+    # Note that `watch` uses the [Listen](http://github.com/guard/listen) library
     # to monitor the filesystem for changes.
-    # FSSM isn't loaded until `watch` is run.
-    # The version of FSSM distributed with Sass is loaded by default,
+    # 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)>]
@@ -213,79 +220,78 @@ module Sass::Plugin
     def watch(individual_files = [])
       update_stylesheets(individual_files)
 
-      begin
-        require 'fssm'
-      rescue LoadError => e
-        dir = Sass::Util.scope("vendor/fssm/lib")
-        if $LOAD_PATH.include?(dir)
-          e.message << "\n" <<
-            if File.exists?(scope(".git"))
-              'Run "git submodule update --init" to get the recommended version.'
-            else
-              'Run "gem install fssm" to get it.'
-            end
-          raise e
-        else
-          $LOAD_PATH.unshift dir
-          retry
-        end
-      end
-
-      unless individual_files.empty? && FSSM::Backends::Default.name == "FSSM::Backends::FSEvents"
-        # As of FSSM 0.1.4, it doesn't support FSevents on individual files,
-        # but it also isn't smart enough to switch to polling itself.
-        require 'fssm/backends/polling'
-        Sass::Util.silence_warnings do
-          FSSM::Backends.const_set(:Default, FSSM::Backends::Polling)
-        end
+      directories = watched_paths
+      individual_files.each do |(source, _, _)|
+        directories << File.dirname(File.expand_path(source))
       end
+      directories = remove_redundant_directories(directories)
 
       # TODO: Keep better track of what depends on what
       # so we don't have to run a global update every time anything changes.
-      FSSM.monitor do |mon|
-        template_location_array.each do |template_location, css_location|
-          mon.path template_location do |path|
-            path.glob '**/*.s[ac]ss'
-
-            path.update do |base, relative|
-              run_template_modified File.join(base, relative)
-              update_stylesheets(individual_files)
-            end
+      listener_args = directories + [{: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
 
-            path.create do |base, relative|
-              run_template_created File.join(base, relative)
-              update_stylesheets(individual_files)
-            end
+      listener = create_listener(*listener_args) do |modified, added, removed|
+        recompile_required = false
 
-            path.delete do |base, relative|
-              run_template_deleted File.join(base, relative)
-              css = File.join(css_location, relative.gsub(/\.s[ac]ss$/, '.css'))
-              try_delete_css css
-              update_stylesheets(individual_files)
-            end
-          end
+        modified.uniq.each do |f|
+          next unless watched_file?(f)
+          recompile_required = true
+          run_template_modified(relative_to_pwd(f))
         end
 
-        individual_files.each do |template, css|
-          mon.file template do |path|
-            path.update do
-              run_template_modified template
-              update_stylesheets(individual_files)
-            end
-
-            path.create do
-              run_template_created template
-              update_stylesheets(individual_files)
-            end
+        added.uniq.each do |f|
+          next unless watched_file?(f)
+          recompile_required = true
+          run_template_created(relative_to_pwd(f))
+        end
 
-            path.delete do
-              run_template_deleted template
-              try_delete_css css
-              update_stylesheets(individual_files)
+        removed.uniq.each do |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
             end
           end
+          run_template_deleted(relative_to_pwd(f))
+        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.exists?(source)}
+          update_stylesheets(watched_files_remaining)
         end
       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,
@@ -306,7 +312,46 @@ module Sass::Plugin
 
     private
 
-    def update_stylesheet(filename, css)
+    def create_listener(*args, &block)
+      require 'listen'
+      if Sass::Util.listen_geq_2?
+        Listen.to(*args, &block)
+      else
+        Listen::Listener.new(*args, &block)
+      end
+    end
+
+    def listen_to(listener)
+      if Sass::Util.listen_geq_2?
+        listener.start
+        listener.thread.join
+        listener.stop # Partially work around guard/listen#146
+      else
+        begin
+          listener.start!
+        rescue Interrupt
+          # Squelch Interrupt for clean exit from Listen::Listener
+        end
+      end
+    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 update_stylesheet(filename, css, sourcemap)
       dir = File.dirname(css)
       unless File.exists?(dir)
         run_creating_directory dir
@@ -315,28 +360,61 @@ module Sass::Plugin
 
       begin
         File.read(filename) unless File.readable?(filename) # triggers an error for handling
-        engine_opts = engine_options(:css_filename => css, :filename => filename)
-        result = Sass::Engine.for_file(filename, engine_opts).render
-      rescue Exception => e
-        run_compilation_error e, filename, css
-        result = Sass::SyntaxError.exception_to_css(e, options)
-      else
-        run_updating_stylesheet filename, css
+        engine_opts = engine_options(:css_filename => css,
+                                     :filename => filename,
+                                     :sourcemap_filename => sourcemap)
+        mapping = nil
+        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
+        rendered = Sass::SyntaxError.exception_to_css(e, options)
       end
 
-      # Finally, write the file
+      write_file(css, rendered)
+      if mapping
+        write_file(sourcemap, mapping.to_json(:css_path => css, :sourcemap_path => 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(css, flag) do |file|
-        file.set_encoding(result.encoding) unless Sass::Util.ruby1_8?
-        file.print(result)
+      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)
-      return unless File.exists?(css)
-      run_deleting_css css
-      File.delete css
+      if File.exists?(css)
+        run_deleting_css css
+        File.delete css
+      end
+      map = Sass::Util.sourcemap_name(css)
+      if File.exists?(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]
     end
 
     def load_paths(opts = options)
@@ -352,7 +430,19 @@ module Sass::Plugin
     end
 
     def css_filename(name, path)
-      "#{path}/#{name}".gsub(/\.s[ac]ss$/, '.css')
+      "#{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
     end
   end
 end

data/lib/sass/plugin/configuration.rb

@@ -1,11 +1,9 @@
-# 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.
-
 module Sass
   module Plugin
+    # 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.
     module Configuration
-
       # Returns the default options for a {Sass::Plugin::Compiler}.
       #
       # @return [{Symbol => Object}]
@@ -19,7 +17,8 @@ module Sass
         }.freeze
       end
 
-      # Resets the options and {Sass::Callbacks::InstanceMethods#clear_callbacks! clears all callbacks}.
+      # Resets the options and
+      # {Sass::Callbacks::InstanceMethods#clear_callbacks! clears all callbacks}.
       def reset!
         @options = nil
         clear_callbacks!
@@ -31,26 +30,14 @@ module Sass
       # @return [{Symbol => Object}]
       def options
         @options ||= default_options.dup
-        @options[:cache_store] ||= Sass::CacheStores::Filesystem.new(@options[:cache_location])
-        @options
-      end
-
-      # Sets the options hash.
-      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
-      # See {Sass::Plugin::Configuration#reset!}
-      # @deprecated Instead, modify the options hash in-place.
-      # @param value [{Symbol => Object}] The options hash
-      def options=(value)
-        Sass::Util.sass_warn("Setting Sass::Plugin.options is deprecated " +
-                             "and will be removed in a future release.")
-        options.merge!(value)
       end
 
       # Adds a new template-location/css-location mapping.
       # This means that Sass/SCSS files in `template_location`
       # will be compiled to CSS files in `css_location`.
       #
-      # This is preferred over manually manipulating the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
+      # 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]`
@@ -70,7 +57,8 @@ module Sass
       # 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}
+      # 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]`
@@ -114,10 +102,15 @@ module Sass
         options[:template_location] =
           case options[:template_location]
           when nil
-            options[:css_location] ?
-              [[File.join(options[:css_location], 'sass'), options[:css_location]]] : []
-          when String; [[options[:template_location], options[:css_location]]]
-          else; options[:template_location].to_a
+            if options[:css_location]
+              [[File.join(options[:css_location], 'sass'), options[:css_location]]]
+            else
+              []
+            end
+          when String
+            [[options[:template_location], options[:css_location]]]
+          else
+            options[:template_location].to_a
           end
       end
     end

data/lib/sass/plugin/merb.rb

@@ -5,7 +5,7 @@ unless defined?(Sass::MERB_LOADED)
     # Different default options in a m envirionment.
     def default_options
       @default_options ||= begin
-        version = Merb::VERSION.split('.').map { |n| n.to_i }
+        version = Merb::VERSION.split('.').map {|n| n.to_i}
         if version[0] <= 0 && version[1] < 5
           root = MERB_ROOT
           env  = MERB_ENV

data/lib/sass/plugin/staleness_checker.rb

@@ -1,3 +1,5 @@
+require 'thread'
+
 module Sass
   module Plugin
     # The class handles `.s[ca]ss` file staleness checks via their mtime timestamps.
@@ -24,11 +26,13 @@ module Sass
     #   as its instance-level caches are never explicitly expired.
     class StalenessChecker
       @dependencies_cache = {}
+      @dependency_cache_mutex = Mutex.new
 
       class << self
         # TODO: attach this to a compiler instance.
         # @private
         attr_accessor :dependencies_cache
+        attr_reader :dependency_cache_mutex
       end
 
       # Creates a new StalenessChecker
@@ -37,11 +41,13 @@ module Sass
       # @param options [{Symbol => Object}]
       #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
       def initialize(options)
-        @dependencies = self.class.dependencies_cache
+        # URIs that are being actively checked for staleness. Protects against
+        # import loops.
+        @actively_checking = Set.new
 
         # 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.
+        # 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, @parse_trees = {}, {}, {}
         @options = Sass::Engine.normalize_options(options)
       end
@@ -127,7 +133,7 @@ module Sass
           begin
             mtime = importer.mtime(uri, @options)
             if mtime.nil?
-              @dependencies.delete([uri, importer])
+              with_dependency_cache {|cache| cache.delete([uri, importer])}
               nil
             else
               mtime
@@ -136,22 +142,31 @@ module Sass
       end
 
       def dependencies(uri, importer)
-        stored_mtime, dependencies = @dependencies[[uri, importer]]
+        stored_mtime, dependencies =
+          with_dependency_cache {|cache| Sass::Util.destructure(cache[[uri, importer]])}
 
         if !stored_mtime || stored_mtime < mtime(uri, importer)
           dependencies = compute_dependencies(uri, importer)
-          @dependencies[[uri, importer]] = [mtime(uri, importer), dependencies]
+          with_dependency_cache do |cache|
+            cache[[uri, importer]] = [mtime(uri, importer), dependencies]
+          end
         end
 
         dependencies
       end
 
       def dependency_updated?(css_mtime)
-        Proc.new do |uri, importer|
-          sass_mtime = mtime(uri, importer)
-          !sass_mtime ||
-            sass_mtime > css_mtime ||
-            dependencies_stale?(uri, importer, css_mtime)
+        proc do |uri, importer|
+          next true if @actively_checking.include?(uri)
+          begin
+            @actively_checking << uri
+            sass_mtime = mtime(uri, importer)
+            !sass_mtime ||
+              sass_mtime > css_mtime ||
+              dependencies_stale?(uri, importer, css_mtime)
+          ensure
+            @actively_checking.delete uri
+          end
         end
       end
 
@@ -168,6 +183,17 @@ module Sass
       def tree(uri, importer)
         @parse_trees[[uri, importer]] ||= importer.find(uri, @options).to_tree
       end
+
+      # Get access to the global dependency cache in a threadsafe manner.
+      # Inside the block, no other thread can access the dependency cache.
+      #
+      # @yieldparam cache [Hash] The hash that is the global dependency cache
+      # @return The value returned by the block to which this method yields
+      def with_dependency_cache
+        StalenessChecker.dependency_cache_mutex.synchronize do
+          yield StalenessChecker.dependencies_cache
+        end
+      end
     end
   end
 end

data/lib/sass/plugin.rb

@@ -11,7 +11,8 @@ 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
@@ -32,7 +33,6 @@ 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,7 +65,8 @@ 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.
@@ -92,14 +93,10 @@ module Sass
     #   the second is the location of the CSS file that it should be compiled to.
     # @see #update_stylesheets
     def force_update_stylesheets(individual_files = [])
-      old_options = options
-      self.options = options.dup
-      options[:never_update] = false
-      options[:always_update] = true
-      options[:cache] = false
-      update_stylesheets(individual_files)
-    ensure
-      self.options = old_options
+      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}.
@@ -123,11 +120,11 @@ 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
+if defined?(ActionController) && !Sass::Util.ap_geq_3?
   require 'sass/plugin/rails'
 elsif defined?(Merb::Plugins)
   require 'sass/plugin/merb'