sass 3.4.0 → 3.4.25

data/lib/sass/importers/deprecated_path.rb

@@ -0,0 +1,51 @@
+module Sass
+  module Importers
+    # This importer emits a deprecation warning the first time it is used to
+    # import a file. It is used to deprecate the current working
+    # directory from the list of automatic sass load paths.
+    class DeprecatedPath < Filesystem
+      # @param root [String] The absolute, expanded path to the folder that is deprecated.
+      def initialize(root)
+        @specified_root = root
+        @warning_given = false
+        super
+      end
+
+      # @see Sass::Importers::Base#find
+      def find(*args)
+        found = super
+        if found && !@warning_given
+          @warning_given = true
+          Sass::Util.sass_warn deprecation_warning
+        end
+        found
+      end
+
+      # @see Base#directories_to_watch
+      def directories_to_watch
+        # The current working directory was not watched in Sass 3.2,
+        # so we continue not to watch it while it's deprecated.
+        []
+      end
+
+      # @see Sass::Importers::Base#to_s
+      def to_s
+        "#{@root} (DEPRECATED)"
+      end
+
+      protected
+
+      # @return [String] The deprecation warning that will be printed the first
+      #   time an import occurs.
+      def deprecation_warning
+        path = @specified_root == "." ? "the current working directory" : @specified_root
+        <<WARNING
+DEPRECATION WARNING: Importing from #{path} will not be
+automatic in future versions of Sass.  To avoid future errors, you can add it
+to your environment explicitly by setting `SASS_PATH=#{@specified_root}`, by using the -I command
+line option, or by changing your Sass configuration options.
+WARNING
+      end
+    end
+  end
+end

data/lib/sass/importers/filesystem.rb

@@ -13,6 +13,7 @@ module Sass
       #   This importer will import files relative to this path.
       def initialize(root)
         @root = File.expand_path(root)
+        @real_root = Sass::Util.realpath(@root).to_s
         @same_name_warnings = Set.new
       end
 
@@ -50,7 +51,7 @@ module Sass
       end
 
       def eql?(other)
-        root.eql?(other.root)
+        !other.nil? && other.respond_to?(:root) && root.eql?(other.root)
       end
 
       # @see Base#directories_to_watch
@@ -60,21 +61,21 @@ module Sass
 
       # @see Base#watched_file?
       def watched_file?(filename)
-        filename =~ /\.s[ac]ss$/ &&
-          filename.start_with?(root + File::SEPARATOR)
+        # Check against the root with symlinks resolved, since Listen
+        # returns fully-resolved paths.
+        filename =~ /\.s[ac]ss$/ && filename.start_with?(@real_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?
+        return Sass::Util.file_uri_from_path(file_pathname) if sourcemap_directory.nil?
+
+        sourcemap_pathname = Sass::Util.cleanpath(sourcemap_directory)
+        begin
+          Sass::Util.file_uri_from_path(
+            Sass::Util.relative_path_from(file_pathname, sourcemap_pathname))
+        rescue ArgumentError # when a relative path cannot be constructed
           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
 
@@ -121,7 +122,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)
@@ -143,14 +144,16 @@ module Sass
         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 = if dir == "." || Sass::Util.pathname(f).absolute?
+                   f
+                 else
+                   "#{escape_glob_characters(dir)}/#{f}"
+                 end
           Dir[path].map do |full_path|
             full_path.gsub!(REDUNDANT_DIRECTORY, File::SEPARATOR)
             [Sass::Util.cleanpath(full_path).to_s, s]
           end
-        end
-        found = Sass::Util.flatten(found, 1)
+        end.flatten(1)
         return if found.empty?
 
         if found.size > 1 && !@same_name_warnings.include?(found.first.first)
@@ -201,6 +204,11 @@ WARNING
         full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
         return unless full_filename && File.readable?(full_filename)
 
+        # TODO: this preserves historical behavior, but it's possible
+        # :filename should be either normalized to the native format
+        # or consistently URI-format.
+        full_filename = full_filename.tr("\\", "/") if Sass::Util.windows?
+
         options[:syntax] = syntax
         options[:filename] = full_filename
         options[:importer] = self

data/lib/sass/importers.rb

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

data/lib/sass/logger/base.rb

@@ -5,6 +5,7 @@ class Sass::Logger::Base
 
   attr_accessor :log_level
   attr_accessor :disabled
+  attr_accessor :io
 
   log_level :trace
   log_level :debug
@@ -12,8 +13,9 @@ class Sass::Logger::Base
   log_level :warn
   log_level :error
 
