oreorenasass 3.4.4 → 3.4.5

data/lib/sass/tree/warn_node.rb

@@ -5,10 +5,10 @@ module Sass
     # @see Sass::Tree
     class WarnNode < Node
       # The expression to print.
-      # @return [Script::Tree::Node]
+      # @return [Script::Node]
       attr_accessor :expr
 
-      # @param expr [Script::Tree::Node] The expression to print
+      # @param expr [Script::Node] The expression to print
       def initialize(expr)
         @expr = expr
         super()

data/lib/sass/tree/while_node.rb

@@ -6,10 +6,10 @@ module Sass::Tree
   # @see Sass::Tree
   class WhileNode < Node
     # The parse tree for the continuation expression.
-    # @return [Script::Tree::Node]
+    # @return [Script::Node]
     attr_accessor :expr
 
-    # @param expr [Script::Tree::Node] See \{#expr}
+    # @param expr [Script::Node] See \{#expr}
     def initialize(expr)
       @expr = expr
       super()

data/lib/sass/util.rb

@@ -1,12 +1,9 @@
-# -*- coding: utf-8 -*-
 require 'erb'
 require 'set'
 require 'enumerator'
 require 'stringio'
 require 'rbconfig'
-require 'uri'
 require 'thread'
-require 'pathname'
 
 require 'sass/root'
 require 'sass/util/subset_map'
@@ -18,7 +15,7 @@ module Sass
 
     # An array of ints representing the Ruby version number.
     # @api public
-    RUBY_VERSION_COMPONENTS = RUBY_VERSION.split(".").map {|s| s.to_i}
+    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
 
     # The Ruby engine we're running under. Defaults to `"ruby"`
     # if the top-level constant is undefined.
@@ -41,7 +38,7 @@ module Sass
     # @param arr [Array<(Object, Object)>] An array of pairs
     # @return [Hash] A hash
     def to_hash(arr)
-      ordered_hash(*arr.compact)
+      Hash[arr.compact]
     end
 
     # Maps the keys in a hash according to a block.
@@ -57,7 +54,7 @@ module Sass
     # @see #map_vals
     # @see #map_hash
     def map_keys(hash)
-      map_hash(hash) {|k, v| [yield(k), v]}
+      to_hash(hash.map {|k, v| [yield(k), v]})
     end
 
     # Maps the values in a hash according to a block.
@@ -73,14 +70,7 @@ module Sass
     # @see #map_keys
     # @see #map_hash
     def map_vals(hash)
-      # We don't delegate to map_hash for performance here
-      # because map_hash does more than is necessary.
-      rv = hash.class.new
-      hash = hash.as_stored if hash.is_a?(NormalizedMap)
-      hash.each do |k, v|
-        rv[k] = yield(v)
-      end
-      rv
+      to_hash(hash.map {|k, v| [k, yield(v)]})
     end
 
     # Maps the key-value pairs of a hash according to a block.
@@ -97,15 +87,8 @@ module Sass
     # @see #map_keys
     # @see #map_vals
     def map_hash(hash)
-      # Copy and modify is more performant than mapping to an array and using
-      # to_hash on the result.
-      rv = hash.class.new
-      hash.each do |k, v|
-        new_key, new_value = yield(k, v)
-        new_key = hash.denormalize(new_key) if hash.is_a?(NormalizedMap) && new_key == k
-        rv[new_key] = new_value
-      end
-      rv
+      # Using &block here completely hoses performance on 1.8.
+      to_hash(hash.map {|k, v| yield k, v})
     end
 
     # Computes the powerset of the given array.
@@ -163,43 +146,6 @@ module Sass
       end
     end
 
-    # Non-destructively replaces all occurrences of a subsequence in an array
-    # with another subsequence.
-    #
-    # @example
-    #   replace_subseq([1, 2, 3, 4, 5], [2, 3], [:a, :b])
-    #     #=> [1, :a, :b, 4, 5]
-    #
-    # @param arr [Array] The array whose subsequences will be replaced.
-    # @param subseq [Array] The subsequence to find and replace.
-    # @param replacement [Array] The sequence that `subseq` will be replaced with.
-    # @return [Array] `arr` with `subseq` replaced with `replacement`.
-    def replace_subseq(arr, subseq, replacement)
-      new = []
-      matched = []
-      i = 0
-      arr.each do |elem|
-        if elem != subseq[i]
-          new.push(*matched)
-          matched = []
-          i = 0
-          new << elem
-          next
-        end
-
-        if i == subseq.length - 1
-          matched = []
-          i = 0
-          new.push(*replacement)
-        else
-          matched << elem
-          i += 1
-        end
-      end
-      new.push(*matched)
-      new
-    end
-
     # Intersperses a value in an enumerable, as would be done with `Array#join`
     # but without concatenating the array together afterwards.
     #
