sass 3.4.25 → 3.5.0.pre.rc.1

data/lib/sass/tree/rule_node.rb

@@ -40,7 +40,7 @@ module Sass::Tree
     # * This is a child rule of another rule
     # * The parent rule has properties, and thus will be rendered
     #
-    # @return [Integer]
+    # @return [Fixnum]
     attr_accessor :tabs
 
     # The entire selector source range for this rule.
@@ -120,7 +120,8 @@ module Sass::Tree
     #
     # @return [{#to_s => #to_s}]
     def debug_info
-      {:filename => filename && ("file://" + Sass::Util.escape_uri(File.expand_path(filename))),
+      {:filename => filename &&
+         ("file://" + URI::DEFAULT_PARSER.escape(File.expand_path(filename))),
        :line => line}
     end
 
@@ -137,19 +138,10 @@ module Sass::Tree
 
       # We don't use real filename/line info because we don't have it yet.
       # When we get it, we'll set it on the parsed rules if possible.
-      parser = nil
-      warnings = Sass::Util.silence_warnings do
-        parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
-        # rubocop:disable RescueModifier
-        @parsed_rules = parser.parse_selector rescue nil
-        # rubocop:enable RescueModifier
-
-        $stderr.string
-      end
-
-      # If parsing produces a warning, throw away the result so we can parse
-      # later with the real filename info.
-      @parsed_rules = nil unless warnings.empty?
+      parser = Sass::SCSS::StaticParser.new(@rule.join.strip, nil, nil, 1)
+      # rubocop:disable RescueModifier
+      @parsed_rules = parser.parse_selector rescue nil
+      # rubocop:enable RescueModifier
     end
   end
 end

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

@@ -31,7 +31,7 @@ class Sass::Tree::Visitors::CheckNesting < Sass::Tree::Visitors::Base
     if parent.is_a?(Sass::Tree::AtRootNode) && parent.resolved_value
       old_parents = @parents
       @parents = @parents.reject {|p| parent.exclude_node?(p)}
-      @parent = Sass::Util.enum_with_index(@parents.reverse).
+      @parent = @parents.reverse.each_with_index.
         find {|p, i| !transparent_parent?(p, @parents[-i - 2])}.first
 
       begin

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

@@ -203,8 +203,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
 
     unless node.args.empty? && node.keywords.empty? && node.splat.nil?
       args = node.args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(node.keywords.as_stored).
-        map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
+      keywords = node.keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k)}: #{arg_to_sass[v]}"}
 
       if node.splat
         splat = "#{arg_to_sass[node.splat]}..."
@@ -281,7 +280,7 @@ class Sass::Tree::Visitors::Convert < Sass::Tree::Visitors::Base
   # Visit rule-level nodes and return their conversion with appropriate
   # whitespace added.
   def visit_rule_level(nodes)
-    Sass::Util.enum_cons(nodes + [nil], 2).map do |child, nxt|
+    (nodes + [nil]).each_cons(2).map do |child, nxt|
       visit(child) +
         if nxt &&
             (child.is_a?(Sass::Tree::CommentNode) && child.line + child.lines + 1 == nxt.line) ||

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

@@ -56,8 +56,7 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     @parents.pop
   end
 
-  # In Ruby 1.8, ensures that there's only one `@charset` directive
-  # and that it's at the top of the document.
+  # Converts the entire document to CSS.
   #
   # @return [(Tree::Node, Sass::Util::SubsetMap)] The resulting tree of static nodes
   #   *and* the extensions defined for this tree
@@ -65,14 +64,6 @@ class Sass::Tree::Visitors::Cssize < Sass::Tree::Visitors::Base
     yield
 
     if parent.nil?
