haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/lib/haml/util.rb

@@ -1,94 +1,19 @@
 require 'erb'
 require 'set'
-require 'enumerator'
 require 'stringio'
 require 'strscan'
-require 'rbconfig'
-
-require 'haml/root'
 
 module Haml
   # A module containing various useful functions.
   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}
-
-    # The Ruby engine we're running under. Defaults to `"ruby"`
-    # if the top-level constant is undefined.
-    # @api public
-    RUBY_ENGINE = defined?(::RUBY_ENGINE) ? ::RUBY_ENGINE : "ruby"
-
-    @@version_comparison_cache = {}
-
     # Returns the path of a file relative to the Haml root directory.
     #
     # @param file [String] The filename relative to the Haml root
     # @return [String] The filename relative to the the working directory
     def scope(file)
-      File.join(Haml::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)
-      Hash[arr.compact]
-    end
-
-    # Maps the keys in a hash according to a block.
-    #
-    # @example
-    #   map_keys({:foo => "bar", :baz => "bang"}) {|k| k.to_s}
-    #     #=> {"foo" => "bar", "baz" => "bang"}
-    # @param hash [Hash] The hash to map
-    # @yield [key] A block in which the keys are transformed
-    # @yieldparam key [Object] The key that should be mapped
-    # @yieldreturn [Object] The new value for the key
-    # @return [Hash] The mapped hash
-    # @see #map_vals
-    # @see #map_hash
-    def map_keys(hash)
-      to_hash(hash.map {|k, v| [yield(k), v]})
-    end
-
-    # Maps the values in a hash according to a block.
-    #
-    # @example
-    #   map_values({:foo => "bar", :baz => "bang"}) {|v| v.to_sym}
-    #     #=> {:foo => :bar, :baz => :bang}
-    # @param hash [Hash] The hash to map
-    # @yield [value] A block in which the values are transformed
-    # @yieldparam value [Object] The value that should be mapped
-    # @yieldreturn [Object] The new value for the value
-    # @return [Hash] The mapped hash
-    # @see #map_keys
-    # @see #map_hash
-    def map_vals(hash)
-      to_hash(hash.map {|k, v| [k, yield(v)]})
-    end
-
-    # Maps the key-value pairs of a hash according to a block.
-    #
-    # @example
-    #   map_hash({:foo => "bar", :baz => "bang"}) {|k, v| [k.to_s, v.to_sym]}
-    #     #=> {"foo" => :bar, "baz" => :bang}
-    # @param hash [Hash] The hash to map
-    # @yield [key, value] A block in which the key-value pairs are transformed
-    # @yieldparam [key] The hash key
-    # @yieldparam [value] The hash value
-    # @yieldreturn [(Object, Object)] The new value for the `[key, value]` pair
-    # @return [Hash] The mapped hash
-    # @see #map_keys
-    # @see #map_vals
-    def map_hash(hash, &block)
-      to_hash(hash.map(&block))
+      File.expand_path("../../../#{file}", __FILE__)
     end
 
     # Computes the powerset of the given array.
@@ -110,116 +35,6 @@ module Haml
       end
     end
 