@@ -210,19 +156,6 @@ module Sass
       enum.inject([]) {|a, e| a << e << val}[0...-1]
     end
 
-    def slice_by(enum)
-      results = []
-      enum.each do |value|
-        key = yield(value)
-        if !results.empty? && results.last.first == key
-          results.last.last << value
-        else
-          results << [key, [value]]
-        end
-      end
-      results
-    end
-
     # Substitutes a sub-array of one array with another sub-array.
     #
     # @param ary [Array] The array in which to make the substitution
@@ -232,8 +165,8 @@ module Sass
       res = ary.dup
       i = 0
       while i < res.size
-        if res[i...i + from.size] == from
-          res[i...i + from.size] = to
+        if res[i...i+from.size] == from
+          res[i...i+from.size] = to
         end
         i += 1
       end
@@ -284,7 +217,7 @@ module Sass
       x = [nil, *x]
       y = [nil, *y]
       block ||= proc {|a, b| a == b && a}
-      lcs_backtrace(lcs_table(x, y, &block), x, y, x.size - 1, y.size - 1, &block)
+      lcs_backtrace(lcs_table(x, y, &block), x, y, x.size-1, y.size-1, &block)
     end
 
     # Converts a Hash to an Array. This is usually identical to `Hash#to_a`,
@@ -298,28 +231,27 @@ 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}
+      return hash.sort_by {|k, v| k}
     end
 
     # Performs the equivalent of `enum.group_by.to_a`, but with a guaranteed
-    # order. Unlike {Util#hash_to_a}, the resulting order isn't sorted key order;
+    # order. Unlike [#hash_to_a], the resulting order isn't sorted key order;
     # instead, it's the same order as `#group_by` has under Ruby 1.9 (key
     # appearance order).
     #
     # @param enum [Enumerable]
     # @return [Array<[Object, Array]>] An array of pairs.
-    def group_by_to_a(enum)
-      return enum.group_by {|e| yield(e)}.to_a unless ruby1_8?
+    def group_by_to_a(enum, &block)
+      return enum.group_by(&block).to_a unless ruby1_8?
       order = {}
       arr = []
-      groups = enum.group_by do |e|
-        res = yield(e)
+      enum.group_by do |e|
+        res = block[e]
         unless order.include?(res)
           order[res] = order.size
         end
         res
-      end
-      groups.each do |key, vals|
+      end.each do |key, vals|
         arr[order[key]] = [key, vals]
       end
       arr
@@ -327,7 +259,7 @@ module Sass
 
     # 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#-`.
+    # `minuend`, even on Rubinius where that's not guaranteed by {Array#-}.
     #
     # @param minuend [Array]
     # @param subtrahend [Array]
@@ -338,22 +270,10 @@ module Sass
       minuend.select {|e| set.include?(e)}
     end
 
-    # Returns the maximum of `val1` and `val2`. We use this over \{Array.max} to
-    # avoid unnecessary garbage collection.
-    def max(val1, val2)
-      val1 > val2 ? val1 : val2
-    end
-
-    # Returns the minimum of `val1` and `val2`. We use this over \{Array.min} to
-    # avoid unnecessary garbage collection.
-    def min(val1, val2)
-      val1 <= val2 ? val1 : val2
-    end
-
     # Returns a string description of the character that caused an
     # `Encoding::UndefinedConversionError`.
     #
-    # @param e [Encoding::UndefinedConversionError]
+    # @param [Encoding::UndefinedConversionError]
     # @return [String]
     def undefined_conversion_error_char(e)
       # Rubinius (as of 2.0.0.rc1) pre-quotes the error character.
@@ -361,7 +281,7 @@ module Sass
       # JRuby (as of 1.7.2) doesn't have an error_char field on
       # Encoding::UndefinedConversionError.
       return e.error_char.dump unless jruby?
-      e.message[/^"[^"]+"/] # "
+      e.message[/^"[^"]+"/] #"
     end
 
     # Asserts that `value` falls within `range` (inclusive), leaving
@@ -369,14 +289,14 @@ module Sass
     #
     # @param name [String] The name of the value. Used in the error message.
     # @param range [Range] The allowed range of values.