-      # In Ruby 1.9 we can make all @charset nodes invisible
-      # and infer the final @charset from the encoding of the final string.
-      if Sass::Util.ruby1_8?
-        charset = node.children.find {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.reject! {|c| c.is_a?(Sass::Tree::CharsetNode)}
-        node.children.unshift charset if charset
-      end
-
       imports_to_move = []
       import_limit = nil
       i = -1

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

@@ -55,13 +55,13 @@ class Sass::Tree::Visitors::DeepCopy < Sass::Tree::Visitors::Base
 
   def visit_mixin(node)
     node.args = node.args.map {|a| a.deep_copy}
-    node.keywords = Sass::Util::NormalizedMap.new(Hash[node.keywords.map {|k, v| [k, v.deep_copy]}])
+    node.keywords = Hash[node.keywords.map {|k, v| [k, v.deep_copy]}]
     yield
   end
 
   def visit_prop(node)
     node.name = node.name.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
-    node.value = node.value.deep_copy
+    node.value = node.value.map {|c| c.is_a?(Sass::Script::Tree::Node) ? c.deep_copy : c}
     yield
   end
 

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

@@ -1,7 +1,5 @@
 # A visitor for converting a dynamic Sass tree into a static Sass tree.
 class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
-  @@function_name_deprecation = Sass::Deprecation.new
-
   class << self
     # @param root [Tree::Node] The root node of the tree to visit.
     # @param environment [Sass::Environment] The lexical environment.
@@ -282,7 +280,8 @@ class Sass::Tree::Visitors::Perform < Sass::Tree::Visitors::Base
 
     if node.normalized_name == 'calc' || node.normalized_name == 'element' ||
         node.name == 'expression' || node.name == 'url'
-      @@function_name_deprecation.warn(node.filename, node.line, <<WARNING)
+      Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING on line #{node.line}#{" of #{node.filename}" if node.filename}:
 Naming a function "#{node.name}" is disallowed and will be an error in future versions of Sass.
 This name conflicts with an existing CSS function with special parse rules.
 WARNING
@@ -290,7 +289,7 @@ WARNING
 
     @environment.set_local_function(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, false, "function"))
+                         node.children, false, "function", :stylesheet))
     []
   end
 
@@ -341,7 +340,7 @@ WARNING
     env = Sass::Environment.new(@environment, node.options)
     @environment.set_local_mixin(node.name,
       Sass::Callable.new(node.name, node.args, node.splat, env,
-                         node.children, node.has_content, "mixin"))
+                         node.children, node.has_content, "mixin", :stylesheet))
     []
   end
 
@@ -395,9 +394,19 @@ WARNING
   # Runs any SassScript that may be embedded in a property.
   def visit_prop(node)
     node.resolved_name = run_interp(node.name)
-    val = node.value.perform(@environment)
-    node.resolved_value = val.to_s
-    node.value_source_range = val.source_range if val.source_range
+
+    # If the node's value is just a variable or similar, we may get a useful
+    # source range from evaluating it.
+    if node.value.length == 1 && node.value.first.is_a?(Sass::Script::Tree::Node)
+      result = node.value.first.perform(@environment)
+      node.resolved_value = result.to_s
+      node.value_source_range = result.source_range if result.source_range
+    elsif node.custom_property?
+      node.resolved_value = run_interp_no_strip(node.value)
+    else
+      node.resolved_value = run_interp(node.value)
+    end
+
     yield
   end
 
@@ -483,9 +492,11 @@ WARNING
   def visit_warn(node)
     res = node.expr.perform(@environment)
     res = res.value if res.is_a?(Sass::Script::Value::String)
-    msg = "WARNING: #{res}\n         "
-    msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
-    Sass::Util.sass_warn msg
+    @environment.stack.with_directive(node.filename, node.line, "@warn") do
+      msg = "WARNING: #{res}\n         "
+      msg << @environment.stack.to_s.gsub("\n", "\n         ") << "\n"
+      Sass::Util.sass_warn msg
+    end
     []
   end
 
@@ -556,7 +567,7 @@ WARNING
     end
 
     files << node.filename << node.imported_file.options[:filename]
