sass 3.4.0 → 3.4.25

data/lib/sass/tree/visitors/to_css.rb

@@ -12,8 +12,10 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     @tabs = 0
     @line = 1
     @offset = 1
-    @result = ""
-    @source_mapping = Sass::Source::Map.new if build_source_mapping
+    @result = String.new("")
+    @source_mapping = build_source_mapping ? Sass::Source::Map.new : nil
+    @lstrip = nil
+    @in_directive = false
   end
 
   # Runs the visitor on `node`.
@@ -51,6 +53,10 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     @source_mapping.add(source_range, target_range)
   end
 
+  def trailing_semicolon?
+   @result.end_with?(";") && !@result.end_with?('\;')
+  end
+
   # Move the output cursor back `chars` characters.
   def erase!(chars)
     return if chars == 0
@@ -98,7 +104,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     @lstrip = true
     yield
   ensure
-    @lstrip = @lstrip && old_lstrip
+    @lstrip &&= old_lstrip
   end
 
   # Prepend `prefix` to the output string.
@@ -116,14 +122,15 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     node.children.each do |child|
       next if child.invisible?
       visit(child)
-      unless node.style == :compressed
-        output "\n"
-        if child.is_a?(Sass::Tree::DirectiveNode) && child.has_children && !child.bubbles?
-          output "\n"
-        end
-      end
+      next if node.style == :compressed
+      output "\n"
+      next unless child.is_a?(Sass::Tree::DirectiveNode) && child.has_children && !child.bubbles?
+      output "\n"
     end
     rstrip!
+    if node.style == :compressed && trailing_semicolon?
+      erase! 1
+    end
     return "" if @result.empty?
 
     output "\n"
@@ -152,13 +159,14 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   def visit_comment(node)
     return if node.invisible?
     spaces = ('  ' * [@tabs - node.resolved_value[/^ */].size, 0].max)
+    output(spaces)
 
-    content = node.resolved_value.gsub(/^/, spaces)
+    content = node.resolved_value.split("\n").join("\n" + spaces)
     if node.type == :silent