-    # @param value [Numeric, Sass::Script::Value::Number] The value to check.
+    # @param value [Numeric, Sass::Script::Number] The value to check.
     # @param unit [String] The unit of the value. Used in error reporting.
     # @return [Numeric] `value` adjusted to fall within range, if it
     #   was outside by a floating-point margin.
-    def check_range(name, range, value, unit = '')
+    def check_range(name, range, value, unit='')
       grace = (-0.00001..0.00001)
       str = value.to_s
-      value = value.value if value.is_a?(Sass::Script::Value::Number)
+      value = value.value if value.is_a?(Sass::Script::Number)
       return value if range.include?(value)
       return range.first if grace.include?(value - range.first)
       return range.last if grace.include?(value - range.last)
@@ -404,8 +324,7 @@ 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)]]
-    #   An array containing the filename, line, and method name of the caller.
+    # @return [[String, Fixnum, (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.
@@ -463,17 +382,6 @@ module Sass
       raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
     end
 
-    # Prints a deprecation warning for the caller method.
-    #
-    # @param obj [Object] `self`
-    # @param message [String] A message describing what to do instead.
-    def deprecated(obj, message = nil)
-      obj_class = obj.is_a?(Class) ? "#{obj}." : "#{obj.class}#"
-      full_message = "DEPRECATION WARNING: #{obj_class}#{caller_info[2]} " +
-        "will be removed in a future version of Sass.#{("\n" + message) if message}"
-      Sass::Util.sass_warn full_message
-    end
-
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -484,6 +392,7 @@ module Sass
       $stderr = the_real_stderr
     end
 
+    @@silence_warnings = false
     # Silences all Sass warnings within a block.
     #
     # @yield A block in which no Sass warnings will be printed
@@ -515,7 +424,7 @@ module Sass
         raise "ERROR: Rails.root is nil!"
       end
       return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
-      nil
+      return nil
     end
 
     # Returns the environment of the Rails application,
@@ -526,7 +435,7 @@ module Sass
     def rails_env
       return ::Rails.env.to_s if defined?(::Rails.env)
       return RAILS_ENV.to_s if defined?(RAILS_ENV)
-      nil
+      return nil
     end
 
     # Returns whether this environment is using ActionPack
@@ -552,21 +461,6 @@ module Sass
       version_geq(ActionPack::VERSION::STRING, version)
     end
 
-    # Returns whether this environment is using Listen
-    # version 2.0.0 or greater.
-    #
-    # @return [Boolean]
-    def listen_geq_2?
-      return @listen_geq_2 unless @listen_geq_2.nil?
-      @listen_geq_2 =
-        begin
-          require 'listen/version'
-          version_geq(::Listen::VERSION, '2.0.0')
-        rescue LoadError
-          false
-        end
-    end
-
     # Returns an ActionView::Template* class.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -577,101 +471,52 @@ module Sass
     #   or `ActionView::Template::Error`.
     def av_template_class(name)
       return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
-      ActionView::Template.const_get(name.to_s)
+      return ActionView::Template.const_get(name.to_s)
     end
 
     ## Cross-OS Compatibility
-    #
-    # These methods are cached because some of them are called quite frequently
-    # and even basic checks like String#== are too costly to be called repeatedly.
 
     # Whether or not this is running on Windows.
     #
     # @return [Boolean]
     def windows?
-      return @windows if defined?(@windows)
-      @windows = (RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i)
+      RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
     end
 
     # Whether or not this is running on IronRuby.
     #
     # @return [Boolean]
     def ironruby?
-      return @ironruby if defined?(@ironruby)
-      @ironruby = RUBY_ENGINE == "ironruby"
+      RUBY_ENGINE == "ironruby"
     end
 
     # Whether or not this is running on Rubinius.
     #
     # @return [Boolean]
     def rbx?
-      return @rbx if defined?(@rbx)
-      @rbx = RUBY_ENGINE == "rbx"
+      RUBY_ENGINE == "rbx"
     end
 
     # Whether or not this is running on JRuby.
     #
     # @return [Boolean]
     def jruby?
-      return @jruby if defined?(@jruby)
-      @jruby = RUBY_PLATFORM =~ /java/
+      RUBY_PLATFORM =~ /java/
     end
 
     # Returns an array of ints representing the JRuby version number.
     #
     # @return [Array<Fixnum>]
     def jruby_version
-      @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
+      $jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
     end
 
     # Like `Dir.glob`, but works with backslash-separated paths on Windows.
     #
     # @param path [String]