-    msg << "\n" << Sass::Util.enum_cons(files, 2).map do |m1, m2|
+    msg << "\n" << files.each_cons(2).map do |m1, m2|
       "    #{m1} imports #{m2}"
     end.join("\n")
     raise Sass::SyntaxError.new(msg)

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

@@ -88,7 +88,7 @@ class Sass::Tree::Visitors::SetOptions < Sass::Tree::Visitors::Base
 
   def visit_prop(node)
     node.name.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
-    node.value.options = @options
+    node.value.each {|c| c.options = @options if c.is_a?(Sass::Script::Tree::Node)}
     yield
   end
 

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

@@ -12,7 +12,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
     @tabs = 0
     @line = 1
     @offset = 1
-    @result = String.new("")
+    @result = ""
     @source_mapping = build_source_mapping ? Sass::Source::Map.new : nil
     @lstrip = nil
     @in_directive = false
@@ -135,7 +135,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
     output "\n"
 
-    unless Sass::Util.ruby1_8? || @result.ascii_only?
+    unless @result.ascii_only?
       if node.style == :compressed
         # A byte order mark is sufficient to tell browsers that this
         # file is UTF-8 encoded, and will override any other detection
@@ -261,18 +261,20 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
   end
 
   def visit_prop(node)
-    return if node.resolved_value.empty?
+    return if node.resolved_value.empty? && !node.custom_property?
     tab_str = '  ' * (@tabs + node.tabs)
     output(tab_str)
     for_node(node, :name) {output(node.resolved_name)}
-    if node.style == :compressed
-      output(":")
-      for_node(node, :value) {output(node.resolved_value)}
-    else
-      output(": ")
-      for_node(node, :value) {output(node.resolved_value)}
-      output(";")
+    output(":")
+    output(" ") unless node.style == :compressed || node.custom_property?
+    for_node(node, :value) do
+      output(if node.custom_property?
+               format_custom_property_value(node)
+             else
+               node.resolved_value
+             end)
     end
+    output(";") unless node.style == :compressed
   end
 
   # @comment
@@ -384,9 +386,41 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
 
   private
 
+  # Reformats the value of `node` so that it's nicely indented, preserving its
+  # existing relative indentation.
+  #
+  # @param node [Sass::Script::Tree::PropNode] A custom property node.
+  # @return [String]
+  def format_custom_property_value(node)
+    if node.style == :compact || node.style == :compressed || !node.resolved_value.include?("\n")
+      # Folding not involving newlines was done in the parser. We can safely
+      # fold newlines here because tokens like strings can't contain literal
+      # newlines, so we know any adjacent whitespace is tokenized as whitespace.
+      return node.resolved_value.gsub(/[ \t\r\f]*\n[ \t\r\f\n]*/, ' ')
+    end
+
+    # Find the smallest amount of indentation in the custom property and use
+    # that as the base indentation level.
+    lines = node.resolved_value.split("\n")
+    indented_lines = lines[1..-1]
+    min_indentation = indented_lines.
+      map {|line| line[/^[ \t]*/]}.
+      reject {|line| line.empty?}.
+      min_by {|line| line.length}
+
+    # Limit the base indentation to the same indentation level as the node name
+    # so that if *every* line is indented relative to the property name that's
+    # preserved.
+    if node.name_source_range
+      base_indentation = min_indentation[0...node.name_source_range.start_pos.offset - 1]
+    end
+
+    lines.first + "\n" + indented_lines.join("\n").gsub(/^#{base_indentation}/, '  ' * @tabs)
+  end
+
   def debug_info_rule(debug_info, options)
     node = Sass::Tree::DirectiveNode.resolved("@media -sass-debug-info")
-    Sass::Util.hash_to_a(debug_info.map {|k, v| [k.to_s, v.to_s]}).each do |k, v|
+    debug_info.map {|k, v| [k.to_s, v.to_s]}.to_a.each do |k, v|
       rule = Sass::Tree::RuleNode.new([""])
       rule.resolved_rules = Sass::Selector::CommaSequence.new(
         [Sass::Selector::Sequence.new(
@@ -395,7 +429,7 @@ class Sass::Tree::Visitors::ToCss < Sass::Tree::Visitors::Base
             false)
           ])
         ])
