sass 3.7.4 → 4.0.0.alpha.1

data/lib/sass/error.rb

@@ -69,14 +69,14 @@ module Sass
     # The name of the mixin in which the error occurred.
     # This could be `nil` if the error occurred outside a mixin.
     #
-    # @return [String]
+    # @return [Fixnum]
     def sass_mixin
       sass_backtrace.first[:mixin]
     end
 
     # The line of the Sass template on which the error occurred.
     #
-    # @return [Integer]
+    # @return [Fixnum]
     def sass_line
       sass_backtrace.first[:line]
     end
@@ -86,7 +86,7 @@ module Sass
     # @param attrs [{Symbol => Object}] The information in the backtrace entry.
     #   See \{#sass\_backtrace}
     def add_backtrace(attrs)
-      sass_backtrace << attrs.reject {|_k, v| v.nil?}
+      sass_backtrace << attrs.reject {|k, v| v.nil?}
     end
 
     # Modify the top Sass backtrace entries
@@ -104,12 +104,12 @@ module Sass
     # @param attrs [{Symbol => Object}] The information to add to the backtrace entry.
     #   See \{#sass\_backtrace}
     def modify_backtrace(attrs)
-      attrs = attrs.reject {|_k, v| v.nil?}
+      attrs = attrs.reject {|k, v| v.nil?}
       # Move backwards through the backtrace
-      (0...sass_backtrace.size).to_a.reverse_each do |i|
+      (0...sass_backtrace.size).to_a.reverse.each do |i|
         entry = sass_backtrace[i]
         sass_backtrace[i] = attrs.merge(entry)
-        attrs.reject! {|k, _v| entry.include?(k)}
+        attrs.reject! {|k, v| entry.include?(k)}
         break if attrs.empty?
       end
     end
@@ -127,7 +127,7 @@ module Sass
       return nil if super.nil?
       return super if sass_backtrace.all? {|h| h.empty?}
       sass_backtrace.map do |h|
