sass 3.1.0 → 3.3.0

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,11 +1,10 @@
-require 'pathname'
+require 'set'
 
 module Sass
   module Importers
     # 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.
@@ -13,7 +12,8 @@ module Sass
       # @param root [String] The root path.
       #   This importer will import files relative to this path.
       def initialize(root)
-        @root = root
+        @root = File.expand_path(root)
+        @same_name_warnings = Set.new
       end
 
       # @see Base#find_relative
@@ -28,7 +28,7 @@ module Sass
 
       # @see Base#mtime
       def mtime(name, options)
-        file, s = find_real_file(@root, name)
+        file, _ = Sass::Util.destructure(find_real_file(@root, name, options))
         File.mtime(file) if file
       rescue Errno::ENOENT
         nil
@@ -37,7 +37,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
@@ -45,14 +45,47 @@ module Sass
         @root
       end
 
+      def hash
+        @root.hash
+      end
+
+      def eql?(other)
+        root.eql?(other.root)
+      end
+
+      # @see Base#directories_to_watch
+      def directories_to_watch
+        [root]
+      end
+
+      # @see Base#watched_file?
+      def watched_file?(filename)
+        filename =~ /\.s[ac]ss$/ &&
+          filename.start_with?(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
+        end
+      end
+
       protected
 
       # If a full uri is passed, this removes the root from it
       # otherwise returns the name unchanged
       def remove_root(name)
-        root = @root.end_with?('/') ? @root : @root + '/'
-        if name.index(root) == 0
-          name[root.length..-1]
+        if name.index(@root + "/") == 0
+          name[(@root.length + 1)..-1]
         else
           name
         end
@@ -77,31 +110,77 @@ module Sass
       #   The first element of each pair is a filename to look for;
       #   the second element is the syntax that file would be in (`:sass` or `:scss`).
       def possible_files(name)
+        name = escape_glob_characters(name)
         dirname, basename, extname = split(name)
         sorted_exts = extensions.sort
         syntax = extensions[extname]
 
-        return [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]] if syntax
-        sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
+        if syntax
+          ret = [["#{dirname}/{_,}#{basename}.#{extensions.invert[syntax]}", syntax]]
+        else
+          ret = sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
+        end
+
+        # JRuby chokes when trying to import files from JARs when the path starts with './'.
+        ret.map {|f, s| [f.sub(/^\.\//, ''), s]}
       end
 
+      def escape_glob_characters(name)
+        name.gsub(/[\*\[\]\{\}\?]/) do |char|
+          "\\#{char}"
+        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.
       #
       # @param dir [String] The directory relative to which to search.
       # @param name [String] The filename to search for.
       # @return [(String, Symbol)] A filename-syntax pair.
-      def find_real_file(dir, name)
-        for (f,s) in possible_files(remove_root(name))
-          path = (dir == ".") ? f : "#{dir}/#{f}"
-          if full_path = Dir[path].first
-            full_path.gsub!(REDUNDANT_DIRECTORY,File::SEPARATOR)
-            return full_path, s
+      def find_real_file(dir, name, options)
+        # on windows 'dir' can be in native File::ALT_SEPARATOR form
+        dir = dir.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]
           end
         end
-        nil
+        found = Sass::Util.flatten(found, 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 = 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 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}
+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.
+            candidates = found.map {|(f, _)| "    " + File.basename(f)}.join("\n")
+            Sass::Util.sass_warn <<WARNING
+WARNING: In #{File.dirname(name)}:
+  There are multiple files that match the name "#{File.basename(name)}":
+#{candidates}
+WARNING
+          end
+        end
+        found.first
       end
 
       # Splits a filename into three parts, a directory part, a basename, and an extension
@@ -109,25 +188,33 @@ module Sass
       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
         [dirname, basename, extension]
       end
 
-      def hash
-        @root.hash
-      end
-
-      def eql?(other)
-        root.eql?(other.root)
+      # 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 = find_real_file(dir, name)
+        full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
         return unless full_filename && File.readable?(full_filename)
 
         options[:syntax] = syntax
@@ -135,10 +222,6 @@ module Sass
         options[:importer] = self
         Sass::Engine.new(File.read(full_filename), options)
       end
-
-      def join(base, path)
-        Pathname.new(base).join(path).to_s
-      end
     end
   end
 end

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

@@ -0,0 +1,30 @@
+require 'sass/logger/log_level'
+
+class Sass::Logger::Base
+  include Sass::Logger::LogLevel
+
+  attr_accessor :log_level
+  attr_accessor :disabled
+
+  log_level :trace
+  log_level :debug
+  log_level :info
+  log_level :warn
+  log_level :error
+
+  def initialize(log_level = :debug)
+    self.log_level = log_level
+  end
+
+  def logging_level?(level)
+    !disabled && self.class.log_level?(level, log_level)
+  end
+
+  def log(level, message)
+    _log(level, message) if logging_level?(level)
+  end
+
+  def _log(level, message)
+    Kernel.warn(message)
+  end
+end

data/lib/sass/logger/log_level.rb

@@ -0,0 +1,45 @@
+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_level?(level, min_level)
+          log_levels[level] >= log_levels[min_level]
+        end
+
+        def log_level(name, options = {})
+          if options[:prepend]
+            level = log_levels.values.min
+            level = level.nil? ? 0 : level - 1
+          else
+            level = log_levels.values.max
+            level = level.nil? ? 0 : level + 1
+          end
+          log_levels.update(name => level)
+          define_logger(name)
+        end
+
+        def define_logger(name, options = {})
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}(message)
+              #{options.fetch(:to, :log)}(#{name.inspect}, message)
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/sass/logger.rb

@@ -0,0 +1,12 @@
+module Sass::Logger; end
+
+require "sass/logger/log_level"
+require "sass/logger/base"
+
+module Sass
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = Sass::Logger::Base.new
+end

data/lib/sass/media.rb

@@ -0,0 +1,213 @@
+# A namespace for the `@media` query parse tree.
+module Sass::Media
+  # A comma-separated list of queries.
+  #
+  #     media_query [ ',' S* media_query ]*
+  class QueryList
+    # The queries contained in this list.
+    #
+    # @return [Array<Query>]
+    attr_accessor :queries
+
+    # @param queries [Array<Query>] See \{#queries}
+    def initialize(queries)
+      @queries = queries
+    end
+
+    # Merges this query list with another. The returned query list
+    # queries for the intersection between the two inputs.
+    #
+    # Both query lists should be resolved.
+    #
+    # @param other [QueryList]
+    # @return [QueryList?] The merged list, or nil if there is no intersection.
+    def merge(other)
+      new_queries = queries.map {|q1| other.queries.map {|q2| q1.merge(q2)}}.flatten.compact
+      return if new_queries.empty?
+      QueryList.new(new_queries)
+    end
+
+    # Returns the CSS for the media query list.
+    #
+    # @return [String]
+    def to_css
+      queries.map {|q| q.to_css}.join(', ')
+    end
+
+    # Returns the Sass/SCSS code for the media query list.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options)
+      queries.map {|q| q.to_src(options)}.join(', ')
+    end
+
+    # Returns a representation of the query as an array of strings and
+    # 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::Tree::Node>]
+    def to_a
+      Sass::Util.intersperse(queries.map {|q| q.to_a}, ', ').flatten
+    end
+
+    # Returns a deep copy of this query list and all its children.
+    #
+    # @return [QueryList]
+    def deep_copy
+      QueryList.new(queries.map {|q| q.deep_copy})
+    end
+  end
+
+  # A single media query.
+  #
+  #     [ [ONLY | NOT]? S* media_type S* | expression ] [ AND S* expression ]*
+  class Query
+    # The modifier for the query.
+    #
+    # When parsed as Sass code, this contains strings and SassScript nodes. When
+    # parsed as CSS, it contains a single string (accessible via
+    # \{#resolved_modifier}).
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :modifier
+
+    # The type of the query (e.g. `"screen"` or `"print"`).
+    #
+    # When parsed as Sass code, this contains strings and SassScript nodes. When
+    # parsed as CSS, it contains a single string (accessible via
+    # \{#resolved_type}).
+    #
+    # @return [Array<String, Sass::Script::Tree::Node>]
+    attr_accessor :type
+
+    # The trailing expressions in the query.
+    #
+    # 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::Tree::Node>>]
+    attr_accessor :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
+      @expressions = expressions
+    end
+
+    # See \{#modifier}.
+    # @return [String]
+    def resolved_modifier
+      # modifier should contain only a single string
+      modifier.first || ''
+    end
+
+    # See \{#type}.
+    # @return [String]
+    def resolved_type
+      # type should contain only a single string
+      type.first || ''
+    end
+
+    # Merges this query with another. The returned query queries for
+    # the intersection between the two inputs.
+    #
+    # Both queries should be resolved.
+    #
+    # @param other [Query]
+    # @return [Query?] The merged query, or nil if there is no intersection.
+    def merge(other)
+      m1, t1 = resolved_modifier.downcase, resolved_type.downcase
+      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')
+        return if t1 == t2
+        type = m1 == 'not' ? t2 : t1
+        mod = m1 == 'not' ? m2 : m1
+      elsif m1 == 'not' && m2 == 'not'
+        # CSS has no way of representing "neither screen nor print"
+        return unless t1 == t2
+        type = t1
+        mod = 'not'
+      elsif t1 != t2
+        return
+      else # t1 == t2, neither m1 nor m2 are "not"
+        type = t1
+        mod = m1.empty? ? m2 : m1
+      end
+      Query.new([mod], [type], other.expressions + expressions)
+    end
+
+    # Returns the CSS for the media query.
+    #
+    # @return [String]
+    def to_css
+      css = ''
+      css << resolved_modifier
+      css << ' ' unless resolved_modifier.empty?
+      css << resolved_type
+      css << ' and ' unless resolved_type.empty? || expressions.empty?
+      css << expressions.map do |e|
+        # 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::Tree::Node) ? c.to_sass : c.to_s}.join
+      end.join(' and ')
+      css
+    end
+
+    # Returns the Sass/SCSS code for the media query.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options)
+      src = ''
+      src << Sass::Media._interp_to_src(modifier, options)
+      src << ' ' unless modifier.empty?
+      src << Sass::Media._interp_to_src(type, options)
+      src << ' and ' unless type.empty? || expressions.empty?
+      src << expressions.map do |e|
+        Sass::Media._interp_to_src(e, options)
+      end.join(' and ')
+      src
+    end
+
+    # @see \{MediaQuery#to\_a}
+    def to_a
+      res = []
+      res += modifier
+      res << ' ' unless modifier.empty?
+      res += type
+      res << ' and ' unless type.empty? || expressions.empty?
+      res += Sass::Util.intersperse(expressions, ' and ').flatten
+      res
+    end
+
+    # Returns a deep copy of this query and all its children.
+    #
+    # @return [Query]
+    def deep_copy
+      Query.new(
+        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 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
+  end
+end