-      content.gsub!(%r{^(\s*)//(.*)$}) {|md| "#{$1}/*#{$2} */"}
+      content.gsub!(%r{^(\s*)//(.*)$}) {"#{$1}/*#{$2} */"}
     end
     if (node.style == :compact || node.style == :compressed) && node.type != :loud
-      content.gsub!(/\n +(\* *(?!\/))?/, ' ')
+      content.gsub!(%r{\n +(\* *(?!/))?}, ' ')
     end
     for_node(node) {output(content)}
   end
@@ -171,28 +179,32 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     if !node.has_children || node.children.empty?
       output(tab_str)
       for_node(node) {output(node.resolved_value)}
-      output(!node.has_children ? ";" : " {}")
+      if node.has_children
+        output("#{' ' unless node.style == :compressed}{}")
+      elsif node.children.empty?
+        output(";")
+      end
       return
     end
 
-    @in_directive = @in_directive || !node.is_a?(Sass::Tree::MediaNode)
+    @in_directive ||= !node.is_a?(Sass::Tree::MediaNode)
     output(tab_str) if node.style != :compressed
     for_node(node) {output(node.resolved_value)}
     output(node.style == :compressed ? "{" : " {")
     output(node.style == :compact ? ' ' : "\n") if node.style != :compressed
 
-    was_prop = false
+    had_children = true
     first = true
     node.children.each do |child|
       next if child.invisible?
       if node.style == :compact
         if child.is_a?(Sass::Tree::PropNode)
-          with_tabs(first || was_prop ? 0 : @tabs + 1) do
+          with_tabs(first || !had_children ? 0 : @tabs + 1) do
             visit(child)
             output(' ')
           end
         else
-          if was_prop
+          unless had_children
             erase! 1
             output "\n"
           end
@@ -206,18 +218,23 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
           rstrip!
           output "\n"
         end
-        was_prop = child.is_a?(Sass::Tree::PropNode)
+        had_children = child.has_children
         first = false
       elsif node.style == :compressed
-        output(was_prop ? ";" : "")
+        unless had_children
+          output(";") unless trailing_semicolon?
+        end
         with_tabs(0) {visit(child)}
-        was_prop = child.is_a?(Sass::Tree::PropNode)
+        had_children = child.has_children
       else
         with_tabs(@tabs + 1) {visit(child)}
         output "\n"
       end
     end
     rstrip!
+    if node.style == :compressed && trailing_semicolon?
+      erase! 1
+    end
     if node.style == :expanded
       output("\n#{tab_str}")
     elsif node.style != :compressed
@@ -278,10 +295,13 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
       joined_rules = node.resolved_rules.members.map do |seq|
         next if seq.has_placeholder?
-        rule_part = seq.to_s
+        rule_part = seq.to_s(:style => node.style)
         if node.style == :compressed
           rule_part.gsub!(/([^,])\s*\n\s*/m, '\1 ')
-          rule_part.gsub!(/\s*([,+>])\s*/m, '\1')
+          rule_part.gsub!(/\s*([+>])\s*/m, '\1')
+          rule_part.gsub!(/nth([^( ]*)\(([^)]*)\)/m) do |match|
+            match.tr(" \t\n", "")
+          end
           rule_part.strip!
         end
         rule_part
@@ -306,8 +326,8 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
             relative_filename =
               if node.options[:css_filename]
                 begin
-                  Sass::Util.pathname(node.filename).relative_path_from(
-                    Sass::Util.pathname(File.dirname(node.options[:css_filename]))).to_s
+                  Sass::Util.relative_path_from(
+                    node.filename, File.dirname(node.options[:css_filename])).to_s
                 rescue ArgumentError
                   nil
                 end
@@ -320,7 +340,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
         end
       end
 
-      end_props, trailer, tabs  = '', '', 0
+      end_props, trailer, tabs = '', '', 0
       if node.style == :compact
         separator, end_props, bracket = ' ', ' ', ' { '
         trailer = "\n" if node.group_end
@@ -338,10 +358,18 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
       with_tabs(tabs) do
         node.children.each_with_index do |child, i|
-          output(separator) if i > 0
+          if i > 0
+            if separator.start_with?(";") && trailing_semicolon?
+              erase! 1
+            end
+            output(separator)
+          end
           visit(child)
         end
       end
+      if node.style == :compressed && trailing_semicolon?
+        erase! 1
+      end
 
       output(end_props)
       output("}" + trailer)
@@ -362,10 +390,10 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(
-            [Sass::Selector::SimpleSequence.new(
-                [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)],
-                false)
-            ])
+          [Sass::Selector::SimpleSequence.new(
+            [Sass::Selector::Element.new(k.to_s.gsub(/[^\w-]/, "\\\\\\0"), nil)],
+            false)
+          ])
         ])
       prop = Sass::Tree::PropNode.new([""], Sass::Script::Value::String.new(''), :new)
       prop.resolved_name = "font-family"

data/lib/sass/util/multibyte_string_scanner.rb

@@ -1,9 +1,7 @@
 require 'strscan'
 
 if Sass::Util.ruby1_8?
-  # rubocop:disable ConstantName
   Sass::Util::MultibyteStringScanner = StringScanner
-  # rubocop:enable ConstantName
 else
   if Sass::Util.rbx?
     # Rubinius's StringScanner class implements some of its methods in terms of

data/lib/sass/util/normalized_map.rb

@@ -1,5 +1,4 @@
 require 'delegate'
-require 'sass/util'
 
 module Sass
   module Util

data/lib/sass/util/subset_map.rb

@@ -78,8 +78,7 @@ module Sass
             next unless subset.subset?(set)
             [index, subenum]
           end
-        end
-        res = Sass::Util.flatten(res, 1)
+        end.flatten(1)
         res.compact!
         res.uniq!
         res.sort!

data/lib/sass/util.rb

@@ -13,6 +13,8 @@ require 'sass/util/subset_map'
 
 module Sass
   # A module containing various useful functions.
+  # @comment
+  #   rubocop:disable ModuleLength
   module Util
     extend self
 
@@ -138,6 +140,18 @@ module Sass
       [[value, range.first].max, range.last].min
     end
 
+    # Like [Fixnum.round], but leaves rooms for slight floating-point
+    # differences.
+    #
+    # @param value [Numeric]
+    # @return [Numeric]
+    def round(value)
+      # If the number is within epsilon of X.5, round up (or down for negative
+      # numbers).
+      return value.round if (value % 1) - 0.5 <= -1 * Script::Value::Number.epsilon
+      value > 0 ? value.ceil : value.floor
+    end
+
     # Concatenates all strings that are adjacent in an array,
     # while leaving other elements as they are.
     #
