sass 3.2.19 → 3.4.25

data/lib/sass/features.rb

@@ -0,0 +1,47 @@
+require 'set'
+module Sass
+  # Provides `Sass.has_feature?` which allows for simple feature detection
+  # 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
+    # the Sass function `feature-exists($feature)`
+    #
+    # @param feature_name [String] The case sensitive name of the feature to
+    #   check if it exists in this version of Sass.
+    # @return [Boolean] whether the feature of that name exists.
+    def has_feature?(feature_name)
+      KNOWN_FEATURES.include?(feature_name)
+    end
+
+    # Add a feature to Sass. Plugins can use this to easily expose their
+    # availability to end users. Plugins must prefix their feature
+    # names with a dash to distinguish them from official features.
+    #
+    # @example
+    #   Sass.add_feature("-import-globbing")
+    #   Sass.add_feature("-math-cos")
+    #
+    #
+    # @param feature_name [String] The case sensitive name of the feature to
+    #   to add to Sass. Must begin with a dash.
+    def add_feature(feature_name)
+      unless feature_name[0] == ?-
+        raise ArgumentError.new("Plugin feature names must begin with a dash")
+      end
+      KNOWN_FEATURES << feature_name
+    end
+  end
+
+  extend Features
+end

data/lib/sass/importers/base.rb

@@ -15,13 +15,9 @@ module Sass
     # They should also implement the \{#find\_relative} method.
     #
     # Importers should be serializable via `Marshal.dump`.
-    # In addition to the standard `_dump` and `_load` methods,
-    # importers can define `_before_dump`, `_after_dump`, `_around_dump`,
-    # and `_after_load` methods as per {Sass::Util#dump} and {Sass::Util#load}.
     #
     # @abstract
     class Base
-
       # Find a Sass file relative to another file.
       # Importers without a notion of "relative paths"
       # should just return nil here.
@@ -94,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)
@@ -122,6 +118,34 @@ module Sass
         Sass::Util.abstract(self)
       end
 
+      # Get the publicly-visible URL for an imported file. This URL is used by
+      # source maps to link to the source stylesheet. This may return `nil` to
+      # indicate that no public URL is available; however, this will cause
+      # 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
+      #   a file on disk that's accessible relative to sourcemap_directory, this
+      #   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. 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
+WARNING: #{self.class.name} should define the #public_url method.
+WARNING
+        nil
+      end
+
       # A string representation of the importer.
       # Should be overridden by subclasses.
       #
@@ -132,8 +156,27 @@ module Sass
       def to_s
         Sass::Util.abstract(self)
       end
+
+      # If the importer is based on files on the local filesystem
+      # this method should return folders which should be watched
+      # for changes.
+      #
+      # @return [Array<String>] List of absolute paths of directories to watch
+      def directories_to_watch
+        []
+      end
+
+      # If this importer is based on files on the local filesystem This method
+      # should return true if the file, when changed, should trigger a
+      # recompile.
+      #
+      # It is acceptable for non-sass files to be watched and trigger a recompile.
+      #
+      # @param filename [String] The absolute filename for a file that has changed.
+      # @return [Boolean] When the file changed should cause a recompile.
+      def watched_file?(filename)
+        false
+      end
     end
   end
 end
-
-      

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

@@ -1,4 +1,3 @@
-require 'pathname'
 require 'set'
 
 module Sass
@@ -6,7 +5,6 @@ module Sass
     # The default importer, used for any strings found in the load path.
     # Simply loads Sass files from the filesystem using the default logic.
     class Filesystem < Base
-
       attr_accessor :root
 
       # Creates a new filesystem importer that imports files relative to a given path.
@@ -15,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
 
@@ -39,7 +38,7 @@ module Sass
       # @see Base#key
       def key(name, options)
         [self.class.name + ":" + File.dirname(File.expand_path(name)),
-          File.basename(name)]
+         File.basename(name)]
       end
 
       # @see Base#to_s
@@ -52,7 +51,32 @@ 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
+      def directories_to_watch
+        [root]
+      end
+
+      # @see Base#watched_file?
+      def watched_file?(filename)
+        # 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))
+        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
 
       protected
@@ -107,7 +131,7 @@ module Sass
         end
       end
 
