haml_ejs 0.0.1

data/lib/haml/railtie.rb

@@ -0,0 +1,19 @@
+if Haml::Util.ap_geq_3? && !Haml::Util.ap_geq?("3.0.0.beta4")
+  raise <<ERROR
+Haml no longer supports Rails 3 versions before beta 4.
+  Please upgrade to Rails 3.0.0.beta4 or later.
+ERROR
+end
+
+# Rails 3.0.0.beta.2+
+if defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load)
+  require 'haml/template/options'
+  autoload(:Sass, 'sass/rails3_shim')
+  ActiveSupport.on_load(:before_initialize) do
+    # resolve autoload if it looks like they're using Sass without options
+    Sass if File.exist?(File.join(Rails.root, 'public/stylesheets/sass'))
+    ActiveSupport.on_load(:action_view) do
+      Haml.init_rails(binding)
+    end
+  end
+end

data/lib/haml/root.rb

@@ -0,0 +1,7 @@
+module Haml
+  # The root directory of the Haml source tree.
+  # This may be overridden by the package manager
+  # if the lib directory is separated from the main source tree.
+  # @api public
+  ROOT_DIR = File.expand_path(File.join(__FILE__, "../../.."))
+end

data/lib/haml/shared.rb

@@ -0,0 +1,78 @@
+require 'strscan'
+
+module Haml
+  # This module contains functionality that's shared between Haml and Sass.
+  module Shared
+    extend self
+
+    # 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
+
+    # 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
+    end
+
+    # 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
+
+      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
+    end
+  end
+end

data/lib/haml/template.rb

