sass 3.3.0 → 3.4.0

data/lib/sass/features.rb

@@ -4,7 +4,14 @@ module Sass
   # by providing a feature name.
   module Features
     # This is the set of features that can be detected.
+    #
+    # When this is updated, the documentation of `feature-exists()` should be
+    # updated as well.
     KNOWN_FEATURES = Set[*%w{
+      global-variable-shadowing
+      extend-selector-pseudoclass
+      units-level-3
+      at-error
     }]
 
     # Check if a feature exists by name. This is used to implement

data/lib/sass/importers/base.rb

@@ -124,6 +124,10 @@ module Sass
       # 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
@@ -131,8 +135,9 @@ module Sass
       #   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.
-      def public_url(uri, sourcemap_directory = 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

data/lib/sass/importers/filesystem.rb

@@ -64,17 +64,16 @@ module Sass
           filename.start_with?(root + File::SEPARATOR)
       end
 
-      def public_url(name, sourcemap_directory = nil)
+      def public_url(name, sourcemap_directory)
+        file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
         if sourcemap_directory.nil?
-          warn_about_public_url(name)
+          Sass::Util.file_uri_from_path(file_pathname)
         else
-          file_pathname = Sass::Util.pathname(Sass::Util.absolute_path(name, @root)).cleanpath
-          sourcemap_pathname = Sass::Util.pathname(sourcemap_directory).cleanpath
+          sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
           begin
-            file_pathname.relative_path_from(sourcemap_pathname).to_s
+            Sass::Util.file_uri_from_path(file_pathname.relative_path_from(sourcemap_pathname))
           rescue ArgumentError # when a relative path cannot be constructed
-            warn_about_public_url(name)
-            nil
+            Sass::Util.file_uri_from_path(file_pathname)
           end
         end
       end
@@ -139,15 +138,16 @@ 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' can be in native File::ALT_SEPARATOR form
+        # On windows 'dir' or 'name' 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}"
           Dir[path].map do |full_path|
             full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
-            [Sass::Util.pathname(full_path).cleanpath.to_s, s]
+            [Sass::Util.cleanpath(full_path).to_s, s]
           end
         end
         found = Sass::Util.flatten(found, 1)
@@ -195,22 +195,6 @@ WARNING
         [dirname, basename, extension]
       end
 
-      # Issues a warning about being unable to determine a public url.
-      #
-      # @param uri [String] A URI known to be valid for this importer.
-      # @return [NilClass] nil
-      def warn_about_public_url(uri)
-        @warnings_issued ||= Set.new
-        unless @warnings_issued.include?(uri)
-          Sass::Util.sass_warn <<WARNING
-WARNING: Couldn't determine public URL for "#{uri}" while generating sourcemap.
-  Without a public URL, there's nothing for the source map to link to.
-WARNING
-          @warnings_issued << uri
-        end
-        nil
-      end
-
       private
 
       def _find(dir, name, options)

data/lib/sass/importers.rb

@@ -20,4 +20,3 @@ end
 
 require 'sass/importers/base'
 require 'sass/importers/filesystem'
-require 'sass/importers/deprecated_path'

data/lib/sass/media.rb

@@ -205,9 +205,6 @@ module Sass::Media
   # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
   # @return [String]
   def self._interp_to_src(interp, options)
-    interp.map do |r|
-      next r if r.is_a?(String)
-      "\#{#{r.to_sass(options)}}"
-    end.join
+    interp.map {|r| r.is_a?(String) ? r : r.to_sass(options)}.join
   end
 end

data/lib/sass/plugin/compiler.rb

@@ -36,19 +36,30 @@ module Sass::Plugin
       options.merge!(opts)
     end
 
-    # Register a callback to be run after stylesheets are mass-updated.
+    # Register a callback to be run before stylesheets are mass-updated.
     # This is run whenever \{#update\_stylesheets} is called,
     # unless the \{file:SASS_REFERENCE.md#never_update-option `:never_update` option}
     # is enabled.
     #
-    # @yield [individual_files]
-    # @yieldparam individual_files [<(String, String)>]
-    #   Individual files to be updated, in addition to the directories
-    #   specified in the options.
+    # @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 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.
@@ -67,6 +78,21 @@ module Sass::Plugin
     #   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
@@ -139,7 +165,8 @@ 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.
+    # This happens when the corresponding Sass/SCSS file has been deleted
+    # and when the compiler cleans the output files.
     #
     # @yield [filename]
     # @yieldparam filename [String]
@@ -147,7 +174,8 @@ module Sass::Plugin
     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.
+    # This happens when the corresponding Sass/SCSS file has been deleted
+    # and when the compiler cleans the output files.
     #
     # @yield [filename]
     # @yieldparam filename [String]
@@ -162,35 +190,72 @@ module Sass::Plugin
     # in {file:SASS_REFERENCE.md#css_location-option `:css_location`}.
     # If it has, it updates the CSS file.
     #
-    # @param individual_files [Array<(String, String)>]
+    # @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 = [])
-      individual_files = individual_files.dup
       Sass::Plugin.checked_for_updates = true
       staleness_checker = StalenessChecker.new(engine_options)
 
-      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 = 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
+      files = file_list(individual_files)
+      run_updating_stylesheets(files)
 
-      individual_files.each do |file, css, sourcemap|
+      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
+          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)
@@ -211,14 +276,19 @@ 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)>]
-    #   A list of files to watch for updates
+    # @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.
-    def watch(individual_files = [])
-      update_stylesheets(individual_files)
+    #   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, _, _)|
@@ -226,9 +296,20 @@ module Sass::Plugin
       end
       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.