-  def initialize(log_level = :debug)
+  def initialize(log_level = :debug, io = nil)
     self.log_level = log_level
+    self.io = io
   end
 
   def logging_level?(level)
@@ -25,6 +27,10 @@ class Sass::Logger::Base
   end
 
   def _log(level, message)
-    Kernel.warn(message)
+    if io
+      io.puts(message)
+    else
+      Kernel.warn(message)
+    end
   end
 end

data/lib/sass/logger/delayed.rb

@@ -0,0 +1,50 @@
+require 'sass/logger/log_level'
+
+# A logger that delays messages until they're explicitly flushed to an inner
+# logger.
+#
+# This can be installed around the current logger by calling \{#install!}, and
+# the original logger can be replaced by calling \{#uninstall!}. The log
+# messages can be flushed by calling \{#flush}.
+class Sass::Logger::Delayed < Sass::Logger::Base
+  # Installs a new delayed logger as the current Sass logger, wrapping the
+  # original logger.
+  #
+  # This can be undone by calling \{#uninstall!}.
+  #
+  # @return [Sass::Logger::Delayed] The newly-created logger.
+  def self.install!
+    logger = Sass::Logger::Delayed.new(Sass.logger)
+    Sass.logger = logger
+    logger
+  end
+
+  # Creates a delayed logger wrapping `inner`.
+  #
+  # @param inner [Sass::Logger::Base] The wrapped logger.
+  def initialize(inner)
+    self.log_level = inner.log_level
+    @inner = inner
+    @messages = []
+  end
+
+  # Flushes all queued logs to the wrapped logger.
+  def flush
+    @messages.each {|(l, m)| @inner.log(l, m)}
+  end
+
+  # Uninstalls this logger from \{Sass.logger\}. This should only be called if
+  # the logger was installed using \{#install!}
+  def uninstall!
+    if Sass.logger != self
+      throw Exception.new("Can't uninstall a logger that's not currently installed.")
+    end
+
+    @inner.log_level = log_level
+    Sass.logger = @inner
+  end
+
+  def _log(level, message)
+    @messages << [level, message]
+  end
+end

data/lib/sass/logger.rb

@@ -2,11 +2,16 @@ module Sass::Logger; end
 
 require "sass/logger/log_level"
 require "sass/logger/base"
+require "sass/logger/delayed"
 
 module Sass
   class << self
-    attr_accessor :logger
-  end
+    def logger=(l)
+      Thread.current[:sass_logger] = l
+    end
 
-  self.logger = Sass::Logger::Base.new
+    def logger
+      Thread.current[:sass_logger] ||= Sass::Logger::Base.new
+    end
+  end
 end

data/lib/sass/plugin/compiler.rb

@@ -31,8 +31,9 @@ module Sass::Plugin
     # Creates a new compiler.
     #
     # @param opts [{Symbol => Object}]
-    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #   See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
     def initialize(opts = {})
+      @watched_files = Set.new
       options.merge!(opts)
     end
 
@@ -238,18 +239,19 @@ module Sass::Plugin
     #   of the directories being updated.
     def file_list(individual_files = [])
       files = individual_files.map do |tuple|
-        if tuple.size < 3
+        if engine_options[:sourcemap] == :none
+          tuple[0..1]
+        elsif tuple.size < 3
           [tuple[0], tuple[1], Sass::Util.sourcemap_name(tuple[1])]
         else
-          tuple
+          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.pathname(file).relative_path_from(
-            Sass::Util.pathname(template_location.to_s)).to_s
+          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]
@@ -287,13 +289,18 @@ module Sass::Plugin
     # @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, _, _)|