@@ -0,0 +1,99 @@
+require 'haml/template/options'
+require 'haml/engine'
+require 'haml/helpers/action_view_mods'
+require 'haml/helpers/action_view_extensions'
+
+if defined?(ActionPack::VERSION::STRING) &&
+    ActionPack::VERSION::STRING == "2.3.6"
+  raise "Haml does not support Rails 2.3.6. Please upgrade to 2.3.7 or later."
+end
+
+module Haml
+  # The class that keeps track of the global options for Haml within Rails.
+  module Template
+    # Enables integration with the Rails 2.2.5+ XSS protection,
+    # if it's available and enabled.
+    #
+    # @return [Boolean] Whether the XSS integration was enabled.
+    def try_enabling_xss_integration
+      return false unless (ActionView::Base.respond_to?(:xss_safe?) && ActionView::Base.xss_safe?) ||
+        # We check for ActiveSupport#on_load here because if we're loading Haml that way, it means:
+        # A) we're in Rails 3 so XSS support is always on, and
+        # B) we might be in Rails 3 beta 3 where the load order is broken and xss_safe? is undefined
+        (defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
+
+      Haml::Template.options[:escape_html] = true
+
+      Haml::Util.module_eval {def rails_xss_safe?; true; end}
+
+      require 'haml/helpers/xss_mods'
+      Haml::Helpers.send(:include, Haml::Helpers::XssMods)
+
+      Haml::Compiler.module_eval do
+        def precompiled_method_return_value_with_haml_xss
+          "::Haml::Util.html_safe(#{precompiled_method_return_value_without_haml_xss})"
+        end
+        alias_method :precompiled_method_return_value_without_haml_xss, :precompiled_method_return_value
+        alias_method :precompiled_method_return_value, :precompiled_method_return_value_with_haml_xss
+      end
+
+      true
+    end
+  end
+end
+
+unless Haml::Util.rails_env == "development"
+  Haml::Template.options[:ugly] ||= true
+end
+
+if Haml::Util.ap_geq_3?
+  Haml::Template.options[:format] ||= :html5
+end
+
+# Decide how we want to load Haml into Rails.
+# Patching was necessary for versions <= 2.0.1,
+# but we can make it a normal handler for higher versions.
+if defined?(ActionView::TemplateHandler) ||
+    (defined?(ActionView::Template) && defined?(ActionView::Template::Handler)) ||
+    # Rails >= 3.2.0 uses Handlers instead of Handler
+    (defined?(ActionView::Template) && defined?(ActionView::Template::Handlers))
+  require 'haml/template/plugin'
+else
+  require 'haml/template/patch'
+end
+
+# Enable XSS integration. Use Rails' after_initialize method
+# so that integration will be checked after the rails_xss plugin is loaded
+# (for Rails 2.3.* where it's not enabled by default).
+#
+# If we're running under Rails 3, though, we don't want to use after_intialize,
+# since Haml loading has already been deferred via ActiveSupport.on_load.
+if defined?(Rails.configuration.after_initialize) &&
+    !(defined?(ActiveSupport) && Haml::Util.has?(:public_method, ActiveSupport, :on_load))
+  Rails.configuration.after_initialize {Haml::Template.try_enabling_xss_integration}
+else
+  Haml::Template.try_enabling_xss_integration
+end
+
+if Haml::Util.rails_root
+  # Update init.rb to the current version
+  # if it's out of date.
+  #
+  # We can probably remove this as of v1.9,
+  # because the new init file is sufficiently flexible
+  # to not need updating.
+  rails_init_file = File.join(Haml::Util.rails_root, 'vendor', 'plugins', 'haml', 'init.rb')
+  haml_init_file = Haml::Util.scope('init.rb')
+  begin
+    if File.exists?(rails_init_file)
+      require 'fileutils'
+      FileUtils.cp(haml_init_file, rails_init_file) unless FileUtils.cmp(rails_init_file, haml_init_file)
+    end
+  rescue SystemCallError
+    Haml::Util.haml_warn <<END
+HAML WARNING:
+#{rails_init_file} is out of date and couldn't be automatically updated.
+Please run `haml --rails #{File.expand_path(Haml::Util.rails_root)}' to update it.
+END
+  end
+end

data/lib/haml/template/options.rb

@@ -0,0 +1,16 @@
+# We keep options in its own self-contained file
+# so that we can load it independently in Rails 3,
+# where the full template stuff is lazy-loaded.
+
+module Haml
+  module Template
+    extend self
+
+    @options = {}
+    # The options hash for Haml when used within Rails.
+    # See {file:HAML_REFERENCE.md#haml_options the Haml options documentation}.
+    #
+    # @return [{Symbol => Object}]
+    attr_accessor :options
+  end
+end

data/lib/haml/template/patch.rb

@@ -0,0 +1,58 @@
+# This file makes Haml work with Rails
+# by monkeypatching the core template-compilation methods.
+# This is necessary for versions <= 2.0.1 because the template handler API
+# wasn't sufficiently powerful to deal with caching and so forth.
+
+# This module refers to the ActionView module that's part of Ruby on Rails.
+# Haml can be used as an alternate templating engine for it,
+# and includes several modifications to make it more Haml-friendly.
+# The documentation can be found
+# here[http://rubyonrails.org/api/classes/ActionView/Base.html].
+module ActionView
+  class Base
+    def delegate_template_exists_with_haml(template_path)
+      template_exists?(template_path, :haml) && [:haml]
+    end
+    alias_method :delegate_template_exists_without_haml, :delegate_template_exists?
+    alias_method :delegate_template_exists?, :delegate_template_exists_with_haml
+
+    def compile_template_with_haml(extension, template, file_name, local_assigns)
+      return compile_haml(template, file_name, local_assigns) if extension.to_s == "haml"
+      compile_template_without_haml(extension, template, file_name, local_assigns)
+    end
+    alias_method :compile_template_without_haml, :compile_template
+    alias_method :compile_template, :compile_template_with_haml
+
+    def compile_haml(template, file_name, local_assigns)
+      render_symbol = assign_method_name(:haml, template, file_name)
+      locals = local_assigns.keys
+
+      @@template_args[render_symbol] ||= {}
+      locals_keys = @@template_args[render_symbol].keys | locals
+      @@template_args[render_symbol] = Haml::Util.to_hash(locals_keys.map {|k| [k, true]})
+
+      options = Haml::Template.options.dup
+      options[:filename] = file_name || 'compiled-template'
+
+      begin
+        Haml::Engine.new(template, options).def_method(CompiledTemplates, render_symbol, *locals_keys)
+      rescue Exception => e
+        if logger
+          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+        end
+
+        base_path = if defined?(extract_base_path_from)
+                      # Rails 2.0.x
+                      extract_base_path_from(file_name) || view_paths.first
+                    else
+                      # Rails <=1.2.6
+                      @base_path
+                    end
+        raise ActionView::TemplateError.new(base_path, file_name || template, @assigns, template, e)
+      end
+
+      @@compile_time[render_symbol] = Time.now
+    end
+  end
+end

data/lib/haml/template/plugin.rb

@@ -0,0 +1,123 @@
+# This file makes Haml work with Rails
+# using the > 2.0.1 template handler API.
+
+module Haml
+  # In Rails 3.1+, template handlers don't inherit from anything. In <= 3.0, they do.
+  # To avoid messy logic figuring this out, we just inherit from whatever the ERB handler does.
+  class Plugin < Haml::Util.av_template_class(:Handlers)::ERB.superclass
+    if ((defined?(ActionView::TemplateHandlers) &&
+          defined?(ActionView::TemplateHandlers::Compilable)) ||
+        (defined?(ActionView::Template) &&
+          defined?(ActionView::Template::Handlers) &&
+          defined?(ActionView::Template::Handlers::Compilable))) &&
+        # In Rails 3.1+, we don't need to include Compilable.
+        Haml::Util.av_template_class(:Handlers)::ERB.include?(
+          Haml::Util.av_template_class(:Handlers)::Compilable)
+      include Haml::Util.av_template_class(:Handlers)::Compilable
+    end
+
+    def handles_encoding?; true; end
+
+    def compile(template)
+      options = Haml::Template.options.dup
+
+      # template is a template object in Rails >=2.1.0,
+      # a source string previously
+      if template.respond_to? :source
+        # Template has a generic identifier in Rails >=3.0.0
+        options[:filename] = template.respond_to?(:identifier) ? template.identifier : template.filename
+        source = template.source
+      else
+        source = template
+      end
+
+      Haml::Engine.new(source, options).send(:precompiled_with_ambles, [])
+    end
+
+    # In Rails 3.1+, #call takes the place of #compile
+    def self.call(template)
+      new.compile(template)
+    end
+
+    def cache_fragment(block, name = {}, options = nil)
+      @view.fragment_for(block, name, options) do
+        eval("_hamlout.buffer", block.binding)
+      end
+    end
+  end
+
+  # Rails 3.0 prints a deprecation warning when block helpers
+  # return strings that go unused.
+  # We want to print the same deprecation warning,
+  # so we have to compile in a method call to check for it.
+  #
+  # I don't like having this in the compilation pipeline,
+  # and I'd like to get rid of it once Rails 3.1 is well-established.
+  if defined?(ActionView::OutputBuffer) &&
+      Haml::Util.has?(:instance_method, ActionView::OutputBuffer, :append_if_string=)
+    module Compiler
+      def compile_silent_script_with_haml_block_deprecation(&block)
+        unless block && !@node.value[:keyword] &&
+            @node.value[:text] =~ ActionView::Template::Handlers::Erubis::BLOCK_EXPR
+          return compile_silent_script_without_haml_block_deprecation(&block)
+        end
+
+        @node.value[:text] = "_hamlout.append_if_string= #{@node.value[:text]}"
+        compile_silent_script_without_haml_block_deprecation(&block)
+      end
+      alias_method :compile_silent_script_without_haml_block_deprecation, :compile_silent_script
+      alias_method :compile_silent_script, :compile_silent_script_with_haml_block_deprecation
+    end
+
+    class Buffer
+      def append_if_string=(value)
+        if value.is_a?(String) && !value.is_a?(ActionView::NonConcattingString)
+          ActiveSupport::Deprecation.warn("- style block helpers are deprecated. Please use =", caller)
+          buffer << value
+        end
+      end
+    end
+  end
+end
+
+if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
+  ActionView::Template
+else
+  ActionView::Base
+end.register_template_handler(:haml, Haml::Plugin)
+
+# In Rails 2.0.2, ActionView::TemplateError took arguments
+# that we can't fill in from the Haml::Plugin context.
+# Thus, we've got to monkeypatch ActionView::Base to catch the error.
+if defined?(ActionView::TemplateError) &&
+    ActionView::TemplateError.instance_method(:initialize).arity == 5
+  class ActionView::Base
+    def compile_template(handler, template, file_name, local_assigns)
+      render_symbol = assign_method_name(handler, template, file_name)
+
+      # Move begin up two lines so it captures compilation exceptions.
+      begin
+        render_source = create_template_source(handler, template, render_symbol, local_assigns.keys)
+        line_offset = @@template_args[render_symbol].size + handler.line_offset
+      
+        file_name = 'compiled-template' if file_name.blank?
+        CompiledTemplates.module_eval(render_source, file_name, -line_offset)
+      rescue Exception => e # errors from template code
+        if logger
+          logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+          logger.debug "Function body: #{render_source}"
+          logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+        end
+
+        # There's no way to tell Haml about the filename,
+        # so we've got to insert it ourselves.
+        e.backtrace[0].gsub!('(haml)', file_name) if e.is_a?(Haml::Error)
+        
+        raise ActionView::TemplateError.new(extract_base_path_from(file_name) || view_paths.first, file_name || template, @assigns, template, e)
+      end
+      
+      @@compile_time[render_symbol] = Time.now
+      # logger.debug "Compiled template #{file_name || template}\n ==> #{render_symbol}" if logger
+    end
+  end
+end

data/lib/haml/util.rb

@@ -0,0 +1,842 @@
+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"
+
+    # 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))
+    end
+
+    # Computes the powerset of the given array.
+    # This is the set of all subsets of the array.
+    #
+    # @example
+    #   powerset([1, 2, 3]) #=>
+    #     Set[Set[], Set[1], Set[2], Set[3], Set[1, 2], Set[2, 3], Set[1, 3], Set[1, 2, 3]]
+    # @param arr [Enumerable]
+    # @return [Set<Set>] The subsets of `arr`
+    def powerset(arr)
+      arr.inject([Set.new].to_set) do |powerset, el|
+        new_powerset = Set.new
+        powerset.each do |subset|
+          new_powerset << subset
+          new_powerset << subset + [el]
+        end
+        new_powerset
+      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
+    # @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 = caller[1])
+      info = entry.scan(/^(.*?):(-?.*?)(?::.*`(.+)')?$/).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]
+      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)
+      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
+    def silence_warnings
+      the_real_stderr, $stderr = $stderr, StringIO.new
+      yield
+    ensure
+      $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`,
+    # while afterwards they were of the form `ActionView;:Template::Foo`.
+    #
+    # @param name [#to_s] The name of the class to get.
+    #   For example, `:Error` will return `ActionView::TemplateError`
+    #   or `ActionView::Template::Error`.
+    def av_template_class(name)
+      return ActionView.const_get("Template#{name}") if ActionView.const_defined?("Template#{name}")
+      return ActionView::Template.const_get(name.to_s)
+    end
+
+    ## Rails XSS Safety
+
+    # Whether or not ActionView's XSS protection is available and enabled,
+    # as is the default for Rails 3.0+, and optional for version 2.3.5+.
+    # Overridden in haml/template.rb if this is the case.
+    #
+    # @return [Boolean]
+    def rails_xss_safe?
+      false
+    end
+
+    # Returns the given text, marked as being HTML-safe.
+    # With older versions of the Rails XSS-safety mechanism,
+    # this destructively modifies the HTML-safety of `text`.
+    #
+    # @param text [String, nil]
+    # @return [String, nil] `text`, marked as HTML-safe
+    def html_safe(text)
+      return unless text
+      return text.html_safe if defined?(ActiveSupport::SafeBuffer)
+      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
+    # 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 #{e.error_char.dump}
+MSG
+        end
+      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")
+      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
+            # /\A@charset "(.*?)"/
+            Regexp.new(/\A#{_enc('@charset "', e)}(.*?)#{_enc('"', e)}/)
+          end
+      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.
+    #
+    # @param obj {Object}
+    # @return {String}
+    def inspect_obj(obj)
+      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]} + '"'
+    end
+
+    ## Static Method Stuff
+
+    # The context in which the ERB for \{#def\_static\_method} will be run.
+    class StaticConditionalContext
+      # @param set [#include?] The set of variables that are defined for this context.
+      def initialize(set)
+        @set = set
+      end
+
+      # Checks whether or not a variable is defined for this context.
+      #
+      # @param name [Symbol] The name of the variable
+      # @return [Boolean]
+      def method_missing(name, *args, &block)
+        super unless args.empty? && block.nil?
+        @set.include?(name)
+      end
+    end
+
+    # This is used for methods in {Haml::Buffer} that need to be very fast,
+    # and take a lot of boolean parameters
+    # that are known at compile-time.
+    # Instead of passing the parameters in normally,
+    # a separate method is defined for every possible combination of those parameters;
+    # these are then called using \{#static\_method\_name}.
+    #
+    # To define a static method, an ERB template for the method is provided.
+    # All conditionals based on the static parameters
+    # are done as embedded Ruby within this template.
+    # For example:
+    #
+    #     def_static_method(Foo, :my_static_method, [:foo, :bar], :baz, :bang, <<RUBY)
+    #       <% if baz && bang %>
+    #         return foo + bar
+    #       <% elsif baz || bang %>
+    #         return foo - bar
+    #       <% else %>
+    #         return 17
+    #       <% end %>
+    #     RUBY
+    #
+    # \{#static\_method\_name} can be used to call static methods.
+    #
+    # @overload def_static_method(klass, name, args, *vars, erb)
+    # @param klass [Module] The class on which to define the static method
+    # @param name [#to_s] The (base) name of the static method
+    # @param args [Array<Symbol>] The names of the arguments to the defined methods
+    #   (**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
+      powerset(vars).each do |set|
+        context = StaticConditionalContext.new(set).instance_eval {binding}
+        klass.class_eval(<<METHOD, info[0], info[1])
+def #{static_method_name(name, *vars.map {|v| set.include?(v)})}(#{args.join(', ')})
+  #{ERB.new(erb).result(context)}
+end
+METHOD
+      end
+    end
+
+    # Computes the name for a method defined via \{#def\_static\_method}.
+    #
+    # @param name [String] The base name of the static method
+    # @param vars [Array<Boolean>] The static variable assignment
+    # @return [String] The real name of the static method
+    def static_method_name(name, *vars)
+      "#{name}_#{vars.map {|v| !!v}.join('_')}"
+    end
+
+    private
+
+    # 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
+      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
+      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)
+    end
+
+    # Parses a magic comment at the beginning of a Haml file.
+    # The parsing rules are basically the same as Ruby's.
+    #
+    # @return [(Boolean, String or nil)]
+    #   Whether the document begins with a UTF-8 BOM,
+    #   and the declared encoding of the document (or nil if none is declared)
+    def parse_haml_magic_comment(str)
+      scanner = StringScanner.new(str.dup.force_encoding("BINARY"))
+      bom = scanner.scan(/\xEF\xBB\xBF/n)
+      return bom unless scanner.scan(/-\s*#\s*/n)
+      if coding = try_parse_haml_emacs_magic_comment(scanner)
+        return bom, coding
+      end
+
+      return bom unless scanner.scan(/.*?coding[=:]\s*([\w-]+)/in)
+      return bom, scanner[1]
+    end
+
+    def try_parse_haml_emacs_magic_comment(scanner)
+      pos = scanner.pos
+      return unless scanner.scan(/.*?-\*-\s*/n)
+      # From Ruby's parse.y
+      return unless scanner.scan(/([^\s'":;]+)\s*:\s*("(?:\\.|[^"])*"|[^"\s;]+?)[\s;]*-\*-/n)
+      name, val = scanner[1], scanner[2]
+      return unless name =~ /(en)?coding/in
+      val = $1 if val =~ /^"(.*)"$/n
+      return val
+    ensure
+      scanner.pos = pos
+    end
+  end
+end