sass 3.3.0 → 3.4.25

data/lib/sass/util.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'erb'
 require 'set'
 require 'enumerator'
@@ -12,12 +13,14 @@ require 'sass/util/subset_map'
 
 module Sass
   # A module containing various useful functions.
+  # @comment
+  #   rubocop:disable ModuleLength
   module Util
     extend self
 
     # An array of ints representing the Ruby version number.
     # @api public
-    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
+    RUBY_VERSION_COMPONENTS = 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.
@@ -137,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.
     #
@@ -162,6 +177,43 @@ 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.
     #
@@ -227,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
 
@@ -260,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
@@ -287,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#-`.
@@ -300,6 +364,18 @@ 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`.
     #
@@ -354,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]
@@ -448,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
 
@@ -507,8 +583,17 @@ module Sass
     #
     # @return [Boolean]
     def listen_geq_2?
-      require 'listen/version'
-      version_geq(::Listen::VERSION, '2.0.0')
+      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
+          false
+        end
     end
 
     # Returns an ActionView::Template* class.
@@ -563,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
@@ -572,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
@@ -583,13 +668,99 @@ module Sass
     # Like `Pathname.new`, but normalizes Windows paths to always use backslash
     # separators.
     #
-    # `Pathname.relative_path_from` can break if the two pathnames aren't
+    # `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
+
+    # 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 =~ %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
@@ -610,7 +781,7 @@ module Sass
     # @return [Boolean]
     def ruby1?
       return @ruby1 if defined?(@ruby1)
-      @ruby1 = Sass::Util::RUBY_VERSION[0] <= 1
+      @ruby1 = RUBY_VERSION_COMPONENTS[0] <= 1
     end
 
     # Whether or not this is running under Ruby 1.8 or lower.
@@ -624,16 +795,28 @@ module Sass
       # We have to fall back to 1.8 behavior.
       return @ruby1_8 if defined?(@ruby1_8)
       @ruby1_8 = ironruby? ||
-                   (Sass::Util::RUBY_VERSION[0] == 1 && Sass::Util::RUBY_VERSION[1] < 9)
+                   (RUBY_VERSION_COMPONENTS[0] == 1 && RUBY_VERSION_COMPONENTS[1] < 9)
+    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]
     end
 
-    # Whether or not this is running under Ruby 1.8.6 or lower.
-    # Note that lower versions are not officially supported.
+    # Whether or not this is running under Ruby 2.4 or higher.
     #
     # @return [Boolean]
-    def ruby1_8_6?
-      return @ruby1_8_6 if defined?(@ruby1_8_6)
-      @ruby1_8_6 = ruby1_8? && Sass::Util::RUBY_VERSION[2] < 7
+    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.
@@ -677,117 +860,80 @@ 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
 
-    # 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
-
-      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
-      str
+    unless ruby1_8?
+      CHARSET_REGEXP = /\A@charset "([^"]+)"/
+      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
     # at the beginning of the file and uses that encoding if it exists.
     #
-    # 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.
+    # Sass follows CSS's decoding rules.
     #
     # @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`
-    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
+    # @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
-      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
+
+      # 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')
           end
         end
-        str.force_encoding(charset)
-      elsif bom
-        str.force_encoding(encoding)
+        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')
       end
 
-      str = check_encoding(str, &block)
-      return str.encode("UTF-8"), str.encoding
-    end
+      find_encoding_error(str) unless str.valid_encoding?
 
-    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
+      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)
       end
     end
 
@@ -820,7 +966,7 @@ MSG
     # 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)
@@ -829,7 +975,7 @@ MSG
     # 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)
@@ -856,22 +1002,11 @@ MSG
     # 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.
@@ -890,27 +1025,6 @@ MSG
       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]`
@@ -919,7 +1033,7 @@ MSG
     # @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]} + '"'
@@ -1013,11 +1127,11 @@ MSG
 
     # 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) + "\""
@@ -1039,7 +1153,7 @@ MSG
     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|
@@ -1050,7 +1164,7 @@ MSG
 
     # 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
@@ -1128,15 +1242,25 @@ MSG
     # rename operation.
     #
     # @param filename [String] The file to write to.
+    # @param perms [Integer] The permissions used for creating this file.
+    #   Will be masked by the process umask. Defaults to readable/writeable
+    #   by all users however the umask usually changes this to only be writable
+    #   by the process's user.
     # @yieldparam tmpfile [Tempfile] The temp file that can be written to.
     # @return The value returned by the block.
-    def atomic_create_and_write_file(filename)
+    def atomic_create_and_write_file(filename, perms = 0666)
       require 'tempfile'
       tmpfile = Tempfile.new(File.basename(filename), File.dirname(filename))
       tmpfile.binmode if tmpfile.respond_to?(:binmode)
       result = yield tmpfile
       tmpfile.close
       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
@@ -1147,15 +1271,71 @@ MSG
       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 = "~> 3.0"
+            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
 
-    # rubocop:disable LineLength
+    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
 
     # 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}
@@ -1171,12 +1351,12 @@ MSG
       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