-    def glob(path)
+    def glob(path, &block)
       path = path.gsub('\\', '/') if windows?
-      if block_given?
-        Dir.glob(path) {|f| yield(f)}
-      else
-        Dir.glob(path)
-      end
-    end
-
-    # Like `Pathname.new`, but normalizes Windows paths to always use backslash
-    # separators.
-    #
-    # `Pathname#relative_path_from` can break if the two pathnames aren't
-    # consistent in their slash style.
-    #
-    # @param path [String]
-    # @return [Pathname]
-    def pathname(path)
-      path = path.tr("/", "\\") if windows?
-      Pathname.new(path)
-    end
-
-    # Like `Pathname#cleanpath`, but normalizes Windows paths to always use
-    # backslash separators. Normally, `Pathname#cleanpath` actually does the
-    # reverse -- it will convert backslashes to forward slashes, which can break
-    # `Pathname#relative_path_from`.
-    #
-    # @param path [String, Pathname]
-    # @return [Pathname]
-    def cleanpath(path)
-      path = Pathname.new(path) unless path.is_a?(Pathname)
-      pathname(path.cleanpath.to_s)
-    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 = 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 =~ /\\\\[^\\]+\\[^\\\/]+/
-      path.tr("\\", "/")
+      Dir.glob(path, &block)
     end
 
     # Prepare a value for a destructuring assignment (e.g. `a, b =
@@ -693,8 +538,7 @@ module Sass
     #
     # @return [Boolean]
     def ruby1?
-      return @ruby1 if defined?(@ruby1)
-      @ruby1 = RUBY_VERSION_COMPONENTS[0] <= 1
+      Sass::Util::RUBY_VERSION[0] <= 1
     end
 
     # Whether or not this is running under Ruby 1.8 or lower.
@@ -706,9 +550,7 @@ module Sass
     def ruby1_8?
       # IronRuby says its version is 1.9, but doesn't support any of the encoding APIs.
       # We have to fall back to 1.8 behavior.
-      return @ruby1_8 if defined?(@ruby1_8)
-      @ruby1_8 = ironruby? ||
-                   (RUBY_VERSION_COMPONENTS[0] == 1 && RUBY_VERSION_COMPONENTS[1] < 9)
+      ironruby? || (Sass::Util::RUBY_VERSION[0] == 1 && Sass::Util::RUBY_VERSION[1] < 9)
     end
 
     # Whether or not this is running under Ruby 1.8.6 or lower.
@@ -716,132 +558,129 @@ module Sass
     #
     # @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]
-    def ruby1_9_2?
-      return @ruby1_9_2 if defined?(@ruby1_9_2)
-      @ruby1_9_2 = RUBY_VERSION_COMPONENTS == [1, 9, 2]
+      ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
     end
 
     # Wehter or not this is running under JRuby 1.6 or lower.
     def jruby1_6?
-      return @jruby1_6 if defined?(@jruby1_6)
-      @jruby1_6 = jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
+      jruby? && jruby_version[0] == 1 && jruby_version[1] < 7
     end
 
     # Whether or not this is running under MacRuby.
     #
     # @return [Boolean]
     def macruby?
-      return @macruby if defined?(@macruby)
-      @macruby = RUBY_ENGINE == 'macruby'
+      RUBY_ENGINE == 'macruby'
     end
 
-    require 'sass/util/ordered_hash' if ruby1_8?
-
-    # Converts a hash or a list of pairs into an order-preserving hash.
-    #
-    # On Ruby 1.8.7, this uses the orderedhash gem to simulate an
-    # order-preserving hash. On Ruby 1.9 and up, it just uses the native Hash
-    # class, since that preserves the order itself.
-    #
-    # @overload ordered_hash(hash)
-    #   @param hash [Hash] a normal hash to convert to an ordered hash
-    #   @return [Hash]
-    # @overload ordered_hash(*pairs)
-    #   @example
-    #     ordered_hash([:foo, "bar"], [:baz, "bang"])
-    #       #=> {:foo => "bar", :baz => "bang"}
-    #     ordered_hash #=> {}
-    #   @param pairs [Array<(Object, Object)>] the list of key/value pairs for
-    #     the hash.
-    #   @return [Hash]
-    def ordered_hash(*pairs_or_hash)
-      if pairs_or_hash.length == 1 && pairs_or_hash.first.is_a?(Hash)
-        hash = pairs_or_hash.first
-        return hash unless ruby1_8?
-        return OrderedHash.new.merge hash
+    # Checks that the encoding of a string is valid in Ruby 1.9
+    # and cleans up potential encoding gotchas like the UTF-8 BOM.
+    # If it's not, yields an error string describing the invalid character
+    # and the line on which it occurrs.
+    #
+    # @param str [String] The string of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
+    # @return [String] `str`, potentially with encoding gotchas like BOMs removed
+    def check_encoding(str)
+      if ruby1_8?
+        return str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
+      elsif str.valid_encoding?
+        # Get rid of the Unicode BOM if possible
+        if str.encoding.name =~ /^UTF-(8|16|32)(BE|LE)?$/
+          return str.gsub(Regexp.new("\\A\uFEFF".encode(str.encoding.name)), '')
+        else
+          return str
+        end
       end
 