@@ -265,7 +279,7 @@ module Sass
     #     #  [2, 4, 5]]
     def paths(arrs)
       arrs.inject([[]]) do |paths, arr|
-        flatten(arr.map {|e| paths.map {|path| path + [e]}}, 1)
+        arr.map {|e| paths.map {|path| path + [e]}}.flatten(1)
       end
     end
 
@@ -298,7 +312,7 @@ module Sass
     # @return [Array]
     def hash_to_a(hash)
       return hash.to_a unless ruby1_8? || defined?(Test::Unit)
-      hash.sort_by {|k, v| k}
+      hash.sort_by {|k, _v| k}
     end
 
     # Performs the equivalent of `enum.group_by.to_a`, but with a guaranteed
@@ -325,6 +339,18 @@ module Sass
       arr
     end
 
+    # Like `String.upcase`, but only ever upcases ASCII letters.
+    def upcase(string)
+      return string.upcase unless ruby2_4?
+      string.upcase(:ascii)
+    end
+
+    # Like `String.downcase`, but only ever downcases ASCII letters.
+    def downcase(string)
+      return string.downcase unless ruby2_4?
+      string.downcase(:ascii)
+    end
+
     # Returns a sub-array of `minuend` containing only elements that are also in
     # `subtrahend`. Ensures that the return value has the same order as
     # `minuend`, even on Rubinius where that's not guaranteed by `Array#-`.
@@ -404,13 +430,13 @@ module Sass
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
-    # @return [[String, Fixnum, (String, nil)]]
+    # @return [[String, Integer, (String, nil)]]
     #   An array containing the filename, line, and method name of the caller.
     #   The method name may be nil
     def caller_info(entry = nil)
       # JRuby evaluates `caller` incorrectly when it's in an actual default argument.
       entry ||= caller[1]