-    # Restricts a number to falling within a given range.
-    # Returns the number if it falls within the range,
-    # or the closest value in the range if it doesn't.
-    #
-    # @param value [Numeric]
-    # @param range [Range<Numeric>]
-    # @return [Numeric]
-    def restrict(value, range)
-      [[value, range.first].max, range.last].min
-    end
-
-    # Concatenates all strings that are adjacent in an array,
-    # while leaving other elements as they are.
-    #
-    # @example
-    #   merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
-    #     #=> [1, "foobar", 2, "baz"]
-    # @param arr [Array]
-    # @return [Array] The enumerable with strings merged
-    def merge_adjacent_strings(arr)
-      # Optimize for the common case of one element
-      return arr if arr.size < 2
-      arr.inject([]) do |a, e|
-        if e.is_a?(String)
-          if a.last.is_a?(String)
-            a.last << e
-          else
-            a << e.dup
-          end
-        else
-          a << e
-        end
-        a
-      end
-    end
-
-    # Intersperses a value in an enumerable, as would be done with `Array#join`
-    # but without concatenating the array together afterwards.
-    #
-    # @param enum [Enumerable]
-    # @param val
-    # @return [Array]
-    def intersperse(enum, val)
-      enum.inject([]) {|a, e| a << e << val}[0...-1]
-    end
-
-    # Substitutes a sub-array of one array with another sub-array.
-    #
-    # @param ary [Array] The array in which to make the substitution
-    # @param from [Array] The sequence of elements to replace with `to`
-    # @param to [Array] The sequence of elements to replace `from` with
-    def substitute(ary, from, to)
-      res = ary.dup
-      i = 0
-      while i < res.size
-        if res[i...i+from.size] == from
-          res[i...i+from.size] = to
-        end
-        i += 1
-      end
-      res
-    end
-
-    # Destructively strips whitespace from the beginning and end
-    # of the first and last elements, respectively,
-    # in the array (if those elements are strings).
-    #
-    # @param arr [Array]
-    # @return [Array] `arr`
-    def strip_string_array(arr)
-      arr.first.lstrip! if arr.first.is_a?(String)
-      arr.last.rstrip! if arr.last.is_a?(String)
-      arr
-    end
-
-    # Return an array of all possible paths through the given arrays.
-    #
-    # @param arrs [Array<Array>]
-    # @return [Array<Arrays>]
-    #
-    # @example
-    #   paths([[1, 2], [3, 4], [5]]) #=>
-    #     # [[1, 3, 5],
-    #     #  [2, 3, 5],
-    #     #  [1, 4, 5],
-    #     #  [2, 4, 5]]
-    def paths(arrs)
-      arrs.inject([[]]) do |paths, arr|
-        flatten(arr.map {|e| paths.map {|path| path + [e]}}, 1)
-      end
-    end
-
-    # Computes a single longest common subsequence for `x` and `y`.
-    # If there are more than one longest common subsequences,
-    # the one returned is that which starts first in `x`.
-    #
-    # @param x [Array]
-    # @param y [Array]
-    # @yield [a, b] An optional block to use in place of a check for equality
-    #   between elements of `x` and `y`.
-    # @yieldreturn [Object, nil] If the two values register as equal,
-    #   this will return the value to use in the LCS array.
-    # @return [Array] The LCS
-    def lcs(x, y, &block)
-      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)
-    end
-
     # Returns information about the caller of the previous method.
     #
     # @param entry [String] An entry in the `#caller` list, or a similarly formatted string
@@ -233,83 +48,6 @@ module Haml
       info
     end
 
-    # Returns whether one version string represents a more recent version than another.
-    #
-    # @param v1 [String] A version string.
-    # @param v2 [String] Another version string.
-    # @return [Boolean]
-    def version_gt(v1, v2)
-      # Construct an array to make sure the shorter version is padded with nil
-      Array.new([v1.length, v2.length].max).zip(v1.split("."), v2.split(".")) do |_, p1, p2|
-        p1 ||= "0"
-        p2 ||= "0"
-        release1 = p1 =~ /^[0-9]+$/
-        release2 = p2 =~ /^[0-9]+$/
-        if release1 && release2
-          # Integer comparison if both are full releases
-          p1, p2 = p1.to_i, p2.to_i
-          next if p1 == p2
-          return p1 > p2
-        elsif !release1 && !release2
-          # String comparison if both are prereleases
-          next if p1 == p2
-          return p1 > p2
-        else
-          # If only one is a release, that one is newer
-          return release1
-        end
-      end
-    end
-
-    # Returns whether one version string represents the same or a more
-    # recent version than another.
-    #
-    # @param v1 [String] A version string.
-    # @param v2 [String] Another version string.
-    # @return [Boolean]
-    def version_geq(v1, v2)
-      k = "#{v1}#{v2}"
-      return @@version_comparison_cache.fetch(k) if @@version_comparison_cache.key?(k)
-      @@version_comparison_cache[k] = version_gt(v1, v2) || !version_gt(v2, v1)
-    end
-
-    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
-    # before dumping it, `#_after_dump` afterwards.
-    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
-    #
-    # If any of these methods are undefined, they are not called.
-    #
-    # @param obj [Object] The object to dump.
-    # @return [String] The dumped data.
-    def dump(obj)
-      obj._before_dump if obj.respond_to?(:_before_dump)
-      return Marshal.dump(obj) unless obj.respond_to?(:_around_dump)
-      res = nil
-      obj._around_dump {res = Marshal.dump(obj)}
-      res
-    ensure
-      obj._after_dump if obj.respond_to?(:_after_dump)
-    end
-
-    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
-    # after loading it, if it's defined.
-    #
-    # @param data [String] The data to load.
-    # @return [Object] The loaded object.
-    def load(data)
-      obj = Marshal.load(data)
-      obj._after_load if obj.respond_to?(:_after_load)
-      obj
-    end
-
-    # Throws a NotImplementedError for an abstract method.
-    #
-    # @param obj [Object] `self`
-    # @raise [NotImplementedError]
-    def abstract(obj)
-      raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
-    end
-
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR
@@ -320,105 +58,6 @@ module Haml
       $stderr = the_real_stderr
     end
 