-      listener_args = directories + [{:relative_paths => false}]
+      # 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
@@ -240,49 +321,8 @@ module Sass::Plugin
       end
 
       listener = create_listener(*listener_args) do |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|
-          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
+        on_file_changed(individual_files, modified, added, removed)
+        yield(modified, added, removed) if block_given?
       end
 
       if poll && !Sass::Util.listen_geq_2?
@@ -302,6 +342,8 @@ 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
 
@@ -310,12 +352,42 @@ 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)
-      require 'listen'
+      Sass::Util.load_listen!
       if Sass::Util.listen_geq_2?
-        Listen.to(*args, &block)
+        # 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
@@ -323,16 +395,12 @@ module Sass::Plugin
 
     def listen_to(listener)
       if Sass::Util.listen_geq_2?
-        listener.start
-        listener.thread.join
-        listener.stop # Partially work around guard/listen#146
+        listener.map {|l| l.start}.each {|thread| thread.join}
       else
-        begin
-          listener.start!
-        rescue Interrupt
-          # Squelch Interrupt for clean exit from Listen::Listener
-        end
+        listener.start!
       end
+    rescue Interrupt
+      # Squelch Interrupt for clean exit from Listen::Listener
     end
 
     def remove_redundant_directories(directories)
@@ -351,9 +419,55 @@ module Sass::Plugin
       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
+          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)
       dir = File.dirname(css)
-      unless File.exists?(dir)
+      unless File.exist?(dir)
         run_creating_directory dir
         FileUtils.mkdir_p dir
       end
@@ -364,6 +478,7 @@ module Sass::Plugin
                                      :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))
@@ -373,12 +488,14 @@ module Sass::Plugin
       rescue StandardError => e
         compilation_error_occured = true
         run_compilation_error e, filename, css, sourcemap
-        rendered = Sass::SyntaxError.exception_to_css(e, options)
+        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))
+        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
@@ -393,12 +510,12 @@ module Sass::Plugin
     end
 
     def try_delete_css(css)
-      if File.exists?(css)
+      if File.exist?(css)
         run_deleting_css css
         File.delete css
       end
       map = Sass::Util.sourcemap_name(css)
-      if File.exists?(map)
+      if File.exist?(map)
         run_deleting_sourcemap map
         File.delete map
       end

data/lib/sass/plugin/staleness_checker.rb

@@ -46,7 +46,7 @@ module Sass
         @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
+        # Instead they are supposed to automatically 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)

data/lib/sass/plugin.rb

@@ -123,9 +123,9 @@ module Sass
   end
 end
 
-# 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'
+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

data/lib/sass/script/css_lexer.rb

@@ -18,7 +18,7 @@ module Sass
         end
 
         return unless scan(STRING)
-        string_value = (@scanner[1] || @scanner[2]).gsub(/\\(['"])/, '\1')
+        string_value = Sass::Script::Value::String.value(@scanner[1] || @scanner[2])
         value = Script::Value::String.new(string_value, :string)
         [:string, value]
       end