-        "#{h[:filename] || '(sass)'}:#{h[:line]}" +
+        "#{h[:filename] || "(sass)"}:#{h[:line]}" +
           (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
       end + super
     end
@@ -142,8 +142,8 @@ module Sass
       msg = lines[0] + lines[1..-1].
         map {|l| "\n" + (" " * "Error: ".size) + l}.join
       "Error: #{msg}" +
-        sass_backtrace.each_with_index.map do |entry, i|
-          "\n        #{i == 0 ? 'on' : 'from'} line #{entry[:line]}" +
+        Sass::Util.enum_with_index(sass_backtrace).map do |entry, i|
+          "\n        #{i == 0 ? "on" : "from"} line #{entry[:line]}" +
             " of #{entry[:filename] || default_filename}" +
             (entry[:mixin] ? ", in `#{entry[:mixin]}'" : "")
         end.join
@@ -153,7 +153,7 @@ module Sass
       # Returns an error report for an exception in CSS format.
       #
       # @param e [Exception]
-      # @param line_offset [Integer] The number of the first line of the Sass template.
+      # @param line_offset [Fixnum] The number of the first line of the Sass template.
       # @return [String] The error report
       # @raise [Exception] `e`, if the
       #   {file:SASS_REFERENCE.md#full_exception-option `:full_exception`} option
@@ -163,9 +163,9 @@ module Sass
 
         <<END
 /*
-#{header.gsub('*/', '*\\/')}
+#{header.gsub("*/", "*\\/")}
 
-Backtrace:\n#{e.backtrace.join("\n").gsub('*/', '*\\/')}
+Backtrace:\n#{e.backtrace.join("\n").gsub("*/", "*\\/")}
 */
 body:before {
   white-space: pre;
@@ -183,10 +183,10 @@ END
 
         line_num = e.sass_line + 1 - line_offset
         min = [line_num - 6, 0].max
-        section = e.sass_template.rstrip.split("\n")[min...line_num + 5]
+        section = e.sass_template.rstrip.split("\n")[min ... line_num + 5]
         return e.sass_backtrace_str if section.nil? || section.empty?
 
-        e.sass_backtrace_str + "\n\n" + section.each_with_index.
+        e.sass_backtrace_str + "\n\n" + Sass::Util.enum_with_index(section).
           map {|line, i| "#{line_offset + min + i}: #{line}"}.join("\n")
       end
     end

data/lib/sass/exec/base.rb

@@ -14,6 +14,7 @@ module Sass::Exec
     #
     # @see #parse
     def parse!
+      # rubocop:disable RescueException
       begin
         parse
       rescue Exception => e
@@ -22,7 +23,7 @@ module Sass::Exec
         # at_exit is a bit of a hack, but it allows us to rethrow when --trace
         # is active and get both the built-in exception formatting and the
         # correct exit code.
-        at_exit {exit Sass::Util.windows? ? 13 : 65} if e.is_a?(Sass::SyntaxError)
+        at_exit {exit 65} if e.is_a?(Sass::SyntaxError)
 
         raise e if @options[:trace] || e.is_a?(SystemExit)
 
@@ -37,6 +38,7 @@ module Sass::Exec
         exit 1
       end
       exit 0
+      # rubocop:enable RescueException
     end
 
     # Parses the command-line arguments and runs the executable.
@@ -88,9 +90,18 @@ module Sass::Exec
     #
     # @param opts [OptionParser]
     def encoding_option(opts)
-      encoding_desc = 'Specify the default encoding for input files.'
+      encoding_desc = if Sass::Util.ruby1_8?
+                        'Does not work in Ruby 1.8.'
+                      else
+                        'Specify the default encoding for input files.'
+                      end
       opts.on('-E', '--default-encoding ENCODING', encoding_desc) do |encoding|
-        Encoding.default_external = encoding
+        if Sass::Util.ruby1_8?
+          $stderr.puts "Specifying the encoding is not supported in ruby 1.8."
+          exit 1
+        else
+          Encoding.default_external = encoding
+        end
       end
     end
 

data/lib/sass/exec/sass_convert.rb

@@ -108,11 +108,10 @@ END
         @options[:for_tree][:dasherize] = true
       end
 
-      opts.on(
-        '--indent NUM',
+      opts.on('--indent NUM',
         'How many spaces to use for each level of indentation. Defaults to 2.',
-        '"t" means use hard tabs.'
-      ) do |indent|
+        '"t" means use hard tabs.') do |indent|
+
         if indent == 't'
           @options[:for_tree][:indent] = "\t"
         else
@@ -157,18 +156,13 @@ END
         @options[:for_engine][:read_cache] = false
       end
 
-      opts.on('-q', '--quiet', 'Silence warnings and status messages during conversion.') do |bool|
-        @options[:for_engine][:quiet] = bool
-      end
-
       opts.on('--trace', :NONE, 'Show a full Ruby stack trace on error') do
         @options[:trace] = true
       end
     end
 
     def process_directory
-      @options[:input] = @args.shift
-      unless @options[:input]
+      unless @options[:input] = @args.shift
         raise "Error: directory required when using --recursive."
       end
 
@@ -247,12 +241,12 @@ END
         Sass::Util.silence_sass_warnings do
           if @options[:from] == :css
             require 'sass/css'
-            Sass::CSS.new(read(input), @options[:for_tree]).render(@options[:to])
+            Sass::CSS.new(input.read, @options[:for_tree]).render(@options[:to])
           else
             if input_path
               Sass::Engine.for_file(input_path, @options[:for_engine])
             else
-              Sass::Engine.new(read(input), @options[:for_engine])
+              Sass::Engine.new(input.read, @options[:for_engine])
             end.to_tree.send("to_#{@options[:to]}", @options[:for_tree])
           end
         end
@@ -271,13 +265,5 @@ END
       return file.path if file.is_a?(File)
       return file if file.is_a?(String)
     end
-
-    def read(file)
-      if file.respond_to?(:read)
-        file.read
-      else
-        open(file, 'rb') {|f| f.read}
-      end
-    end
   end
 end

data/lib/sass/exec/sass_scss.rb

@@ -92,7 +92,7 @@ END
       end
 
       opts.on("-v", "--version", "Print the Sass version.") do
-        puts("Ruby Sass #{Sass.version[:string]}")
+        puts("Sass #{Sass.version[:string]}")
         exit
       end
     end
@@ -156,7 +156,7 @@ END
           '  file: always absolute file URIs',
           '  inline: include the source text in the sourcemap',
           '  none: no sourcemaps') do |type|
-        if type && !%w(auto file inline none).include?(type)
+        if type && !%w[auto file inline none].include?(type)
           $stderr.puts "Unknown sourcemap type #{type}.\n\n"
           $stderr.puts opts
           exit
@@ -256,6 +256,8 @@ MESSAGE
       Sass::Repl.new(@options).run
     end
 
+    # @comment
+    #   rubocop:disable MethodLength
     def watch_or_update
       require 'sass/plugin'
       Sass::Plugin.options.merge! @options[:for_engine]
@@ -288,6 +290,27 @@ File #{@args[1]} #{err}.
 MSG
       end
 
+      # Watch the working directory for changes without adding it to the load
+      # path. This preserves the pre-3.4 behavior when the working directory was
+      # on the load path. We should remove this when we can look for directories
+      # to watch by traversing the import graph.
+      class << Sass::Plugin.compiler
+        # We have to use a class var to make this visible to #watched_file? and
+        # #watched_paths.
+        # rubocop:disable ClassVars
+        @@working_directory = Sass::Util.realpath('.').to_s
+        # rubocop:ensable ClassVars
+
+        def watched_file?(file)
+          super(file) ||
+            (file =~ /\.s[ac]ss$/ && file.start_with?(@@working_directory + File::SEPARATOR))
+        end
+
+        def watched_paths
+          @watched_paths ||= super + [@@working_directory]
+        end
+      end
+
       dirs, files = @args.map {|name| split_colon_path(name)}.
         partition {|i, _| File.directory? i}
 
@@ -357,6 +380,8 @@ WARNING
 
       Sass::Plugin.watch(files)
     end
+    # @comment
+    #   rubocop:enable MethodLength
 
     def run
       input = @options[:input]
@@ -386,8 +411,7 @@ WARNING
           @options[:sourcemap_filename], Sass::Util.pathname(@options[:output_filename]).dirname)
         rendered, mapping = engine.render_with_sourcemap(relative_sourcemap_path.to_s)
         write_output(rendered, output)
