tabulatr2 0.6.0

data/lib/tabulatr/tabulatr/row_builder.rb

@@ -0,0 +1,128 @@
+#--
+# Copyright (c) 2010-2011 Peter Horn, Provideal GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# These are extensions for use as a row builder
+# In a seperate class call only for clearity
+
+class Tabulatr
+
+  # called inside the build_table block, branches into data, header,
+  # or filter building methods depending on the current mode
+  def column(name, opts={}, &block)
+    #puts "column: '#{name}'"
+    case @row_mode
+    when :data   then data_column(name, opts, &block)
+    when :header then
+      @attributes << name.to_s
+      header_column(name, opts, &block)
+    when :filter then filter_column(name, opts, &block)
+    when :empty then empty_column(name, opts, &block)
+    else raise "Wrong row mode '#{@row_mode}'"
+    end # case
+  end
+
+  # called inside the build_table block, branches into data, header,
+  # or filter building methods depending on the current mode
+  def association(relation, name, opts={}, &block)
+    #puts "assoc: '#{relation}.#{name}'"
+    case @row_mode
+    when :data   then data_association(relation, name, opts, &block)
+    when :header then
+      @attributes << "#{relation}:#{name}"
+      header_association(relation, name, opts, &block)
+    when :filter then filter_association(relation, name, opts, &block)
+    when :empty then empty_column(name, opts, &block)
+    else raise "Wrong row mode '#{@row_mode}'"
+    end # case
+  end
+
+  # called inside the build_table block, branches into data, header,
+  # or filter building methods depending on the current mode
+  def checkbox(opts={}, &block)
+    #puts "column: '#{name}'"
+    case @row_mode
+    when :data   then data_checkbox(opts, &block)
+    when :header then header_checkbox(opts, &block)
+    when :filter then filter_checkbox(opts, &block)
+    when :empty then nil
+    else raise "Wrong row mode '#{@row_mode}'"
+    end # case
+  end
+
+  def action(opts={}, &block)
+    #puts "column: '#{name}'"
+    case @row_mode
+    when :data   then data_action(opts, &block)
+    when :header then header_action(opts, &block)
+    when :filter then filter_action(opts, &block)
+    when :empty then nil
+    else raise "Wrong row mode '#{@row_mode}'"
+    end # case
+  end
+
+private
+
+  # returns self, sets record to nil and row_mode as required for a
+  # header row
+  def header_row_builder
+    @record = nil
+    @row_mode = :header
+    self
+  end
+
+  def filter_form_builder
+    @record = nil
+    @row_mode = :filter
+    self
+  end
+
+  def empty_row_builder
+    @record = nil
+    @row_mode = :empty
+    self
+  end
+
+  def data_row_builder(record)
+    @record = record
+    @row_mode = :data
+    self
+  end
+
+
+  # some preprocessing of the options
+  def normalize_column_options(name, opts)
+    preset = column_preset_for(opts[:preset] || name)
+    opts = Tabulatr::COLUMN_OPTIONS.merge(preset).merge(opts)
+    {:width => 'width', :align => 'text-align', :valign => 'vertical-align'}.each do |key,css|
+      if opts[key]
+        [:th_html, :filter_html].each do |set|
+          opts[set] ||= {}
+          opts[set][:style] = (opts[set][:style] ? opts[set][:style] << "; " : "") << "#{css}: #{opts[key]}"
+        end # each
+      end # if
+    end # each
+    # more to come!
+    opts
+  end
+end
+

data/lib/tabulatr/tabulatr/security.rb

@@ -0,0 +1,21 @@
+require 'securerandom'
+
+class Tabulatr
+  class Security
+    def self.sign(arglist, salt=nil)
+      salt ||= SecureRandom.base64
+      str = "#{Tabulatr.secret_tokens.first}-#{salt}-#{arglist}-#{Rails.application.config.secret_token}-#{Tabulatr.secret_tokens.last}"
+      hash = Digest::SHA1.hexdigest(str)
+      "#{arglist}-#{salt}-#{hash[5..40]}"
+    end
+
+    def self.validate(str)
+      arglist, salt, hash = str.split('-')
+      str == sign(arglist, salt)
+    end
+
+    def self.validate!(str)
+      validate(str) or raise "SECURITY!"
+    end
+  end
+end

data/lib/tabulatr/tabulatr/settings.rb

