sass 3.3.0 → 3.4.25

data/lib/sass/features.rb

@@ -4,8 +4,15 @@ module Sass
   # by providing a feature name.
   module Features
     # This is the set of features that can be detected.
-    KNOWN_FEATURES = Set[*%w{
-    }]
+    #
+    # 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
     # the Sass function `feature-exists($feature)`

data/lib/sass/importers/base.rb

@@ -90,7 +90,7 @@ module Sass
       #
       # @param uri [String] The URI of the file to check.
       #   Comes from a `:filename` option set on an engine returned by this importer.
-      # @param options [{Symbol => Objet}] Options for the Sass file
+      # @param options [{Symbol => Object}] Options for the Sass file
       #   containing the `@import` currently being checked.
       # @return [Time, nil]
       def mtime(uri, options)
@@ -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

@@ -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,22 +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 = nil)
-        if sourcemap_directory.nil?
-          warn_about_public_url(name)
-        else
-          file_pathname = Sass::Util.pathname(Sass::Util.absolute_path(name, @root)).cleanpath
-          sourcemap_pathname = Sass::Util.pathname(sourcemap_directory).cleanpath
-          begin
-            file_pathname.relative_path_from(sourcemap_pathname).to_s
-          rescue ArgumentError # when a relative path cannot be constructed
-            warn_about_public_url(name)
-            nil
-          end
+      def public_url(name, sourcemap_directory)
+        file_pathname = Sass::Util.cleanpath(Sass::Util.absolute_path(name, @root))
+        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)
         end
       end
 
@@ -122,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)
@@ -139,18 +139,21 @@ 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}"
+          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.pathname(full_path).cleanpath.to_s, s]
+            [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)
@@ -195,28 +198,17 @@ 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)
         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/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/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