-      prop = Sass::Tree::PropNode.new([""], Sass::Script::Value::String.new(''), :new)
+      prop = Sass::Tree::PropNode.new([""], [""], :new)
       prop.resolved_name = "font-family"
       prop.resolved_value = Sass::SCSS::RX.escape_ident(v.to_s)
       rule << prop

data/lib/sass/util.rb

@@ -35,17 +35,6 @@ module Sass
       File.join(Sass::ROOT_DIR, file)
     end
 
-    # Converts an array of `[key, value]` pairs to a hash.
-    #
-    # @example
-    #   to_hash([[:foo, "bar"], [:baz, "bang"]])
-    #     #=> {:foo => "bar", :baz => "bang"}
-    # @param arr [Array<(Object, Object)>] An array of pairs
-    # @return [Hash] A hash
-    def to_hash(arr)
-      ordered_hash(*arr.compact)
-    end
-
     # Maps the keys in a hash according to a block.
     #
     # @example
@@ -301,56 +290,6 @@ module Sass
       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`,
-    # with the following exceptions:
-    #
-    # * In Ruby 1.8, `Hash#to_a` is not deterministically ordered, but this is.
-    # * In Ruby 1.9 when running tests, this is ordered in the same way it would
-    #   be under Ruby 1.8 (sorted key order rather than insertion order).
-    #
-    # @param hash [Hash]
-    # @return [Array]
-    def hash_to_a(hash)
-      return hash.to_a unless ruby1_8? || defined?(Test::Unit)
-      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;
-    # 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?
-      order = {}
-      arr = []
-      groups = enum.group_by do |e|
-        res = yield(e)
-        unless order.include?(res)
-          order[res] = order.size
-        end
-        res
-      end
-      groups.each do |key, vals|
-        arr[order[key]] = [key, vals]
-      end
-      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#-`.
@@ -430,7 +369,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, Integer, (String, nil)]]
+    # @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)
@@ -524,8 +463,7 @@ module Sass
     #
     # @param msg [String]
     def sass_warn(msg)
-      msg += "\n" unless ruby1?
-      Sass.logger.warn(msg)
+      Sass.logger.warn("#{msg}\n")
     end
 
     ## Cross Rails Version Compatibility
@@ -578,24 +516,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 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.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -648,7 +568,7 @@ module Sass
 
     # Returns an array of ints representing the JRuby version number.
     #
-    # @return [Array<Integer>]
+    # @return [Array<Fixnum>]
     def jruby_version
       @jruby_version ||= ::JRUBY_VERSION.split(".").map {|s| s.to_i}
     end
@@ -739,7 +659,7 @@ module Sass
     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)
+      path = URI::DEFAULT_PARSER.escape(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{\\\\[^\\]+\\[^\\/]+}
@@ -774,102 +694,11 @@ module Sass
       val || []
     end
 
-    ## Cross-Ruby-Version Compatibility
-
-    # Whether or not this is running under a Ruby version under 2.0.
-    #
-    # @return [Boolean]
-    def ruby1?
-      return @ruby1 if defined?(@ruby1)
-      @ruby1 = RUBY_VERSION_COMPONENTS[0] <= 1
-    end
-
-    # Whether or not this is running under Ruby 1.8 or lower.
-    #
-    # Note that IronRuby counts as Ruby 1.8,
-    # because it doesn't support the Ruby 1.9 encoding API.
-    #
-    # @return [Boolean]
-    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)
-    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 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)
-      @jruby1_6 = 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'
-    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
-      end
-
-      return Hash[pairs_or_hash] unless ruby1_8?
-      (pairs_or_hash.is_a?(NormalizedMap) ? NormalizedMap : OrderedHash)[*pairs_or_hash.flatten(1)]
-    end
-
-    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
+    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')
 
     # Like {\#check\_encoding}, but also checks for a `@charset` declaration
     # at the beginning of the file and uses that encoding if it exists.