-    @@silence_warnings = false
-    # Silences all Haml warnings within a block.
-    #
-    # @yield A block in which no Haml warnings will be printed
-    def silence_haml_warnings
-      old_silence_warnings = @@silence_warnings
-      @@silence_warnings = true
-      yield
-    ensure
-      @@silence_warnings = old_silence_warnings
-    end
-
-    # The same as `Kernel#warn`, but is silenced by \{#silence\_haml\_warnings}.
-    #
-    # @param msg [String]
-    def haml_warn(msg)
-      return if @@silence_warnings
-      warn(msg)
-    end
-
-    # Try loading Sass. If the `sass` gem isn't installed,
-    # print a warning and load from the vendored gem.
-    #
-    # @return [Boolean] True if Sass was successfully loaded from the `sass` gem,
-    #   false otherwise.
-    def try_sass
-      return true if defined?(::SASS_BEGUN_TO_LOAD)
-      begin
-        require 'sass/version'
-        loaded = Sass.respond_to?(:version) && Sass.version[:major] &&
-          Sass.version[:minor] && ((Sass.version[:major] > 3 && Sass.version[:minor] > 1) ||
-          ((Sass.version[:major] == 3 && Sass.version[:minor] == 1) &&
-            (Sass.version[:prerelease] || Sass.version[:name] != "Bleeding Edge")))
-      rescue LoadError => e
-        loaded = false
-      end
-
-      unless loaded
-        haml_warn(<<WARNING)
-Sass is in the process of being separated from Haml,
-and will no longer be bundled at all in Haml 3.2.0.
-Please install the 'sass' gem if you want to use Sass.
-WARNING
-        $".delete('sass/version')
-        $LOAD_PATH.unshift(scope("vendor/sass/lib"))
-      end
-      loaded
-    end
-
-    ## Cross Rails Version Compatibility
-
-    # Returns the root of the Rails application,
-    # if this is running in a Rails context.
-    # Returns `nil` if no such root is defined.
-    #
-    # @return [String, nil]
-    def rails_root
-      if defined?(::Rails.root)
-        return ::Rails.root.to_s if ::Rails.root
-        raise "ERROR: Rails.root is nil!"
-      end
-      return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
-      return nil
-    end
-
-    # Returns the environment of the Rails application,
-    # if this is running in a Rails context.
-    # Returns `nil` if no such environment is defined.
-    #
-    # @return [String, nil]
-    def rails_env
-      return ::Rails.env.to_s if defined?(::Rails.env)
-      return RAILS_ENV.to_s if defined?(RAILS_ENV)
-      return nil
-    end
-
-    # Returns whether this environment is using ActionPack
-    # version 3.0.0 or greater.
-    #
-    # @return [Boolean]
-    def ap_geq_3?
-      ap_geq?("3.0.0.beta1")
-    end
-
-    # Returns whether this environment is using ActionPack
-    # of a version greater than or equal to that specified.
-    #
-    # @param version [String] The string version number to check against.
-    #   Should be greater than or equal to Rails 3,
-    #   because otherwise ActionPack::VERSION isn't autoloaded
-    # @return [Boolean]
-    def ap_geq?(version)
-      # The ActionPack module is always loaded automatically in Rails >= 3
-      return false unless defined?(ActionPack) && defined?(ActionPack::VERSION) &&
-        defined?(ActionPack::VERSION::STRING)
-
-      version_geq(ActionPack::VERSION::STRING, version)
-    end
-
     # Returns an ActionView::Template* class.
     # In pre-3.0 versions of Rails, most of these classes
     # were of the form `ActionView::TemplateFoo`,
@@ -455,65 +94,6 @@ WARNING
       text.html_safe!
     end
 