-      return Hash[pairs_or_hash] unless ruby1_8?
-      (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*flatten(pairs_or_hash, 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')
+      encoding = str.encoding
+      newlines = Regexp.new("\r\n|\r|\n".encode(encoding).force_encoding("binary"))
+      str.force_encoding("binary").split(newlines).each_with_index do |line, i|
+        begin
+          line.encode(encoding)
+        rescue Encoding::UndefinedConversionError => e
+          yield <<MSG.rstrip, i + 1
+Invalid #{encoding.name} character #{undefined_conversion_error_char(e)}
+MSG
+        end
+      end
+      return str
     end
 
     # Like {\#check\_encoding}, but also checks for a `@charset` declaration
     # at the beginning of the file and uses that encoding if it exists.
     #
-    # Sass follows CSS's decoding rules.
+    # The Sass encoding rules are simple.
+    # If a `@charset` declaration exists,
+    # we assume that that's the original encoding of the document.
+    # Otherwise, we use whatever encoding Ruby has.
+    # Then we convert that to UTF-8 to process internally.
+    # The UTF-8 end result is what's returned by this method.
     #
     # @param str [String] The string of which to check the encoding
+    # @yield [msg] A block in which an encoding error can be raised.
+    #   Only yields if there is an encoding error
+    # @yieldparam msg [String] The error message to be raised
     # @return [(String, Encoding)] The original string encoded as UTF-8,
     #   and the source encoding of the string (or `nil` under Ruby 1.8)
     # @raise [Encoding::UndefinedConversionError] if the source encoding
     #   cannot be converted to UTF-8
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
-    # @raise [Sass::SyntaxError] If the document declares an encoding that
-    #   doesn't match its contents, or it doesn't declare an encoding and its
-    #   contents are invalid in the native encoding.
-    def check_sass_encoding(str)
-      # On Ruby 1.8 we can't do anything complicated with encodings.
-      # Instead, we just strip out a UTF-8 BOM if it exists and
-      # sanitize according to Section 3.3 of CSS Syntax Level 3. We
-      # don't sanitize null characters since they might be components
-      # of other characters.
-      if ruby1_8?
-        return str.gsub(/\A\xEF\xBB\xBF/, '').gsub(/\r\n?|\f/, "\n"), nil
-      end
-
-      # Determine the fallback encoding following section 3.2 of CSS Syntax Level 3 and Encodings:
-      # http://www.w3.org/TR/2013/WD-css-syntax-3-20130919/#determine-the-fallback-encoding
-      # http://encoding.spec.whatwg.org/#decode
-      binary = str.dup.force_encoding("BINARY")
-      if binary.start_with?(UTF_8_BOM)
-        binary.slice! 0, UTF_8_BOM.length
-        str = binary.force_encoding('UTF-8')
-      elsif binary.start_with?(UTF_16BE_BOM)
-        binary.slice! 0, UTF_16BE_BOM.length
-        str = binary.force_encoding('UTF-16BE')
-      elsif binary.start_with?(UTF_16LE_BOM)
-        binary.slice! 0, UTF_16LE_BOM.length
-        str = binary.force_encoding('UTF-16LE')
-      elsif binary =~ CHARSET_REGEXP
-        charset = $1.force_encoding('US-ASCII')
-        # Ruby 1.9.2 doesn't recognize a UTF-16 encoding without an endian marker.
-        if ruby1_9_2? && charset.downcase == 'utf-16'
-          encoding = Encoding.find('UTF-8')
-        else
-          encoding = Encoding.find(charset)
-          if encoding.name == 'UTF-16' || encoding.name == 'UTF-16BE'
-            encoding = Encoding.find('UTF-8')
+    def check_sass_encoding(str, &block)
+      return check_encoding(str, &block), nil if ruby1_8?
+      # We allow any printable ASCII characters but double quotes in the charset decl
+      bin = str.dup.force_encoding("BINARY")
+      encoding = Sass::Util::ENCODINGS_TO_CHECK.find do |enc|
+        re = Sass::Util::CHARSET_REGEXPS[enc]
+        re && bin =~ re
+      end
+      charset, bom = $1, $2
+      if charset
+        charset = charset.force_encoding(encoding).encode("UTF-8")
+        if endianness = encoding[/[BL]E$/]
+          begin
+            Encoding.find(charset + endianness)
+            charset << endianness
+          rescue ArgumentError # Encoding charset + endianness doesn't exist
           end
         end
-        str = binary.force_encoding(encoding)
-      elsif str.encoding.name == "ASCII-8BIT"
-        # Normally we want to fall back on believing the Ruby string
-        # encoding, but if that's just binary we want to make sure
-        # it's valid UTF-8.
-        str = str.force_encoding('utf-8')
+        str.force_encoding(charset)
+      elsif bom
+        str.force_encoding(encoding)
       end
 
-      find_encoding_error(str) unless str.valid_encoding?
+      str = check_encoding(str, &block)
+      return str.encode("UTF-8"), str.encoding
+    end
 
-      begin
-        # If the string is valid, preprocess it according to section 3.3 of CSS Syntax Level 3.
-        return str.encode("UTF-8").gsub(/\r\n?|\f/, "\n").tr("\u0000", "�"), str.encoding
-      rescue EncodingError
-        find_encoding_error(str)
+    unless ruby1_8?
+      # @private
+      def _enc(string, encoding)
+        string.encode(encoding).force_encoding("BINARY")
+      end
+
+      # We could automatically add in any non-ASCII-compatible encodings here,
+      # but there's not really a good way to do that
+      # without manually checking that each encoding
+      # encodes all ASCII characters properly,
+      # which takes long enough to affect the startup time of the CLI.
+      ENCODINGS_TO_CHECK = %w[UTF-8 UTF-16BE UTF-16LE UTF-32BE UTF-32LE]
+
+      CHARSET_REGEXPS = Hash.new do |h, e|
+        h[e] =
+          begin
+            # /\A(?:\uFEFF)?@charset "(.*?)"|\A(\uFEFF)/
+            Regexp.new(/\A(?:#{_enc("\uFEFF", e)})?#{
+              _enc('@charset "', e)}(.*?)#{_enc('"', e)}|\A(#{
+              _enc("\uFEFF", e)})/)
+          rescue Encoding::ConverterNotFoundError => _
+            nil # JRuby on Java 5 doesn't support UTF-32
+          rescue
+            # /\A@charset "(.*?)"/
+            Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
+          end
       end
     end
 