@@ -0,0 +1,158 @@
+#--
+# Copyright (c) 2010-2011 Peter Horn, Provideal GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'whiny_hash'
+
+class Tabulatr
+
+  # Hash keeping the defaults for the table options, may be overriden in the
+  # table_for call
+  TABLE_OPTIONS = WhinyHash.new({ # WhinyHash.new({
+    :table_class => 'tabulatr_table',               # class for the actual data table
+    :control_div_class_before => 'table-controls',  # class of the upper div containing the paging and batch action controls
+    :control_div_class_after => 'table-controls',   # class of the lower div containing the paging and batch action controls
+    :paginator_div_class => 'pagination',            # class of the div containing the paging controls
+
+    # which controls to be rendered above and below the tabel and in which order
+    :before_table_controls => [:filter, :paginator],
+    :after_table_controls => [],
+
+    :table_html => false,              # a hash with html attributes for the table
+    :row_html => false,                # a hash with html attributes for the normal trs
+    :header_html => false,             # a hash with html attributes for the header trs
+    :filter_html => false,             # a hash with html attributes for the filter trs
+    :filter => true,                   # false for no filter row at all
+    :paginate => false,                # true to show paginator
+    :default_pagesize => 10,           # default pagesize
+    :sortable => true,                 # true to allow sorting (can be specified for every sortable column)
+    :batch_actions => false,           # :name => value hash of batch action stuff
+    :footer_content => false,          # if given, add a <%= content_for <footer_content> %> before the </table>
+    :path => '#'                       # where to send the AJAX-requests to
+  })
+
+  # these settings are considered constant for the whole application, can not be overridden
+  # on a per-table basis.
+  # That's necessary to allow find_for_table to work properly
+  TABLE_FORM_OPTIONS = WhinyHash.new({
+    :filter_postfix => '_filter',               # postfix for name of the filter in the params :hash => xxx_filter
+    :sort_postfix => '_sort',                   # postfix for name of the filter in the params :hash => xxx_filter
+    :associations_filter => '__association',    # name of the associations in the filter hash
+    :batch_postfix => '_batch',                 # postfix for name of the batch action select
+    :checked_separator => ','                   # symbol to separate the checked ids
+  })
+
+  # these settings are considered constant for the whole application, can not be overridden
+  # on a per-table basis.
+  # That's necessary to allow find_for_table to work properly
+  PAGINATE_OPTIONS = ActiveSupport::HashWithIndifferentAccess.new({
+    :page => 1,
+    :pagesize => 10,
+    :pagesizes => [10, 20, 50]
+  })
+
+  # Hash keeping the defaults for the column options
+  COLUMN_OPTIONS = ActiveSupport::HashWithIndifferentAccess.new({
+    :header => false,                   # a string to write into the header cell
+    :width => false,                    # the width of the cell
+    :align => false,                    # horizontal alignment
+    :valign => false,                   # vertical alignment
+    :wrap => true,                      # wraps
+    :type => :string,                   # :integer, :date
+    :th_html => false,                  # a hash with html attributes for the header cell
+    :filter_html => false,              # a hash with html attributes for the filter cell
+    :filter => true,                    # false for no filter field,
+                                     # container for options_for_select
+                                     # String from options_from_collection_for_select or the like
+                                     # :range for range spec
+                                     # :checkbox for a 0/1 valued checkbox
+    :checkbox_value => '1',             # value if checkbox is checked
+    :checkbox_label => '',              # text behind the checkbox
+    :filter_width => '97%',             # width of the filter <input>
+    :range_filter_symbol => '&ndash;',  # put between the <inputs> of the range filter
+    :sortable => true,                  # if set, sorting-stuff is added to the header cell
+    :format_methods => []               # javascript methods to execute on this column
+  })
+
+  # defaults for the find_for_table
+  FINDER_OPTIONS = WhinyHash.new({
+    :default_order => false,
+    :precondition => false,
+    :store_data => false,
+    :name_mapping => nil,
+    :action => nil
+  })
+
+  # Stupid hack
+  SQL_OPTIONS = WhinyHash.new({
+    :like => nil
+  })
+
+  def self.finder_options(n=nil)
+    FINDER_OPTIONS.merge!(n) if n
+    FINDER_OPTIONS
+  end
+
+  def self.column_options(n=nil)
+    COLUMN_OPTIONS.merge!(n) if n
+    COLUMN_OPTIONS
+  end
+
+  def self.table_options(n=nil)
+    TABLE_OPTIONS.merge!(n) if n
+    TABLE_OPTIONS
+  end
+
+  def self.paginate_options(n=nil)
+    PAGINATE_OPTIONS.merge!(n) if n
+    PAGINATE_OPTIONS
+  end
+
+  def self.table_form_options(n=nil)
+    TABLE_FORM_OPTIONS.merge!(n) if n
+    TABLE_FORM_OPTIONS
+  end
+
+  def self.table_design_options(n=nil)
+    raise("table_design_options stopped existing. Use table_options instead.")
+  end
+  def table_design_options(n=nil) self.class.table_design_options(n) end
+
+  def self.sql_options(n=nil)
+    SQL_OPTIONS.merge!(n) if n
+    SQL_OPTIONS
+  end
+  def sql_options(n=nil) self.class.sql_options(n) end
+
+  COLUMN_PRESETS = {}
+  def self.column_presets(n=nil)
+    COLUMN_PRESETS.merge!(n) if n
+    COLUMN_PRESETS
+  end
+  def column_presets(n=nil) self.class.column_presets(n) end
+  def column_preset_for(name)
+    h = COLUMN_PRESETS[name.to_sym]
+    return {} unless h
+    return h if h.is_a? Hash
+    COLUMN_PRESETS[h] || {}
+  end
+end