-    # Assert that a given object (usually a String) is HTML safe
-    # according to Rails' XSS handling, if it's loaded.
-    #
-    # @param text [Object]
-    def assert_html_safe!(text)
-      return unless rails_xss_safe? && text && !text.to_s.html_safe?
-      raise Haml::Error.new("Expected #{text.inspect} to be HTML-safe.")
-    end
-
-    # The class for the Rails SafeBuffer XSS protection class.
-    # This varies depending on Rails version.
-    #
-    # @return [Class]
-    def rails_safe_buffer_class
-      # It's important that we check ActiveSupport first,
-      # because in Rails 2.3.6 ActionView::SafeBuffer exists
-      # but is a deprecated proxy object.
-      return ActiveSupport::SafeBuffer if defined?(ActiveSupport::SafeBuffer)
-      return ActionView::SafeBuffer
-    end
-
-    ## Cross-OS Compatibility
-
-    # Whether or not this is running on Windows.
-    #
-    # @return [Boolean]
-    def windows?
-      RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
-    end
-
-    # Whether or not this is running on IronRuby.
-    #
-    # @return [Boolean]
-    def ironruby?
-      RUBY_ENGINE == "ironruby"
-    end
-
-    ## Cross-Ruby-Version Compatibility
-
-    # 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.
-      ironruby? || (Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9)
-    end
-
-    # Whether or not this is running under Ruby 1.8.6 or lower.
-    # Note that lower versions are not officially supported.
-    #
-    # @return [Boolean]
-    def ruby1_8_6?
-      ruby1_8? && Haml::Util::RUBY_VERSION[2] < 7
-    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
@@ -524,175 +104,74 @@ WARNING
     #   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
+    if RUBY_VERSION < "1.9"
+      def check_encoding(str)
+        str.gsub(/\A\xEF\xBB\xBF/, '') # Get rid of the UTF-8 BOM
       end
+    else
+
+      def check_encoding(str)
+        if 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
+        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 #{e.error_char.dump}
 MSG
+          end
         end
+        return str
       end
-      return str
     end
 
-    # Like {\#check\_encoding}, but also checks for a Ruby-style `-# coding:` comment
-    # at the beginning of the template and uses that encoding if it exists.
-    #
-    # The Haml encoding rules are simple.
-    # If a `-# coding:` comment exists,
-    # we assume that that's the original encoding of the document.
-    # Otherwise, we use whatever encoding Ruby has.
-    #
-    # Haml uses the same rules for parsing coding comments as Ruby.
-    # This means that it can understand Emacs-style comments
-    # (e.g. `-*- encoding: "utf-8" -*-`),
-    # and also that it cannot understand non-ASCII-compatible encodings
-    # such as `UTF-16` and `UTF-32`.
-    #
-    # @param str [String] The Haml template 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] The original string encoded properly
-    # @raise [ArgumentError] if the document declares an unknown encoding
-    def check_haml_encoding(str, &block)
-      return check_encoding(str, &block) if ruby1_8?
-      str = str.dup if str.frozen?
-
-      bom, encoding = parse_haml_magic_comment(str)
-      if encoding; str.force_encoding(encoding)
-      elsif bom; str.force_encoding("UTF-8")
-      end
-
-      return check_encoding(str, &block)
-    end
-
-    unless ruby1_8?
-      # @private
-      def _enc(string, encoding)
-        string.encode(encoding).force_encoding("BINARY")
+    if RUBY_VERSION < "1.9"
+      # Like {\#check\_encoding}, but also checks for a Ruby-style `-# coding:` comment
+      # at the beginning of the template and uses that encoding if it exists.
+      #
+      # The Haml encoding rules are simple.
+      # If a `-# coding:` comment exists,
+      # we assume that that's the original encoding of the document.
+      # Otherwise, we use whatever encoding Ruby has.
+      #
+      # Haml uses the same rules for parsing coding comments as Ruby.
+      # This means that it can understand Emacs-style comments
+      # (e.g. `-*- encoding: "utf-8" -*-`),
+      # and also that it cannot understand non-ASCII-compatible encodings
+      # such as `UTF-16` and `UTF-32`.
+      #
+      # @param str [String] The Haml template 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] The original string encoded properly
+      # @raise [ArgumentError] if the document declares an unknown encoding
+      def check_haml_encoding(str, &block)
+        check_encoding(str, &block)
       end