-        directories << File.dirname(File.expand_path(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
@@ -395,7 +402,8 @@ module Sass::Plugin
 
     def listen_to(listener)
       if Sass::Util.listen_geq_2?
-        listener.map {|l| l.start}.each {|thread| thread.join}
+        listener.map {|l| l.start}
+        sleep
       else
         listener.start!
       end
@@ -435,6 +443,7 @@ module Sass::Plugin
       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
@@ -448,21 +457,20 @@ module Sass::Plugin
           # 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
+            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
 
-      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
+      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)
@@ -494,7 +502,9 @@ module Sass::Plugin
 
       write_file(css, rendered)
       if mapping
-        write_file(sourcemap, mapping.to_json(
+        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
@@ -515,14 +525,21 @@ module Sass::Plugin
         File.delete css
       end
       map = Sass::Util.sourcemap_name(css)
-      if File.exist?(map)
-        run_deleting_sourcemap map
-        File.delete map
-      end
+
+      return unless File.exist?(map)
+
+      run_deleting_sourcemap map
+      File.delete map
     end
 
     def watched_file?(file)
-      normalized_load_paths.find {|lp| lp.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
@@ -552,7 +569,7 @@ module Sass::Plugin
     end
 
     def relative_to_pwd(f)
-      Sass::Util.pathname(f).relative_path_from(Sass::Util.pathname(Dir.pwd)).to_s
+      Sass::Util.relative_path_from(f, Dir.pwd).to_s
     rescue ArgumentError # when a relative path cannot be computed
       f
     end

data/lib/sass/plugin/configuration.rb

@@ -1,8 +1,10 @@
 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.
+    # 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.
+    #
+    # Note that this is not guaranteed to be thread-safe. For guaranteed thread
+    # safety, use a separate {Sass::Plugin} for each thread.
     module Configuration
       # Returns the default options for a {Sass::Plugin::Compiler}.
       #
@@ -25,7 +27,7 @@ module Sass
       end
 
       # An options hash.
-      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       #
       # @return [{Symbol => Object}]
       def options
@@ -85,33 +87,47 @@ module Sass
       # See the {file:SASS_REFERENCE.md#template_location-option `:template_location` option}
       # for details.
       #
+      # Modifications to the returned array may not be persistent.  Use {#add_template_location}
+      # and {#remove_template_location} instead.
+      #
       # @return [Array<(String, String)>]
       #   An array of `[template_location, css_location]` pairs.
       def template_location_array
-        old_template_location = options[:template_location]
-        normalize_template_location!
-        options[:template_location]
-      ensure
-        options[:template_location] = old_template_location
+        convert_template_location(options[:template_location], options[:css_location])
       end
 
       private
 
-      def normalize_template_location!
-        return if options[:template_location].is_a?(Array)
-        options[:template_location] =
-          case options[:template_location]
-          when nil
-            if options[:css_location]
-              [[File.join(options[:css_location], 'sass'), options[:css_location]]]
-            else
-              []
-            end
-          when String
-            [[options[:template_location], options[:css_location]]]
+      # Returns the given template location, as an array. If it's already an array,
+      # it is returned unmodified. Otherwise, a new array is created and returned.
+      #
+      # @param template_location [String, Array<(String, String)>]
+      #   A single template location, or a pre-normalized array of template
+      #   locations and CSS locations.
+      # @param css_location [String?]
+      #   The location for compiled CSS files.
+      # @return [Array<(String, String)>]
+      #   An array of `[template_location, css_location]` pairs.
+      def convert_template_location(template_location, css_location)
+        return template_location if template_location.is_a?(Array)
+
+        case template_location
+        when nil
+          if css_location
+            [[File.join(css_location, 'sass'), css_location]]
           else
-            options[:template_location].to_a
+            []
           end
+        when String
+          [[template_location, css_location]]
+        else
+          template_location.to_a
+        end
+      end
+
+      def normalize_template_location!
+        options[:template_location] = convert_template_location(
+          options[:template_location], options[:css_location])
       end
     end
   end

data/lib/sass/plugin/merb.rb

@@ -2,7 +2,7 @@ unless defined?(Sass::MERB_LOADED)
   Sass::MERB_LOADED = true
 
   module Sass::Plugin::Configuration
-    # Different default options in a m envirionment.
+    # Different default options in a m environment.
     def default_options
       @default_options ||= begin
         version = Merb::VERSION.split('.').map {|n| n.to_i}
@@ -15,7 +15,7 @@ unless defined?(Sass::MERB_LOADED)
         end
 
         {
-          :always_update      => false,
+          :always_update     => false,
           :template_location => root + '/public/stylesheets/sass',
           :css_location      => root + '/public/stylesheets',
           :cache_location    => root + '/tmp/sass-cache',

data/lib/sass/plugin/rack.rb

@@ -9,19 +9,19 @@ module Sass
     #
     # ## Customize
     #
-    #     Sass::Plugin.options.merge(
+    #     Sass::Plugin.options.merge!(
     #       :cache_location => './tmp/sass-cache',
     #       :never_update => environment != :production,
     #       :full_exception => environment != :production)
     #
-    # {file:SASS_REFERENCE.md#options See the Reference for more options}.
+    # {file:SASS_REFERENCE.md#Options See the Reference for more options}.
     #
     # ## Use
     #
     # Put your Sass files in `public/stylesheets/sass`.
     # Your CSS will be generated in `public/stylesheets`,
     # and regenerated every request if necessary.
-    # The locations and frequency {file:SASS_REFERENCE.md#options can be customized}.
+    # The locations and frequency {file:SASS_REFERENCE.md#Options can be customized}.
     # That's all there is to it!
     class Rack
       # The delay, in seconds, between update checks.

data/lib/sass/plugin/rails.rb

@@ -2,7 +2,7 @@ unless defined?(Sass::RAILS_LOADED)
   Sass::RAILS_LOADED = true
 
   module Sass::Plugin::Configuration
-    # Different default options in a rails envirionment.
+    # Different default options in a rails environment.
     def default_options
       return @default_options if @default_options
       opts = {

data/lib/sass/plugin/staleness_checker.rb

@@ -39,7 +39,7 @@ module Sass
       # for checking the staleness of several stylesheets at once.
       #
       # @param options [{Symbol => Object}]
-      #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #   See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
       def initialize(options)
         # URIs that are being actively checked for staleness. Protects against
         # import loops.
@@ -72,7 +72,7 @@ module Sass
       # Returns whether a Sass or SCSS stylesheet has been modified since a given time.
       #
       # @param template_file [String] The location of the Sass or SCSS template.
-      # @param mtime [Fixnum] The modification time to check against.
+      # @param mtime [Time] The modification time to check against.
       # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
       #   Defaults to the filesystem importer.
       # @return [Boolean] Whether the stylesheet has been modified.
@@ -103,7 +103,7 @@ module Sass
       # so it's better to use when checking multiple stylesheets at once.
       #
       # @param template_file [String] The location of the Sass or SCSS template.
-      # @param mtime [Fixnum] The modification time to check against.
+      # @param mtime [Time] The modification time to check against.
       # @param importer [Sass::Importers::Base] The importer used to locate the stylesheet.
       #   Defaults to the filesystem importer.
       # @return [Boolean] Whether the stylesheet has been modified.

data/lib/sass/plugin.rb

@@ -12,7 +12,7 @@ module 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}.
+  # {file:SASS_REFERENCE.md#Rack_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
@@ -93,7 +93,8 @@ 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 = [])
-      Compiler.new(options.dup.merge(
+      Compiler.new(
+        options.dup.merge(
           :never_update => false,
           :always_update => true,
           :cache => false)).update_stylesheets(individual_files)

data/lib/sass/script/css_parser.rb

@@ -19,9 +19,8 @@ module Sass
       def string
         tok = try_tok(:string)
         return number unless tok
-        unless @lexer.peek && @lexer.peek.type == :begin_interpolation
-          return literal_node(tok.value, tok.source_range)
-        end
+        return if @lexer.peek && @lexer.peek.type == :begin_interpolation
+        literal_node(tok.value, tok.source_range)
       end
 
       # Short-circuit all the SassScript-only productions

data/lib/sass/script/css_variable_warning.rb

@@ -0,0 +1,52 @@
+module Sass
+  module Script
+    # An object tracking whether a warning has been emitted for a given script
+    # tree.
+    #
+    # This is shared among all objects in a script tree. Whenever any of those
+    # objects encounters a situation in which it wouldn't produce semantically
+    # identical CSS to its input, it calls \{#warn!\}. The first time \{#warn!}
+    # is called for a given warning object, it prints a deprecation warning.
+    class CssVariableWarning
+      def initialize
+        @warned = false
+        @value = nil
+      end
+
+      # Sets the root of the script tree that this warning refers to.
+      #
+      # @param value [Sass::Script::Tree::Node]
+      def value=(value)
+        warn_called = @warned && !@value
+        @value = value
+        print_warning if warn_called
+      end
+
+      # The first time this is called, it prints a deprecation warning.
+      #
+      # This may be called before \{#value=}. If it is, the warning is emitted
+      # once the script tree is set.
+      def warn!
+        return if @warned
+        @warned = true
+        return unless @value
+
+        print_warning
+      end
+
+      private
+
+      # Prints this node's warning.
+      def print_warning
+        of_filename = " of #{@value.filename}" if @value.filename
+        Sass::Util.sass_warn(
+          "DEPRECATION WARNING on line #{@value.line}#{of_filename}:\n" +
+          "Sass 3.6 will change the way CSS variables are parsed. Instead of being parsed as\n" +
+          "normal properties, they will not allow any Sass-specific behavior other than \#{}.\n" +
+          "For forwards-compatibility, use \#{}:\n" +
+          "\n" +
+          "  --variable: \#{#{@value.to_sass}};")
+      end
+    end
+  end
+end