-      REDUNDANT_DIRECTORY = %r{#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}}
+      REDUNDANT_DIRECTORY = /#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}/
       # Given a base directory and an `@import`ed name,
       # finds an existant file that matches the name.
       #
@@ -115,35 +139,39 @@ 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 == "." || Pathname.new(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)
-            [Pathname.new(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)
           found.each {|(f, _)| @same_name_warnings << f}
-          relative_to = Pathname.new(dir)
-          if options[:_line]
+          relative_to = Sass::Util.pathname(dir)
+          if options[:_from_import_node]
             # If _line exists, we're here due to an actual import in an
             # import_node and we want to print a warning for a user writing an
             # ambiguous import.
-            candidates = found.map {|(f, _)| "    " + Pathname.new(f).relative_path_from(relative_to).to_s}.join("\n")
-            Sass::Util.sass_warn <<WARNING
-WARNING: On line #{options[:_line]}#{" of #{options[:filename]}" if options[:filename]}:
-  It's not clear which file to import for '@import "#{name}"'.
-  Candidates:
+            candidates = found.map do |(f, _)|
+              "  " + Sass::Util.pathname(f).relative_path_from(relative_to).to_s
+            end.join("\n")
+            raise Sass::SyntaxError.new(<<MESSAGE)
+It's not clear which file to import for '@import "#{name}"'.
+Candidates:
 #{candidates}
-  For now I'll choose #{File.basename found.first.first}.
-  This will be an error in future versions of Sass.
-WARNING
+Please delete or rename all but one of these files.
+MESSAGE
           else
             # Otherwise, we're here via StalenessChecker, and we want to print a
             # warning for a user running `sass --watch` with two ambiguous files.
@@ -163,7 +191,7 @@ WARNING
       def split(name)
         extension = nil
         dirname, basename = File.dirname(name), File.basename(name)
-        if basename =~ /^(.*)\.(#{extensions.keys.map{|e| Regexp.escape(e)}.join('|')})$/
+        if basename =~ /^(.*)\.(#{extensions.keys.map {|e| Regexp.escape(e)}.join('|')})$/
           basename = $1
           extension = $2
         end
@@ -176,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

@@ -1,11 +1,11 @@
 require 'sass/logger/log_level'
 
 class Sass::Logger::Base
-  
   include Sass::Logger::LogLevel
 
   attr_accessor :log_level
   attr_accessor :disabled
+  attr_accessor :io
 
   log_level :trace
   log_level :debug
@@ -13,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)
@@ -22,11 +23,14 @@ class Sass::Logger::Base
   end
 
   def log(level, message)
-    self._log(level, message) if logging_level?(level)
+    _log(level, message) if logging_level?(level)
   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/log_level.rb

@@ -1,24 +1,21 @@
 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_levels=(levels)
-          @log_levels = levels
-        end
-
         def log_level?(level, min_level)
           log_levels[level] >= log_levels[min_level]
         end
@@ -43,7 +40,6 @@ module Sass
           RUBY
         end
       end
-      
     end
   end
 end

data/lib/sass/logger.rb

@@ -1,15 +1,17 @@
-module Sass::Logger
-
-end
+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

@@ -2,7 +2,7 @@
 module Sass::Media
   # A comma-separated list of queries.
   #
-  #   media_query [ ',' S* media_query ]*
+  #     media_query [ ',' S* media_query ]*
   class QueryList
     # The queries contained in this list.
     #
@@ -43,11 +43,11 @@ module Sass::Media
     end
 
     # Returns a representation of the query as an array of strings and
-    # potentially {Sass::Script::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.
+    # 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::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     def to_a
       Sass::Util.intersperse(queries.map {|q| q.to_a}, ', ').flatten
     end
@@ -62,7 +62,7 @@ module Sass::Media
 
   # A single media query.
   #
-  #   [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
+  #     [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
   class Query
     # The modifier for the query.
     #
@@ -70,7 +70,7 @@ module Sass::Media
     # parsed as CSS, it contains a single string (accessible via
     # \{#resolved_modifier}).
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :modifier
 
     # The type of the query (e.g. `"screen"` or `"print"`).
@@ -79,7 +79,7 @@ module Sass::Media
     # parsed as CSS, it contains a single string (accessible via
     # \{#resolved_type}).
     #
-    # @return [Array<String, Sass::Script::Node>]
+    # @return [Array<String, Sass::Script::Tree::Node>]
     attr_accessor :type
 
     # The trailing expressions in the query.
@@ -87,12 +87,12 @@ module Sass::Media
     # 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::Node>>]
+    # @return [Array<Array<String, Sass::Script::Tree::Node>>]
     attr_accessor :expressions
 
-    # @param modifier [Array<String, Sass::Script::Node>] See \{#modifier}
-    # @param type [Array<String, Sass::Script::Node>] See \{#type}
-    # @param expressions [Array<Array<String, Sass::Script::Node>>] See \{#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
@@ -125,7 +125,7 @@ module Sass::Media
       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'))
+      if (m1 == 'not') ^ (m2 == 'not')
         return if t1 == t2
         type = m1 == 'not' ? t2 : t1
         mod = m1 == 'not' ? m2 : m1
@@ -140,7 +140,7 @@ module Sass::Media
         type = t1
         mod = m1.empty? ? m2 : m1
       end
-      return Query.new([mod], [type], other.expressions + expressions)
+      Query.new([mod], [type], other.expressions + expressions)
     end
 
     # Returns the CSS for the media query.
@@ -156,7 +156,7 @@ module Sass::Media
         # 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::Node) ? c.to_sass : c.to_s}.join
+        e.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.to_sass : c.to_s}.join
       end.join(' and ')
       css
     end
@@ -193,21 +193,18 @@ module Sass::Media
     # @return [Query]
     def deep_copy
       Query.new(
-        modifier.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
-        type.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c},
-        expressions.map {|e| e.map {|c| c.is_a?(Sass::Script::Node) ? c.deep_copy : c}})
+        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 [Array<String, Sass::Script::Node>] The interpolation array to convert.
+  # @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 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