simple-templater 0.0.1.4 → 0.0.1.5

data/gems/gems/haml-2.2.16/lib/haml/shared.rb

@@ -1,78 +0,0 @@
-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/gems/gems/haml-2.2.16/lib/haml/template/patch.rb

@@ -1,58 +0,0 @@
-# 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/gems/gems/haml-2.2.16/lib/haml/template/plugin.rb

@@ -1,75 +0,0 @@
-# This file makes Haml work with Rails
-# using the > 2.0.1 template handler API.
-
-module Haml
-  class Plugin < Haml::Util.av_template_class(:Handler)
-    if defined?(ActionView::TemplateHandlers::Compilable) ||
-        defined?(ActionView::Template::Handlers::Compilable)
-      include Haml::Util.av_template_class(:Handlers)::Compilable
-    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
-
-    def cache_fragment(block, name = {}, options = nil)
-      @view.fragment_for(block, name, options) do
-        eval("_hamlout.buffer", block.binding)
-      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/gems/gems/haml-2.2.16/lib/haml/template.rb

@@ -1,85 +0,0 @@
-require 'haml/engine'
-
-module Haml
-  # The class that keeps track of the global options for Haml within Rails.
-  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
-
-    # 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?
-
-      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::Precompiler.module_eval do
-        def precompiled_method_return_value_with_haml_xss
-          "(#{precompiled_method_return_value_without_haml_xss}).html_safe!"
-        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
-
-if defined?(RAILS_ENV) && RAILS_ENV == "production"
-  Haml::Template.options[:ugly] = true
-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::Handler)
-  require 'haml/template/plugin'
-else
-  require 'haml/template/patch'
-end
-
-# Enable XSS integration. Use Rails' after_initialize method if possible
-# 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 defined?(Rails.configuration.after_initialize)
-  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
-    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/gems/gems/haml-2.2.16/lib/haml/util.rb

@@ -1,289 +0,0 @@
-require 'erb'
-require 'set'
-require 'enumerator'
-require 'stringio'
-
-module Haml
-  # A module containing various useful functions.
-  module Util
-    extend self
-
-    # An array of ints representing the Ruby version number.
-    RUBY_VERSION = ::RUBY_VERSION.split(".").map {|s| s.to_i}
-
-    # 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(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), file)
-    end
-
-    # Converts an array of `[key, value]` pairs to a hash.
-    # For 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)
-      arr.compact.inject({}) {|h, (k, v)| h[k] = v; h}
-    end
-
-    # Maps the keys in a hash according to a block.
-    # For 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.
-    # For 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.
-    # For 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.
-    # For 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
-
-    # Concatenates all strings that are adjacent in an array,
-    # while leaving other elements as they are.
-    # For example:
-    #
-    #     merge_adjacent_strings([1, "foo", "bar", 2, "baz"])
-    #       #=> [1, "foobar", 2, "baz"]
-    #
-    # @param enum [Enumerable]
-    # @return [Array] The enumerable with strings merged
-    def merge_adjacent_strings(enum)
-      e = enum.inject([]) do |a, e|
-        if e.is_a?(String) && a.last.is_a?(String)
-          a.last << e
-        else
-          a << e
-        end
-        a
-      end
-    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
-
-    ## 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
-      return Rails.root.to_s if defined?(Rails.root)
-      return RAILS_ROOT.to_s if defined?(RAILS_ROOT)
-      return nil
-    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
-
-    # 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
-
-    ## Cross-Ruby-Version Compatibility
-
-    # Whether or not this is running under Ruby 1.8 or lower.
-    #
-    # @return [Boolean]
-    def ruby1_8?
-      Haml::Util::RUBY_VERSION[0] == 1 && Haml::Util::RUBY_VERSION[1] < 9
-    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
-
-    ## 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
-      powerset(vars).each do |set|
-        context = StaticConditionalContext.new(set).instance_eval {binding}
-        klass.class_eval(<<METHOD)
-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
-  end
-end