data/lib/tabulatr/tabulatr.rb

@@ -0,0 +1,343 @@
+#--
+# Copyright (c) 2010-2011 Peter Horn, Provideal GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+# Tabulatr is a class to allow easy creation of data tables as you
+# frequently find them on 'index' pages in rails. The 'table convention'
+# here is that we consider every table to consist of three parts:
+# * a header containing the names of the attribute of the column
+# * a filter which is an input element to allow for searching the
+#   particular attribute
+# * the rows with the actual data.
+#
+# Additionally, we expect that people want to 'select' rows and perform
+# batch actions on these rows.
+#
+# Author::    Peter Horn, (mailto:peter.horn@provideal.net)
+# Copyright:: Copyright (c) 2010-2011 by Provideal GmbH (http://www.provideal.net)
+# License::   MIT Licence
+class Tabulatr
+
+  include ActionView::Helpers::TagHelper
+  include ActionView::Helpers::FormTagHelper
+  include ActionView::Helpers::FormOptionsHelper
+  include ActionView::Helpers::TranslationHelper
+  include ActionView::Helpers::RecordTagHelper
+#  include ActionView::Helpers::AssetTagHelper
+#  include Rails::Application::Configurable
+
+  # Constructor of Tabulatr
+  #
+  # Parameters:
+  # <tt>klass</tt>:: the klass of the data for the table
+  # <tt>view</tt>:: the current instance of ActionView
+  # <tt>opts</tt>:: a hash of options specific for this table
+  def initialize(klass_or_record, view=nil, toptions={})
+    if klass_or_record.is_a?(Class) && klass_or_record < ActiveRecord::Base
+      @klass = klass_or_record
+      @records = nil
+    elsif klass_or_record.respond_to?(:each)
+      @records = klass_or_record
+      @klass = @records.first.try(:class)
+      toptions = toptions.merge! \
+        :filter => false,
+        :paginate => false,
+        :sortable => false
+    else
+      raise "Give a model-class or an collection to `table_for'"
+    end
+    @view = view
+    @table_options = TABLE_OPTIONS.merge(toptions)
+    @table_form_options = TABLE_FORM_OPTIONS
+    @val = []
+    @record = nil
+    @row_mode = false
+    @classname = @klass.to_s.downcase.gsub("/","_")
+    @attributes = []
+  end
+
+  cattr_accessor :bootstrap_paginator, instance_accessor: false do
+    'create_ul_paginator'
+  end
+
+  def self.config &block
+    yield self
+  end
+
+  def self.secret_tokens=(secret_tokens)
+    @@secret_tokens = secret_tokens
+  end
+
+  def self.secret_tokens
+    @@secret_tokens ||= []
+  end
+
+  # the actual table definition method. It takes an Array of records, a hash of
+  # options and a block with the actual <tt>column</tt> calls.
+  #
+  # The following options are evaluated here:
+  # <tt>:table_html</tt>:: a hash with html-attributes added to the <table> created
+  # <tt>:header_html</tt>:: a hash with html-attributes added to the <tr> created
+  #                         for the header row
+  # <tt>:filter_html</tt>:: a hash with html-attributes added to the <tr> created
+  #                         for the filter row
+  # <tt>:row_html</tt>:: a hash with html-attributes added to the <tr>s created
+  #                      for the data rows
+  # <tt>:filter</tt>:: if set to false, no filter row is output
+  def build_table(&block)
+    return nil if @records && @records.blank?
+    @val = []
+    # TODO: make_tag(:input, :type => 'submit', :style => 'display:inline; width:1px; height:1px', :value => '__submit')
+    unless @records
+      render_table_controls(:control_div_class_before, :before_table_controls)
+    end
+
+    render_element(:table, &block)
+
+    unless @records
+      render_table_controls(:control_div_class_after, :after_table_controls)
+      make_tag(:div, class: "tabulatr_count",
+        :'data-table' => "#{@klass.to_s.downcase}_table",
+        :'data-format-string' => I18n.t('tabulatr.count')){}
+
+      render_filter_dialog &block
+      sec_hash = Tabulatr::Security.sign(@attributes.join(','))
+      make_tag(:span, :id => "tabulatr_security_#{@klass.to_s.downcase}",
+        :'data-salt' => sec_hash.split('-')[1],
+        :'data-hash' => sec_hash.split('-')[2]){}
+    end
+    @val.join("").html_safe
+  end
+
+  def render_element(element, &block)
+    case element
+    when :filter then render_filter_icon
+    when :paginator then render_paginator
+    when :table then render_table &block
+    else
+      if element.is_a?(String)
+        concat(element)
+      else
+        raise "unknown element '#{element}'"
+      end
+    end
+  end
+
+
+  def render_table(&block)
+    to = @table_options[:table_html]
+    to = (to || {}).merge(:class => "#{@table_options[:table_class]} table",
+      :'data-path' => @table_options[:path], :id => "#{@klass.to_s.downcase}_table")
+    make_tag(:table, to) do
+      make_tag(:thead) do
+        render_table_header(&block)
+      end # </thead>
+      if @records
+        make_tag(:tbody) do
+          render_table_rows(&block)
+        end # </tbody>
+      else
+        make_tag(:tbody) do
+          render_empty_start_row(&block)
+        end # </tbody>
+      end
+      content_for(@table_options[:footer_content]) if @table_options[:footer_content]
+    end # </table>
+  end
+
+private
+
+  def readable_name_for(name, relation=nil)
+    if relation
+      "#{@klass.human_attribute_name(relation).titlecase}
+       #{@klass.reflect_on_association(relation).klass.
+          human_attribute_name(name).titlecase}"
+    else
+      @klass.human_attribute_name(name).titlecase
+    end
+  end
+
+  # either append to the internal string buffer or use
+  # ActionView#concat to output if an instance is available.
+  def concat(s, html_escape=false)
+    #@view.concat(s) if (Rails.version.to_f < 3.0 && @view)
+    #puts "\##{Rails.version.to_f} '#{s}'"
+    if s.present? then @val << (html_escape ? h(s) : s) end
+  end
+
+  def h(s)
+    ERB::Util.h(s)
+  end
+
+  def t(s)
+    return '' unless s.present?
+    begin
+      if s.respond_to?(:should_localize?) and s.should_localize?
+        translate(s)
+      else
+        case @should_translate
+        when :translate then translate(s)
+        when true then translate(s)
+        when :localize then localize(s)
+        else
+          if !@should_translate
+            s
+          elsif @should_translate.respond_to?(:call)
+            @should_translate.call(s)
+          else
+            raise "Wrong value '#{@should_translate}' for table option ':translate', should be false, true, :translate, :localize or a proc."
+          end
+        end
+      end
+    rescue
+      raise "Translating '#{s}' failed!"
+    end
+  end
+
+  # render the header row
+  def render_table_header(&block)
+    make_tag(:tr, @table_options[:header_html]) do
+      yield(header_row_builder)
+    end # </tr>"
+  end
+
+
+  def render_filter_options(&block)
+      yield(filter_form_builder)
+      make_tag(:input, :type => 'hidden', :name => 'sort_by')
+      make_tag(:input, :type => 'hidden', :name => 'orientation')
+  end
+
+  def render_empty_start_row(&block)
+    row_html = @table_options[:row_html] || {}
+    row_html[:class] = 'empty_row'
+    make_tag(:tr, row_html) do
+      yield empty_row_builder
+    end
+  end
+
+  def render_table_controls div_class, before_or_after
+    make_tag(:div,  :class => @table_options[div_class]) do
+      @table_options[before_or_after].each do |element|
+        render_element(element)
+      end
+    end if @table_options[before_or_after].present? # </div>
+  end
+
+  def render_filter_dialog &block
+    make_tag(:div, class: 'modal fade', id: "tabulatr_filter_dialog_#{@klass.to_s.downcase}", style: "display:none ;") do
+      make_tag(:div, class: 'modal-dialog') do
+        make_tag(:div, class: 'modal-content') do
+          make_tag(:div, class: 'modal-header') do
+            make_tag(:button, class: :close, :'data-dismiss' => :modal,
+              :'aria-hidden' => true) do
+              concat "&times"
+            end
+            make_tag(:h3, class: 'modal-title') do
+              concat I18n.t('tabulatr.filter')
+            end
+          end
+          make_tag(:form, :'data-table' => "#{@klass.to_s.downcase}_table",
+            class: 'form-horizontal tabulatr_filter_form', :'data-remote' => true) do
+            make_tag(:div, class: 'modal-body') do
+              render_filter_options &block
+            end
+            make_tag(:div, class: 'modal-footer') do
+              make_tag(:input, :type => 'submit',
+                :class => 'submit-table btn btn-primary',
+                :value => I18n.t('tabulatr.apply_filters'))
+            end
+          end
+        end # modal-content
+      end # modal-dialog
+    end # modal fade
+  end
+
+  # render the table rows, only used if records are passed
+  def render_table_rows(&block)
+    #   row_classes = @table_options[:row_classes] || []
+    #   row_html = @table_options[:row_html] || {}
+    #   row_class = row_html[:class] || ""
+    @records.each_with_index do |record, i|
+      #concat("<!-- Row #{i} -->")
+      # if row_classes.present?
+      #   rc = row_class.present? ? row_class + " " : ''
+      #   rc += row_classes[i % row_classes.length]
+      # else
+      #   rc = nil
+      # end
+      rc = nil
+      make_tag(:tr, :class => rc, :id => dom_id(record)) do
+        yield(data_row_builder(record))
+      end # </tr>
+    end
+  end
+
+  def render_table_row(&block)
+    row_html = @table_options[:row_html] || {}
+    row_html[:class] = 'empty_row'
+    make_tag(:tr, row_html) do
+      yield empty_row_builder
+    end
+  end
+
+
+  # stringly produce a tag w/ some options
+  def make_tag(name, hash={}, &block)
+    attrs = hash ? tag_options(hash) : ''
+    if block_given?
+      if name
+        concat("<#{name}#{attrs}>")
+        yield
+        concat("</#{name}>")
+      else
+        yield
+      end
+    else
+      concat("<#{name}#{attrs} />")
+    end
+    nil
+  end
+
+  def make_image_button(options)
+    inactive = options.delete(:inactive)
+    if(options['data-sort'] == 'desc')
+      icon_class = 'icon-arrow-down'
+    else
+      icon_class = 'icon-arrow-up'
+    end
+    if !inactive
+      make_tag(:i,
+        options.merge(
+          :class => "tabulatr-sort #{icon_class}"
+        )
+      )
+    else
+      make_tag(:i, :class => "tabulatr-sort #{icon_class}")
+    end
+  end
+
+end
+
+Dir[File.join(File.dirname(__FILE__), "tabulatr", "*.rb")].each do |file|
+  require file
+end

data/lib/tabulatr/version.rb

@@ -0,0 +1,3 @@
+class Tabulatr
+  VERSION = "0.6.0"
+end

data/lib/tabulatr.rb

@@ -0,0 +1,34 @@
+#--
+# Copyright (c) 2010-2011 Peter Horn, Provideal GmbH
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'tabulatr/tabulatr'
+require 'tabulatr/engine'
+require 'whiny_hash'
+
+#--
+# Mainly Monkey Patching...
+#--
+Dir[File.join(File.dirname(__FILE__), "initializers", "*.rb")].each do |file|
+  require file
+end
+