-      info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).first
+      info = entry.scan(/^((?:[A-Za-z]:)?.*?):(-?.*?)(?::.*`(.+)')?$/).first
       info[1] = info[1].to_i
       # This is added by Rubinius to designate a block, but we don't care about it.
       info[2].sub!(/ \{\}\Z/, '') if info[2]
@@ -498,7 +524,7 @@ module Sass
     #
     # @param msg [String]
     def sass_warn(msg)
-      msg = msg + "\n" unless ruby1?
+      msg += "\n" unless ruby1?
       Sass.logger.warn(msg)
     end
 
@@ -557,9 +583,12 @@ module Sass
     #
     # @return [Boolean]
     def listen_geq_2?
-      return @listen_geq_2 unless @listen_geq_2.nil?
+      return @listen_geq_2 if defined?(@listen_geq_2)
       @listen_geq_2 =
         begin
+          # Make sure we're loading listen/version from the same place that
+          # we're loading listen itself.
+          load_listen!
           require 'listen/version'
           version_geq(::Listen::VERSION, '2.0.0')
         rescue LoadError
@@ -619,7 +648,7 @@ module Sass
 
     # Returns an array of ints representing the JRuby version number.
     #
-    # @return [Array<Fixnum>]
+    # @return [Array<Integer>]
     def jruby_version
       @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
     end
@@ -628,7 +657,7 @@ module Sass
     #
     # @param path [String]
     def glob(path)
-      path = path.gsub('\\', '/') if windows?
+      path = path.tr('\\', '/') if windows?
       if block_given?
         Dir.glob(path) {|f| yield(f)}
       else
@@ -661,19 +690,77 @@ module Sass
       pathname(path.cleanpath.to_s)
     end
 
+    # Returns `path` with all symlinks resolved.
+    #
+    # @param path [String, Pathname]
+    # @return [Pathname]
+    def realpath(path)
+      path = Pathname.new(path) unless path.is_a?(Pathname)
+
+      # Explicitly DON'T run #pathname here. We don't want to convert
+      # to Windows directory separators because we're comparing these
+      # against the paths returned by Listen, which use forward
+      # slashes everywhere.
+      begin
+        path.realpath
+      rescue SystemCallError
+        # If [path] doesn't actually exist, don't bail, just
+        # return the original.
+        path
+      end
+    end
+
+    # Returns `path` relative to `from`.
+    #
+    # This is like `Pathname#relative_path_from` except it accepts both strings
+    # and pathnames, it handles Windows path separators correctly, and it throws
+    # an error rather than crashing if the paths use different encodings
+    # (https://github.com/ruby/ruby/pull/713).
+    #
+    # @param path [String, Pathname]
+    # @param from [String, Pathname]
+    # @return [Pathname?]
+    def relative_path_from(path, from)
+      pathname(path.to_s).relative_path_from(pathname(from.to_s))
+    rescue NoMethodError => e
+      raise e unless e.name == :zero?
+
+      # Work around https://github.com/ruby/ruby/pull/713.
+      path = path.to_s
+      from = from.to_s
+      raise ArgumentError("Incompatible path encodings: #{path.inspect} is #{path.encoding}, " +
+        "#{from.inspect} is #{from.encoding}")
+    end
+
     # Converts `path` to a "file:" URI. This handles Windows paths correctly.
     #
     # @param path [String, Pathname]
     # @return [String]
     def file_uri_from_path(path)
       path = path.to_s if path.is_a?(Pathname)
+      path = path.tr('\\', '/') if windows?
       path = Sass::Util.escape_uri(path)
       return path.start_with?('/') ? "file://" + path : path unless windows?
-      return "file:///" + path.tr("\\", "/") if path =~ /^[a-zA-Z]:[\/\\]/
-      return "file://" + path.tr("\\", "/") if path =~ /\\\\[^\\]+\\[^\\\/]+/
+      return "file:///" + path.tr("\\", "/") if path =~ %r{^[a-zA-Z]:[/\\]}
+      return "file:" + path.tr("\\", "/") if path =~ %r{\\\\[^\\]+\\[^\\/]+}
       path.tr("\\", "/")
     end
 
+    # Retries a filesystem operation if it fails on Windows. Windows
+    # has weird and flaky locking rules that can cause operations to fail.
+    #
+    # @yield [] The filesystem operation.
+    def retry_on_windows
+      return yield unless windows?
+
+      begin
+        yield
+      rescue SystemCallError
+        sleep 0.1
+        yield
+      end
+    end
+
     # Prepare a value for a destructuring assignment (e.g. `a, b =
     # val`). This works around a performance bug when using
     # ActiveSupport, and only needs to be called when `val` is likely
@@ -711,15 +798,6 @@ module Sass
                    (RUBY_VERSION_COMPONENTS[0] == 1 && RUBY_VERSION_COMPONENTS[1] < 9)
     end
 
-    # Whether or not this is running under Ruby 1.8.6 or lower.
-    # Note that lower versions are not officially supported.
-    #
-    # @return [Boolean]
-    def ruby1_8_6?
-      return @ruby1_8_6 if defined?(@ruby1_8_6)
-      @ruby1_8_6 = ruby1_8? && RUBY_VERSION_COMPONENTS[2] < 7
-    end
-
     # Whether or not this is running under Ruby 1.9.2 exactly.
     #
     # @return [Boolean]
@@ -728,6 +806,19 @@ module Sass
       @ruby1_9_2 = RUBY_VERSION_COMPONENTS == [1, 9, 2]
     end
 
+    # Whether or not this is running under Ruby 2.4 or higher.
+    #
+    # @return [Boolean]
+    def ruby2_4?
+      return @ruby2_4 if defined?(@ruby2_4)
+      @ruby2_4 =
+        if RUBY_VERSION_COMPONENTS[0] == 2
+          RUBY_VERSION_COMPONENTS[1] >= 4
+        else
+          RUBY_VERSION_COMPONENTS[0] > 2
+        end
+    end
+
     # Wehter or not this is running under JRuby 1.6 or lower.
     def jruby1_6?
       return @jruby1_6 if defined?(@jruby1_6)
@@ -769,14 +860,15 @@ module Sass
       end
 
       return Hash[pairs_or_hash] unless ruby1_8?
-      (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*flatten(pairs_or_hash, 1)]
+      (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*pairs_or_hash.flatten(1)]
     end
 
     unless ruby1_8?
       CHARSET_REGEXP = /\A@charset "([^"]+)"/
-      UTF_8_BOM = "\xEF\xBB\xBF".force_encoding('BINARY')
-      UTF_16BE_BOM = "\xFE\xFF".force_encoding('BINARY')
-      UTF_16LE_BOM = "\xFF\xFE".force_encoding('BINARY')
+      bom = "\uFEFF"
+      UTF_8_BOM = bom.encode("UTF-8").force_encoding('BINARY')
+      UTF_16BE_BOM = bom.encode("UTF-16BE").force_encoding('BINARY')
+      UTF_16LE_BOM = bom.encode("UTF-16LE").force_encoding('BINARY')
     end
 
     # Like {\#check\_encoding}, but also checks for a `@charset` declaration