+    else
+      def check_haml_encoding(str, &block)
+        str = str.dup if str.frozen?
 
-      # 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]
+        bom, encoding = parse_haml_magic_comment(str)
+        if encoding; str.force_encoding(encoding)
+        elsif bom; str.force_encoding("UTF-8")
+        end
 
-      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
-            # /\A@charset "(.*?)"/
-            Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
-          end
+        return check_encoding(str, &block)
       end
     end
 
-    # Checks to see if a class has a given method.
-    # For example:
-    #
-    #     Haml::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 [Fixnum] 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 [Fixnum] 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
-
-    # 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`.
-    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
-
-    # 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]`
     # before being evaluated.
@@ -700,7 +179,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 (::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]} + '"'
@@ -756,7 +235,6 @@ MSG
     #   (**not** to the ERB template)
     # @param vars [Array<Symbol>] The names of the static boolean variables
     #   to be made available to the ERB template
-    # @param erb [String] The template for the method code
     def def_static_method(klass, name, args, *vars)
       erb = vars.pop
       info = caller_info
@@ -779,39 +257,78 @@ METHOD
       "#{name}_#{vars.map {|v| !!v}.join('_')}"
     end
 
-    private
+    # Scans through a string looking for the interoplation-opening `#{`
+    # and, when it's found, yields the scanner to the calling code
+    # so it can handle it properly.
+    #
+    # The scanner will have any backslashes immediately in front of the `#{`
+    # as the second capture group (`scan[2]`),
+    # and the text prior to that as the first (`scan[1]`).
+    #
+    # @yieldparam scan [StringScanner] The scanner scanning through the string
+    # @return [String] The text remaining in the scanner after all `#{`s have been processed
+    def handle_interpolation(str)
+      scan = StringScanner.new(str)
+      yield scan while scan.scan(/(.*?)(\\*)\#\{/)
+      scan.rest
+    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)
-      c = Array.new(x.size) {[]}
-      x.size.times {|i| c[i][0] = 0}
-      y.size.times {|j| c[0][j] = 0}
-      (1...x.size).each do |i|
-        (1...y.size).each do |j|
-          c[i][j] =
-            if yield x[i], y[j]
-              c[i-1][j-1] + 1
-            else
-              [c[i][j-1], c[i-1][j]].max
-            end
-        end
+    # Moves a scanner through a balanced pair of characters.
+    # For example:
+    #
+    #     Foo (Bar (Baz bang) bop) (Bang (bop bip))
+    #     ^                       ^
+    #     from                    to
+    #
+    # @param scanner [StringScanner] The string scanner to move
+    # @param start [Character] The character opening the balanced pair.
+    #   A `Fixnum` in 1.8, a `String` in 1.9
+    # @param finish [Character] The character closing the balanced pair.
+    #   A `Fixnum` in 1.8, a `String` in 1.9
+    # @param count [Fixnum] The number of opening characters matched
+    #   before calling this method
+    # @return [(String, String)] The string matched within the balanced pair
+    #   and the rest of the string.
+    #   `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
+    def balance(scanner, start, finish, count = 0)
+      str = ''
+      scanner = StringScanner.new(scanner) unless scanner.is_a? StringScanner
+      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+      while scanner.scan(regexp)
+        str << scanner.matched
+        count += 1 if scanner.matched[-1] == start
+        count -= 1 if scanner.matched[-1] == finish
+        return [str.strip, scanner.rest] if count == 0
       end
-      return c
     end
 
-    # 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)
-      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
+    # Formats a string for use in error messages about indentation.
+    #
+    # @param indentation [String] The string used for indentation
+    # @param was [Boolean] Whether or not to add `"was"` or `"were"`
+    #   (depending on how many characters were in `indentation`)
+    # @return [String] The name of the indentation (e.g. `"12 spaces"`, `"1 tab"`)
+    def human_indentation(indentation, was = false)
+      if !indentation.include?(?\t)
+        noun = 'space'
+      elsif !indentation.include?(?\s)
+        noun = 'tab'
+      else
+        return indentation.inspect + (was ? ' was' : '')
+      end
+
+      singular = indentation.length == 1
+      if was
+        was = singular ? ' was' : ' were'
+      else
+        was = ''
       end
 
-      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)
+      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
     end
 
+    private
+
     # Parses a magic comment at the beginning of a Haml file.
     # The parsing rules are basically the same as Ruby's.
     #