data/gems/gems/haml-2.2.16/lib/haml/version.rb

@@ -1,64 +0,0 @@
-require 'haml/util'
-
-module Haml
-  # Handles Haml version-reporting.
-  # Haml not only reports the standard three version numbers,
-  # but its Git revision hash as well,
-  # if it was installed from Git.
-  module Version
-    include Haml::Util
-
-    # Returns a hash representing the version of Haml.
-    # The `:major`, `:minor`, and `:teeny` keys have their respective numbers as Fixnums.
-    # The `:name` key has the name of the version.
-    # The `:string` key contains a human-readable string representation of the version.
-    # The `:number` key is the major, minor, and teeny keys separated by periods.
-    # If Haml is checked out from Git, the `:rev` key will have the revision hash.
-    # For example:
-    #
-    #     {
-    #       :string => "2.1.0.9616393",
-    #       :rev    => "9616393b8924ef36639c7e82aa88a51a24d16949",
-    #       :number => "2.1.0",
-    #       :major  => 2, :minor => 1, :teeny => 0
-    #     }
-    #
-    # @return [{Symbol => String/Fixnum}] The version hash
-    def version
-      return @@version if defined?(@@version)
-
-      numbers = File.read(scope('VERSION')).strip.split('.').map { |n| n.to_i }
-      name = File.read(scope('VERSION_NAME')).strip
-      @@version = {
-        :major => numbers[0],
-        :minor => numbers[1],
-        :teeny => numbers[2],
-        :name => name
-      }
-      @@version[:number] = [:major, :minor, :teeny].map { |comp| @@version[comp] }.compact.join('.')
-      @@version[:string] = @@version[:number].dup
-
-      if File.exists?(scope('REVISION'))
-        rev = File.read(scope('REVISION')).strip
-        rev = nil if rev !~ /^([a-f0-9]+|\(.*\))$/
-      end
-
-      if (rev.nil? || rev == '(unknown)') && File.exists?(scope('.git/HEAD'))
-        rev = File.read(scope('.git/HEAD')).strip
-        if rev =~ /^ref: (.*)$/
-          rev = File.read(scope(".git/#{$1}")).strip
-        end
-      end
-
-      if rev
-        @@version[:rev] = rev
-        unless rev[0] == ?(
-          @@version[:string] << "." << rev[0...7]
-        end
-        @@version[:string] << " (#{name})"
-      end
-
-      @@version
-    end
-  end
-end

data/gems/gems/haml-2.2.16/lib/haml.rb

@@ -1,40 +0,0 @@
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift dir unless $LOAD_PATH.include?(dir)
-
-require 'haml/version'
-
-# The module that contains everything Haml-related:
-#
-# * {Haml::Engine} is the class used to render Haml within Ruby code.
-# * {Haml::Helpers} contains Ruby helpers available within Haml templates.
-# * {Haml::Template} interfaces with web frameworks (Rails in particular).
-# * {Haml::Error} is raised when Haml encounters an error.
-# * {Haml::HTML} handles conversion of HTML to Haml.
-#
-# Also see the {file:HAML_REFERENCE.md full Haml reference}.
-module Haml
-  extend Haml::Version
-
-  # A string representing the version of Haml.
-  # A more fine-grained representation is available from Haml.version.
-  VERSION = version[:string] unless defined?(Haml::VERSION)
-
-  # Initializes Haml for Rails.
-  #
-  # This method is called by `init.rb`,
-  # which is run by Rails on startup.
-  # We use it rather than putting stuff straight into `init.rb`
-  # so we can change the initialization behavior
-  # without modifying the file itself.
-  #
-  # @param binding [Binding] The context of the `init.rb` file.
-  #   This isn't actually used;
-  #   it's just passed in in case it needs to be used in the future
-  def self.init_rails(binding)
-    # No &method here for Rails 2.1 compatibility
-    %w[haml/template sass sass/plugin].each {|f| require f}
-  end
-end
-
-require 'haml/util'
-require 'haml/engine'