@@ -926,24 +765,6 @@ module Sass
       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.
-    #
-    # @param arrs [Array] The array to flatten.
-    # @return [Array] The flattened array.
-    def flatten_vertically(arrs)
-      result = []
-      arrs = arrs.map {|sub| sub.is_a?(Array) ? sub.dup : Array(sub)}
-      until arrs.empty?
-        arrs.reject! do |arr|
-          result << arr.shift
-          arr.empty?
-        end
-      end
-      result
-    end
-
     # Returns the hash code for a set in a cross-version manner.
     # Aggravatingly, this is order-dependent in Ruby 1.8.6.
     #
@@ -965,15 +786,14 @@ module Sass
       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]`
+    # 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]`
     # before being evaluated.
     #
     # @param obj {Object}
     # @return {String}
     def inspect_obj(obj)
-      return obj.inspect unless version_geq(RUBY_VERSION, "1.9.2")
+      return obj.inspect unless version_geq(::RUBY_VERSION, "1.9.2")
       return ':' + inspect_obj(obj.to_s) if obj.is_a?(Symbol)
       return obj.inspect unless obj.is_a?(String)
       '"' + obj.gsub(/[\x00-\x7F]+/) {|s| s.inspect[1...-1]} + '"'
@@ -993,12 +813,11 @@ module Sass
     # @return [(String, Array)] The resulting string, and an array of extracted values.
     def extract_values(arr)
       values = []
-      mapped = arr.map do |e|
+      return arr.map do |e|
         next e.gsub('{', '{{') if e.is_a?(String)
         values << e
         next "{#{values.count - 1}}"