@@ -874,7 +966,7 @@ module Sass
     # A version of `Enumerable#enum_cons` that works in Ruby 1.8 and 1.9.
     #
     # @param enum [Enumerable] The enumerable to get the enumerator for
-    # @param n [Fixnum] The size of each cons
+    # @param n [Integer] The size of each cons
     # @return [Enumerator] The consed enumerator
     def enum_cons(enum, n)
       ruby1_8? ? enum.enum_cons(n) : enum.each_cons(n)
@@ -883,7 +975,7 @@ module Sass
     # A version of `Enumerable#enum_slice` that works in Ruby 1.8 and 1.9.
     #
     # @param enum [Enumerable] The enumerable to get the enumerator for
-    # @param n [Fixnum] The size of each slice
+    # @param n [Integer] The size of each slice
     # @return [Enumerator] The consed enumerator
     def enum_slice(enum, n)
       ruby1_8? ? enum.enum_slice(n) : enum.each_slice(n)
@@ -910,22 +1002,11 @@ module Sass
     # Returns the ASCII code of the given character.
     #
     # @param c [String] All characters but the first are ignored.
-    # @return [Fixnum] The ASCII code of `c`.
+    # @return [Integer] The ASCII code of `c`.
     def ord(c)
       ruby1_8? ? c[0] : c.ord
     end
 
-    # Flattens the first `n` nested arrays in a cross-version manner.
-    #
-    # @param arr [Array] The array to flatten
-    # @param n [Fixnum] The number of levels to flatten
-    # @return [Array] The flattened array
-    def flatten(arr, n)
-      return arr.flatten(n) unless ruby1_8_6?
-      return arr if n == 0
-      arr.inject([]) {|res, e| e.is_a?(Array) ? res.concat(flatten(e, n - 1)) : res << e}
-    end
-
     # Flattens the first level of nested arrays in `arrs`. Unlike
     # `Array#flatten`, this orders the result by taking the first
     # values from each array in order, then the second, and so on.
@@ -944,27 +1025,6 @@ module Sass
       result
     end
 
-    # Returns the hash code for a set in a cross-version manner.
-    # Aggravatingly, this is order-dependent in Ruby 1.8.6.
-    #
-    # @param set [Set]
-    # @return [Fixnum] The order-independent hashcode of `set`
-    def set_hash(set)
-      return set.hash unless ruby1_8_6?
-      set.map {|e| e.hash}.uniq.sort.hash
-    end
-
-    # Tests the hash-equality of two sets in a cross-version manner.
-    # Aggravatingly, this is order-dependent in Ruby 1.8.6.
-    #
-    # @param set1 [Set]
-    # @param set2 [Set]
-    # @return [Boolean] Whether or not the sets are hashcode equal
-    def set_eql?(set1, set2)
-      return set1.eql?(set2) unless ruby1_8_6?
-      set1.to_a.uniq.sort_by {|e| e.hash}.eql?(set2.to_a.uniq.sort_by {|e| e.hash})
-    end
-
     # Like `Object#inspect`, but preserves non-ASCII characters rather than
     # escaping them under Ruby 1.9.2.  This is necessary so that the
     # precompiled Haml template can be `#encode`d into `@options[:encoding]`
@@ -1067,11 +1127,11 @@ module Sass
 
     # Converts the argument into a valid JSON value.
     #
-    # @param v [Fixnum, String, Array, Boolean, nil]
+    # @param v [Integer, String, Array, Boolean, nil]
     # @return [String]
     def json_value_of(v)
       case v
-      when Fixnum
+      when Integer
         v.to_s
       when String
         "\"" + json_escape_string(v) + "\""
@@ -1093,7 +1153,7 @@ module Sass
     VLQ_BASE_MASK = VLQ_BASE - 1
     VLQ_CONTINUATION_BIT = VLQ_BASE
 
-    BASE64_DIGITS = ('A'..'Z').to_a  + ('a'..'z').to_a + ('0'..'9').to_a  + ['+', '/']
+    BASE64_DIGITS = ('A'..'Z').to_a + ('a'..'z').to_a + ('0'..'9').to_a + ['+', '/']
     BASE64_DIGIT_MAP = begin
       map = {}
       Sass::Util.enum_with_index(BASE64_DIGITS).map do |digit, i|