-        write_output(
-          mapping.to_json(
+        write_output(mapping.to_json(
             :type => @options[:sourcemap],
             :css_path => @options[:output_filename],
             :sourcemap_path => @options[:sourcemap_filename]) + "\n",
@@ -409,7 +433,7 @@ WARNING
     def split_colon_path(path)
       one, two = path.split(':', 2)
       if one && two && Sass::Util.windows? &&
-          one =~ /\A[A-Za-z]\Z/ && two =~ %r{\A[/\\]}
+          one =~ /\A[A-Za-z]\Z/ && two =~ /\A[\/\\]/
         # If we're on Windows and we were passed a drive letter path,
         # don't split on that colon.
         one2, two = two.split(':', 2)

data/lib/sass/features.rb

@@ -7,13 +7,12 @@ module Sass
     #
     # When this is updated, the documentation of `feature-exists()` should be
     # updated as well.
-    KNOWN_FEATURES = Set[*%w(
+    KNOWN_FEATURES = Set[*%w{
       global-variable-shadowing
       extend-selector-pseudoclass
       units-level-3
       at-error
-      custom-property
-    )]
+    }]
 
     # Check if a feature exists by name. This is used to implement
     # the Sass function `feature-exists($feature)`

data/lib/sass/importers/filesystem.rb

@@ -67,7 +67,7 @@ module Sass
       end
 
       def public_url(name, sourcemap_directory)
-        file_pathname = Sass::Util.cleanpath(File.absolute_path(name, @root))
+        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)
@@ -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(%r{^\./}, ''), s]}
+        ret.map {|f, s| [f.sub(/^\.\//, ''), s]}
       end
 
       def escape_glob_characters(name)
@@ -144,19 +144,14 @@ 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 = if dir == "." || Sass::Util.pathname(f).absolute?
-                   f
-                 else
-                   "#{escape_glob_characters(dir)}/#{f}"
-                 end
+          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.cleanpath(full_path).to_s, s]
           end
         end.flatten(1)
-        if found.empty? && split(name)[2].nil? && File.directory?("#{dir}/#{name}")
-          return find_real_file("#{dir}/#{name}", "index", options)
-        end
+        return if found.empty?
 
         if found.size > 1 && !@same_name_warnings.include?(found.first.first)
           found.each {|(f, _)| @same_name_warnings << f}
@@ -204,7 +199,7 @@ WARNING
 
       def _find(dir, name, options)
         full_filename, syntax = Sass::Util.destructure(find_real_file(dir, name, options))
-        return unless full_filename && File.file?(full_filename) && File.readable?(full_filename)
+        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

data/lib/sass/logger.rb

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

data/lib/sass/logger/base.rb

@@ -5,7 +5,6 @@ class Sass::Logger::Base
 
   attr_accessor :log_level
   attr_accessor :disabled
-  attr_accessor :io
 
   log_level :trace
   log_level :debug
@@ -13,35 +12,19 @@ class Sass::Logger::Base
   log_level :warn
   log_level :error
 
-  def initialize(log_level = :debug, io = nil)
+  def initialize(log_level = :debug)
     self.log_level = log_level
-    self.io = io
   end
 
   def logging_level?(level)
     !disabled && self.class.log_level?(level, log_level)
   end
 
-  # Captures all logger messages emitted during a block and returns them as a
-  # string.
-  def capture
-    old_io = io
-    self.io = StringIO.new
-    yield
-    io.string
-  ensure
-    self.io = old_io
-  end
-
   def log(level, message)
     _log(level, message) if logging_level?(level)
   end
 
   def _log(level, message)
-    if io
-      io.puts(message)
-    else
-      Kernel.warn(message)
-    end
+    Kernel.warn(message)
   end
 end

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#Rack_Rails_Merb_Plugin automatically activated for Rails and Merb}.
+  # {file:SASS_REFERENCE.md#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,8 +93,7 @@ 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/plugin/compiler.rb

@@ -31,7 +31,7 @@ module Sass::Plugin
     # Creates a new compiler.
     #
     # @param opts [{Symbol => Object}]
-    #   See {file:SASS_REFERENCE.md#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)
@@ -289,7 +289,6 @@ 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]
 
@@ -297,36 +296,46 @@ module Sass::Plugin
       individual_files.each do |(source, _, _)|
         source = File.expand_path(source)
         @watched_files << Sass::Util.realpath(source).to_s
-        @inferred_directories << File.dirname(source)
+        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
+      # 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.
       # XXX The :additional_watch_paths option exists for Compass to use until
       # a deprecated feature is removed. It may be removed without warning.
-      directories += Array(options[:additional_watch_paths])
-
-      options = {
-        :relative_paths => false,
-        # The native windows listener is much slower than the polling option, according to
-        # https://github.com/nex3/sass/commit/a3031856b22bc834a5417dedecb038b7be9b9e3e
-        :force_polling => @options[:poll] || Sass::Util.windows?
-      }
+      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
+      poll = @options[:poll] || Sass::Util.windows?
+      if poll && Sass::Util.listen_geq_2?
+        # In Listen 2.0.0 and on, :force_polling is an option. In earlier
+        # versions, it's a method on the listener (called below).
+        listener_args.last[:force_polling] = true
+      end
 
-      listener = create_listener(*directories, options) do |modified, added, removed|
+      listener = create_listener(*listener_args) do |modified, added, removed|
         on_file_changed(individual_files, modified, added, removed)
         yield(modified, added, removed) if block_given?
       end
 
-      begin
-        listener.start
-        sleep
-      rescue Interrupt
-        # Squelch Interrupt for clean exit from Listen::Listener
+      if poll && !Sass::Util.listen_geq_2?
+        # In Listen 2.0.0 and on, :force_polling is an option (set above). In
+        # earlier versions, it's a method on the listener.
+        listener.force_polling(true)
       end
+
+      listen_to(listener)
     end
 
     # Non-destructively modifies \{#options} so that default values are properly set,
@@ -375,10 +384,28 @@ module Sass::Plugin
 
     private
 
-    # This is mocked out in compiler_test.rb.
     def create_listener(*args, &block)
-      require 'sass-listen'
-      SassListen.to(*args, &block)
+      Sass::Util.load_listen!
+      if Sass::Util.listen_geq_2?
+        # 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
+    end
+
+    def listen_to(listener)
+      if Sass::Util.listen_geq_2?
+        listener.map {|l| l.start}
+        sleep
+      else
+        listener.start!
+      end
+    rescue Interrupt
+      # Squelch Interrupt for clean exit from Listen::Listener
     end
 
     def remove_redundant_directories(directories)
@@ -427,20 +454,21 @@ 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)
-            next unless child_of_directory?(sass_dir, f)
-            remainder = f[(sass_dir.size + 1)..-1]
-            try_delete_css(css_filename(remainder, css_dir))
-            break
+            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
 
-      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)
+      if recompile_required
+        # In case a file we're watching is removed and then recreated we
+        # prune out the non-existent 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)
@@ -472,9 +500,7 @@ 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_occurred
@@ -484,7 +510,7 @@ module Sass::Plugin
       flag = 'w'
       flag = 'wb' if Sass::Util.windows? && options[:unix_newlines]
       File.open(fileName, flag) do |file|
-        file.set_encoding(content.encoding)
+        file.set_encoding(content.encoding) unless Sass::Util.ruby1_8?
         file.print(content)
       end
     end
@@ -495,21 +521,14 @@ module Sass::Plugin
         File.delete css
       end
       map = Sass::Util.sourcemap_name(css)
-
-      return unless File.exist?(map)
-
-      run_deleting_sourcemap map
-      File.delete map
+      if File.exist?(map)
+        run_deleting_sourcemap map
+        File.delete map
+      end
     end
 
     def 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)
+      @watched_files.include?(file) || normalized_load_paths.any? {|lp| lp.watched_file?(file)}
     end
 
     def watched_paths