-      end
-      return mapped.join, values
+      end.join, values
     end
 
     # Undoes \{#extract\_values} by transforming a string with escape sequences
@@ -1031,129 +850,6 @@ module Sass
       inject_values(str, vals)
     end
 
-    # Builds a sourcemap file name given the generated CSS file name.
-    #
-    # @param css [String] The generated CSS file name.
-    # @return [String] The source map file name.
-    def sourcemap_name(css)
-      css + ".map"
-    end
-
-    # Escapes certain characters so that the result can be used
-    # as the JSON string value. Returns the original string if
-    # no escaping is necessary.
-    #
-    # @param s [String] The string to be escaped
-    # @return [String] The escaped string
-    def json_escape_string(s)
-      return s if s !~ /["\\\b\f\n\r\t]/
-
-      result = ""
-      s.split("").each do |c|
-        case c
-        when '"', "\\"
-          result << "\\" << c
-        when "\n" then result << "\\n"
-        when "\t" then result << "\\t"
-        when "\r" then result << "\\r"
-        when "\f" then result << "\\f"
-        when "\b" then result << "\\b"
-        else
-          result << c
-        end
-      end
-      result
-    end
-
-    # Converts the argument into a valid JSON value.
-    #
-    # @param v [Fixnum, String, Array, Boolean, nil]
-    # @return [String]
-    def json_value_of(v)
-      case v
-      when Fixnum
-        v.to_s
-      when String
-        "\"" + json_escape_string(v) + "\""
-      when Array
-        "[" + v.map {|x| json_value_of(x)}.join(",") + "]"
-      when NilClass
-        "null"
-      when TrueClass
-        "true"
-      when FalseClass
-        "false"
-      else
-        raise ArgumentError.new("Unknown type: #{v.class.name}")
-      end
-    end
-
-    VLQ_BASE_SHIFT = 5
-    VLQ_BASE = 1 << VLQ_BASE_SHIFT
-    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_DIGIT_MAP = begin
-      map = {}
-      Sass::Util.enum_with_index(BASE64_DIGITS).map do |digit, i|
-        map[digit] = i
-      end
-      map
-    end
-
-    # Encodes `value` as VLQ (http://en.wikipedia.org/wiki/VLQ).
-    #
-    # @param value [Fixnum]
-    # @return [String] The encoded value
-    def encode_vlq(value)
-      if value < 0
-        value = ((-value) << 1) | 1
-      else
-        value <<= 1
-      end
-
-      result = ''
-      begin
-        digit = value & VLQ_BASE_MASK
-        value >>= VLQ_BASE_SHIFT
-        if value > 0
-          digit |= VLQ_CONTINUATION_BIT
-        end
-        result << BASE64_DIGITS[digit]
-      end while value > 0
-      result
-    end
-
-    # This is a hack around the fact that you can't instantiate a URI parser on
-    # 1.8, so we have to have this hacky stuff to work around it. When 1.8
-    # support is dropped, we can remove this method.
-    #
-    # @private
-    URI_ESCAPE = URI.const_defined?("DEFAULT_PARSER") ? URI::DEFAULT_PARSER : URI
-
-    # URI-escape `string`.
-    #
-    # @param string [String]
-    # @return [String]
-    def escape_uri(string)
-      URI_ESCAPE.escape string
-    end
-
-    # A cross-platform implementation of `File.absolute_path`.
-    #
-    # @param path [String]
-    # @param dir_string [String] The directory to consider [path] relative to.
-    # @return [String] The absolute version of `path`.
-    def absolute_path(path, dir_string = nil)
-      # Ruby 1.8 doesn't support File.absolute_path.
-      return File.absolute_path(path, dir_string) unless ruby1_8?
-
-      # File.expand_path expands "~", which we don't want.
-      return File.expand_path(path, dir_string) unless path[0] == ?~
-      File.expand_path(File.join(".", path), dir_string)
-    end
-
     ## Static Method Stuff
 
     # The context in which the ERB for \{#def\_static\_method} will be run.
@@ -1167,8 +863,8 @@ module Sass
       #
       # @param name [Symbol] The name of the variable
       # @return [Boolean]
-      def method_missing(name, *args)
-        super unless args.empty? && !block_given?
+      def method_missing(name, *args, &block)
+        super unless args.empty? && block.nil?
         @set.include?(name)
       end
     end
@@ -1176,6 +872,7 @@ module Sass
     # @private
     ATOMIC_WRITE_MUTEX = Mutex.new
 
+
     # This creates a temp file and yields it for writing. When the
     # write is complete, the file is moved into the desired location.
     # The atomicity of this operation is provided by the filesystem's
@@ -1193,14 +890,16 @@ module Sass
       tmpfile = Tempfile.new(File.basename(filename), File.dirname(filename))
       tmpfile.binmode if tmpfile.respond_to?(:binmode)
       result = yield tmpfile
-      tmpfile.close
+      tmpfile.flush # ensure all writes are flushed to the OS
+      begin
+        tmpfile.fsync # ensure all buffered data in the OS is sync'd to disk.
+      rescue NotImplementedError
+        # Not all OSes support fsync
+      end
+      tmpfile.close # Windows cannot rename an open file.
+      # Make file readable and writeable to all but respect umask (usually 022).
+      File.chmod(perms & ~File.umask, tmpfile.path)
       ATOMIC_WRITE_MUTEX.synchronize do
-        begin
-          File.chmod(perms & ~File.umask, tmpfile.path)
-        rescue Errno::EPERM
-          # If we don't have permissions to chmod the file, don't let that crash
-          # the compilation. See issue 1215.
-        end
         File.rename tmpfile.path, filename
       end
       result
@@ -1211,74 +910,11 @@ module Sass
       tmpfile.unlink if tmpfile
     end
 
-    def load_listen!
-      if defined?(gem)
-        begin
-          gem 'listen', '>= 1.1.0', '< 3.0.0'
-          require 'listen'
-        rescue Gem::LoadError
-          dir = scope("vendor/listen/lib")
-          $LOAD_PATH.unshift dir
-          begin
-            require 'listen'
-          rescue LoadError => e
-            if version_geq(RUBY_VERSION, "1.9.3")
-              version_constraint = "~> 2.7"
-            else
-              version_constraint = "~> 1.1"
-            end
-            e.message << "\n" <<
-              "Run \"gem install listen --version '#{version_constraint}'\" to get it."
-            raise e
-          end
-        end
-      else
-        begin
-          require 'listen'
-        rescue LoadError => e
-          dir = scope("vendor/listen/lib")
-          if $LOAD_PATH.include?(dir)
-            raise e unless File.exist?(scope(".git"))
-            e.message << "\n" <<
-              'Run "git submodule update --init" to get the bundled version.'
-          else
-            $LOAD_PATH.unshift dir
-            retry
-          end
-        end
-      end
-    end
-
     private
 
-    def find_encoding_error(str)
-      encoding = str.encoding
-      cr = Regexp.quote("\r".encode(encoding).force_encoding('BINARY'))
-      lf = Regexp.quote("\n".encode(encoding).force_encoding('BINARY'))
-      ff = Regexp.quote("\f".encode(encoding).force_encoding('BINARY'))
-      line_break = /#{cr}#{lf}?|#{ff}|#{lf}/
-
-      str.force_encoding("binary").split(line_break).each_with_index do |line, i|
-        begin
-          line.encode(encoding)
-        rescue Encoding::UndefinedConversionError => e
-          raise Sass::SyntaxError.new(
-            "Invalid #{encoding.name} character #{undefined_conversion_error_char(e)}",
-            :line => i + 1)
-        end
-      end
-
-      # We shouldn't get here, but it's possible some weird encoding stuff causes it.
-      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}
@@ -1286,33 +922,27 @@ module Sass
         (1...y.size).each do |j|
           c[i][j] =
             if yield x[i], y[j]
-              c[i - 1][j - 1] + 1
+              c[i-1][j-1] + 1
             else
-              [c[i][j - 1], c[i - 1][j]].max
+              [c[i][j-1], c[i-1][j]].max
             end
         end
       end
-      c
+      return c
     end
-    # rubocop:disable ParameterLists, LineLength
 
     # 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
       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
+      if v = yield(x[i], y[j])
+        return lcs_backtrace(c, x, y, i-1, j-1, &block) << v
       end
 
-      return lcs_backtrace(c, x, y, i, j - 1, &block) if c[i][j - 1] > c[i - 1][j]
-      lcs_backtrace(c, x, y, i - 1, j, &block)
+      return lcs_backtrace(c, x, y, i, j-1, &block) if c[i][j-1] > c[i-1][j]
+      return lcs_backtrace(c, x, y, i-1, j, &block)
     end
-
-    singleton_methods.each {|method| module_function method}
   end
 end
 
 require 'sass/util/multibyte_string_scanner'
-require 'sass/util/normalized_map'
-require 'sass/util/cross_platform_random'