@@ -878,7 +707,7 @@ module Sass
     #
     # @param str [String] The string of which to check the encoding
     # @return [(String, Encoding)] The original string encoded as UTF-8,
-    #   and the source encoding of the string (or `nil` under Ruby 1.8)
+    #   and the source encoding of the string
     # @raise [Encoding::UndefinedConversionError] if the source encoding
     #   cannot be converted to UTF-8
     # @raise [ArgumentError] if the document uses an unknown encoding with `@charset`
@@ -886,15 +715,6 @@ module Sass
     #   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
@@ -910,14 +730,9 @@ module Sass
         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(charset)
+        if encoding.name == 'UTF-16' || encoding.name == 'UTF-16BE'
           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 = binary.force_encoding(encoding)
       elsif str.encoding.name == "ASCII-8BIT"
@@ -937,50 +752,6 @@ module Sass
       end
     end
 
-    # Checks to see if a class has a given method.
-    # For example:
-    #
-    #     Sass::Util.has?(:public_instance_method, String, :gsub) #=> true
-    #
-    # Method collections like `Class#instance_methods`
-    # return strings in Ruby 1.8 and symbols in Ruby 1.9 and on,
-    # so this handles checking for them in a compatible way.
-    #
-    # @param attr [#to_s] The (singular) name of the method-collection method
-    #   (e.g. `:instance_methods`, `:private_methods`)
-    # @param klass [Module] The class to check the methods of which to check
-    # @param method [String, Symbol] The name of the method do check for
-    # @return [Boolean] Whether or not the given collection has the given method
-    def has?(attr, klass, method)
-      klass.send("#{attr}s").include?(ruby1_8? ? method.to_s : method.to_sym)
-    end
-
-    # A version of `Enumerable#enum_with_index` that works in Ruby 1.8 and 1.9.
-    #
-    # @param enum [Enumerable] The enumerable to get the enumerator for
-    # @return [Enumerator] The with-index enumerator
-    def enum_with_index(enum)
-      ruby1_8? ? enum.enum_with_index : enum.each_with_index
-    end
-
-    # 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 [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)
-    end
-
-    # 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 [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)
-    end
-
     # Destructively removes all elements from an array that match a block, and
     # returns the removed elements.
     #
@@ -999,14 +770,6 @@ module Sass
       out
     end
 
-    # Returns the ASCII code of the given character.
-    #
-    # @param c [String] All characters but the first are ignored.
-    # @return [Integer] The ASCII code of `c`.
-    def ord(c)
-      ruby1_8? ? c[0] : c.ord
-    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.
@@ -1127,11 +890,11 @@ module Sass
 
     # Converts the argument into a valid JSON value.
     #
-    # @param v [Integer, String, Array, Boolean, nil]
+    # @param v [Fixnum, String, Array, Boolean, nil]
     # @return [String]
     def json_value_of(v)
       case v
-      when Integer
+      when Fixnum
         v.to_s
       when String
         "\"" + json_escape_string(v) + "\""
@@ -1156,7 +919,7 @@ module Sass
     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|
+      BASE64_DIGITS.each_with_index.map do |digit, i|
         map[digit] = i
       end
       map
@@ -1164,7 +927,7 @@ module Sass
 
     # Encodes `value` as VLQ (http://en.wikipedia.org/wiki/VLQ).
     #
-    # @param value [Integer]
+    # @param value [Fixnum]
     # @return [String] The encoded value
     def encode_vlq(value)
       if value < 0
@@ -1185,35 +948,6 @@ module Sass
       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.
@@ -1271,44 +1005,6 @@ 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 = "~> 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
 
     def find_encoding_error(str)
@@ -1372,4 +1068,3 @@ end
 
 require 'sass/util/multibyte_string_scanner'
 require 'sass/util/normalized_map'
-require 'sass/util/cross_platform_random'