@@ -1104,7 +1164,7 @@ module Sass
 
     # Encodes `value` as VLQ (http://en.wikipedia.org/wiki/VLQ).
     #
-    # @param value [Fixnum]
+    # @param value [Integer]
     # @return [String] The encoded value
     def encode_vlq(value)
       if value < 0
@@ -1223,7 +1283,7 @@ module Sass
             require 'listen'
           rescue LoadError => e
             if version_geq(RUBY_VERSION, "1.9.3")
-              version_constraint = "~> 2.7"
+              version_constraint = "~> 3.0"
             else
               version_constraint = "~> 1.1"
             end
@@ -1272,13 +1332,10 @@ module Sass
       return str, str.encoding
     end
 
-    # rubocop:disable LineLength
-
     # Calculates the memoization table for the Least Common Subsequence algorithm.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Computing_the_length_of_the_LCS)
     def lcs_table(x, y)
       # This method does not take a block as an explicit parameter for performance reasons.
-      # rubocop:enable LineLength
       c = Array.new(x.size) {[]}
       x.size.times {|i| c[i][0] = 0}
       y.size.times {|j| c[0][j] = 0}
@@ -1294,12 +1351,12 @@ module Sass
       end
       c
     end
-    # rubocop:disable ParameterLists, LineLength
+    # rubocop:disable ParameterLists
 
     # Computes a single longest common subsequence for arrays x and y.
     # Algorithm from [Wikipedia](http://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Reading_out_an_LCS)
     def lcs_backtrace(c, x, y, i, j, &block)
-      # rubocop:enable ParameterList, LineLengths
+      # rubocop:enable ParameterList
       return [] if i == 0 || j == 0
       if (v = yield(x[i], y[j]))
         return lcs_backtrace(c, x, y, i - 1, j - 1, &block) << v

data/lib/sass/version.rb

@@ -8,7 +8,7 @@ module Sass
   # if it was installed from Git.
   module Version
     # Returns a hash representing the version of Sass.
-    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
+    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Integers.
     # The `:name` key has the name of the version.
     # The `:string` key contains a human-readable string representation of the version.
     # The `:number` key is the major, minor, and teeny keys separated by periods.
@@ -41,7 +41,7 @@ module Sass
     #       :prerelease_number => 1
     #     }
     #
-    # @return [{Symbol => String/Fixnum}] The version hash
+    # @return [{Symbol => String/Integer}] The version hash
     # @comment
     #   rubocop:disable ClassVars
     def version

data/lib/sass.rb

@@ -47,7 +47,7 @@ module Sass
   #
   # @param contents [String] The contents of the Sass file.
   # @param options [{Symbol => Object}] An options hash;
-  #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+  #   see {file:SASS_REFERENCE.md#Options the Sass options documentation}
   # @raise [Sass::SyntaxError] if there's an error in the document
   # @raise [Encoding::UndefinedConversionError] if the source encoding
   #   cannot be converted to UTF-8
@@ -69,7 +69,7 @@ module Sass
   #
   #   @param filename [String] The path to the Sass, SCSS, or CSS file on disk.
   #   @param options [{Symbol => Object}] 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 [String] The compiled CSS.
   #
   # @overload compile_file(filename, css_filename, options = {})
@@ -77,7 +77,7 @@ module Sass
   #
   #   @param filename [String] The path to the Sass, SCSS, or CSS file on disk.
   #   @param options [{Symbol => Object}] An options hash;
-  #     see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+  #     see {file:SASS_REFERENCE.md#Options the Sass options documentation}
   #   @param css_filename [String] The location to which to write the compiled CSS.
   def self.compile_file(filename, *args)
     options = args.last.is_a?(Hash) ? args.pop : {}
@@ -100,3 +100,10 @@ require 'sass/engine'
 require 'sass/plugin' if defined?(Merb::Plugins)
 require 'sass/railtie'
 require 'sass/features'
+
+if Sass::Util.ruby1?
+  Sass::Util.sass_warn(
+    "DEPRECATION WARNING:\n" +
+    "Sass 3.5 will no longer support Ruby #{RUBY_VERSION}.\n" +
+    "Please upgrade to Ruby 2.0.0 or greater as soon as possible.\n")
+end