tabulatr 0.0.1

data/lib/initializers/mongoid.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.
+#++
+
+# buggy like hell
+if Object.const_defined? "Mongoid"
+  raise "Mongoid support is buggy like hell as of now"
+  module Mongoid::Document
+    module ClassMethods
+      def find_for_table(params, opts={}, &block)
+        Tabulatr.find_for_mongoid_table(self, params, opts, &block)
+      end
+    end
+  end
+end

data/lib/tabulatr/tabulatr/batch_actions.rb

@@ -0,0 +1,52 @@
+#--
+# 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.
+#++
+
+class Tabulatr
+
+  # render the select tag for batch actions
+  def render_batch_actions
+    make_tag(:div, :class => @table_options[:batch_actions_div_class]) do
+      concat(t(@table_options[:batch_actions_label])) if @table_options[:batch_actions_label]
+      iname = "#{@classname}#{TABLE_FORM_OPTIONS[:batch_postfix]}"
+      case @table_options[:batch_actions_type]
+      when :select
+        make_tag(:select, :name => iname, :class => @table_options[:batch_actions_class]) do
+          concat("<option></option>")
+          @table_options[:batch_actions].each do |n,v|
+            make_tag(:option, :value => n) do
+              concat(v)
+            end # </option>
+          end # each
+        end # </select>
+      when :buttons
+        @table_options[:batch_actions].each do |n,v|
+          make_tag(:input, :type => 'submit', :value => v, 
+            :name => "#{iname}[#{n}]",
+            :class => @table_options[:batch_actions_class])
+        end # each
+      else raise "Use either :select or :buttons for :batch_actions_type"
+      end # case
+    end # </div>
+  end
+  
+end

data/lib/tabulatr/tabulatr/check_controls.rb

@@ -0,0 +1,43 @@
+#--
+# 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.
+#++
+
+class Tabulatr
+
+  def render_select_controls
+    make_tag(:div, :class => @table_options[:select_controls_div_class]) do
+      iname = "#{@classname}#{TABLE_FORM_OPTIONS[:checked_postfix]}"
+      @table_options[:select_controls].each do |name|
+        raise "Invalid check control '#{name}' requested." unless [:select_all,
+          :select_none, :select_visible, :unselect_visible,
+          :select_filtered, :unselect_filtered].member?(name)
+        topts = {
+          :type => 'submit',
+          :value => t(@table_options["#{name}_label"]),
+          :name => "#{iname}[#{name}]" }
+        topts[:class] = @table_options["#{name}_class"] if @table_options["#{name}_class"]
+        make_tag(:input, topts)
+      end
+    end # </div>
+  end
+
+end

data/lib/tabulatr/tabulatr/data_cell.rb

@@ -0,0 +1,118 @@
+#--
+# 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.
+#++
+
+class Tabulatr
+
+  # the method used to actually define the data cells of the columns,
+  # taking the name of the attribute and a hash of options.
+  #
+  # The following options are evaluated here:
+  # <tt>:td_html</tt>:: a hash with html-attributes added to the <ts>s created
+  # <tt>:method</tt>:: the actual method invoked on the record to retrieve the
+  #                    value for the column, or false if name is to be used.
+  # <tt>:fromat</tt>:: either a String by which the value is <tt>sprinf</tt>ed,
+  #                    a proc/lambda to which the value is passed or false if
+  #                    no specific formatting is desired.
+  def data_column(name, opts={}, &block)
+    raise "Not in data mode!" if @row_mode != :data
+    opts = normalize_column_options opts
+    make_tag(:td, opts[:td_html]) do
+      href = if opts[:link].class == Symbol || opts[:link].class == String
+          @view.send(opts[:link], @record)
+        elsif opts[:link].respond_to?(:call)
+          opts[:link].call(@record)
+        else
+          nil
+        end
+      make_tag((href ? :a : nil), :href => href) do
+        if block_given?
+          concat(yield(@record))
+        else
+          val = @record.send(opts[:method] || name)
+          format = opts[:format]
+          concat(
+            if format.is_a?(Proc) then format.call(val)
+            elsif format.is_a?(String) then h(format % val)
+            elsif format.is_a?(Symbol) then Tabulatr::Formattr.format(format, val)
+            else h(val.to_s)
+          end)
+        end # block_given?
+      end # </a>
+    end # </td>
+  end
+
+  # the method used to actually define the data cells of the columns,
+  # taking the name of the attribute and a hash of options.
+  #
+  # The following options are evaluated here:
+  # <tt>:td_html</tt>:: a hash with html-attributes added to the <ts>s created
+  # <tt>:method</tt>:: the actual method invoked on the record to retrieve the
+  #                    value for the column, or false if name is to be used.
+  # <tt>:fromat</tt>:: either a String by which the value is <tt>sprinf</tt>ed,
+  #                    a proc/lambda to which the value is passed or false if
+  #                    no specific formatting is desired.
+  def data_association(relation, name, opts={}, &block)
+    raise "Not in data mode!" if @row_mode != :data
+    opts = normalize_column_options opts
+    if block_given?
+      return yield(@record)
+    end
+    assoc = @record.class.reflect_on_association(relation)
+    make_tag(:td, opts[:td_html]) do
+      concat(if assoc.collection?
+        @record.send relation
+      else
+        [ @record.send(relation.to_sym) ]
+      end.map do |r|
+        val = h(r.send(opts[:method] || name))
+        val = opts[:format].call(val) if opts[:format].class == Proc
+        val = (opts[:format] % val)   if opts[:format].class == String
+        val
+      end.join(opts[:join_symbol]))
+    end # </td>
+  end
+
+  def data_checkbox(opts={}, &block)
+    raise "Whatever that's for!" if block_given?
+    iname = "#{@classname}#{@table_form_options[:checked_postfix]}[current_page][]"
+    make_tag(:td, opts[:td_html]) do
+      checked = @checked[:selected].member?(@record.id.to_s) ? :checked : nil
+      make_tag(:input, :type => 'checkbox', :name => iname,
+        :id => "#{@classname}#{@table_form_options[:checked_postfix]}_#{@record.id.to_s}",
+        :value => @record.id, :checked => checked)
+    end
+  end
+
+  def data_action(opts={}, &block)
+    raise "Not in data mode!" if @row_mode != :data
+    opts = normalize_column_options opts
+    make_tag(:td, opts[:td_html]) do
+      if block_given?
+        concat(yield(@record))
+      else
+        raise "Always give a block ino action columns"
+      end # block_given?
+    end # </td>
+  end
+
+end

data/lib/tabulatr/tabulatr/filter_cell.rb

@@ -0,0 +1,130 @@
+#--
+# 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.
+#++
+
+class Tabulatr
+
+  # the method used to actually define the filters of the columns,
+  # taking the name of the attribute and a hash of options.
+  #
+  # The following options are evaluated here:
+  # <tt>:filter_html</tt>:: a hash with html-attributes added to the <ts>s created
+  # <tt>:filter</tt>:: may take different values:
+  #                    <tt>false</tt>:: no filter is output for this column
+  #                    a container:: the keys of the hash are used to define a <tt>select</tt>
+  #                             where the values are the <tt>value</tt> of the <tt>options</tt>.
+  #                    an Array:: the elements of that array are used to define a
+  #                               <tt>select</tt>
+  #                    a String:: a <tt>select</tt> is created with that String as options
+  #                               you can use ActionView#collection_select and the like
+  def filter_column(name, opts={}, &block)
+    raise "Not in filter mode!" if @row_mode != :filter
+    opts = normalize_column_options(opts)
+    value = @filters[name]
+    make_tag(:td, opts[:filter_html]) do
+      of = opts[:filter]
+      iname = "#{@classname}#{@table_form_options[:filter_postfix]}[#{name}]"
+      filter_tag(of, iname, value, opts)
+    end # </td>
+  end
+
+  # the method used to actually define the filters of the columns,
+  # taking the name of the attribute and a hash of options.
+  #
+  # The following options are evaluated here:
+  # <tt>:filter_html</tt>:: a hash with html-attributes added to the <ts>s created
+  # <tt>:filter</tt>:: may take different values:
+  #                    <tt>false</tt>:: no filter is output for this column
+  #                    a Hash:: the keys of the hash are used to define a <tt>select</tt>
+  #                             where the values are the <tt>value</tt> of the <tt>options</tt>.
+  #                    an Array:: the elements of that array are used to define a
+  #                               <tt>select</tt>
+  #                    a subclass of <tt>ActiveRecord::Base</tt>:: a <tt>select</tt> is created
+  #                                                                with all instances
+  def filter_association(relation, name, opts={}, &block)
+    raise "Not in filter mode!" if @row_mode != :filter
+    opts = normalize_column_options(opts)
+    filters = (@filters[@table_form_options[:associations_filter]] || {})
+    value = filters["#{relation}.#{name}"]
+    make_tag(:td, opts[:filter_html]) do
+      of = opts[:filter]
+      iname = "#{@classname}#{@table_form_options[:filter_postfix]}[#{@table_form_options[:associations_filter]}][#{relation}.#{name}]"
+      filter_tag(of, iname, value, opts)
+    end # </td>
+  end
+
+  def filter_checkbox(opts={}, &block)
+    raise "Whatever that's for!" if block_given?
+    make_tag(:td, opts[:filter_html]) do
+      iname = "#{@classname}#{@table_form_options[:checked_postfix]}"
+      make_tag(:input, :type => 'hidden', :name => "#{iname}[checked_ids]", :value => @checked[:checked_ids])
+      make_tag(:input, :type => 'hidden', :name => "#{iname}[visible]", :value => @checked[:visible])
+    end
+  end
+
+  def filter_action(opts={}, &block)
+    raise "Not in filter mode!" if @row_mode != :filter
+    opts = normalize_column_options(opts)
+    make_tag(:td, opts[:filter_html]) do
+      concat(t(opts[:filter])) unless [true, false, nil].member?(opts[:filter])
+    end # </td>
+  end
+
+private
+
+  def filter_tag(of, iname, value, opts)
+    if !of
+      ""
+    elsif of.is_a?(Hash) or of.is_a?(Array) or of.is_a?(String)
+      make_tag(:select, :name => iname) do
+        if of.class.is_a?(String)
+          concat(of)
+        else
+          concat("<option></option>")
+          t = options_for_select(of)
+          concat(t.sub("value=\"#{value}\"", "value=\"#{value}\" selected=\"selected\""))
+        end
+      end # </select>
+    elsif opts[:filter] == :range
+      make_tag(:input, :type => :text, :name => "#{iname}[from]",
+        :style => "width:#{opts[:filter_width]}",
+        :value => value ? value[:from] : '')
+      concat(t(opts[:range_filter_symbol]))
+      make_tag(:input, :type => :text, :name => "#{iname}[to]",
+        :style => "width:#{opts[:filter_width]}",
+        :value => value ? value[:to] : '')
+    elsif opts[:filter] == :checkbox
+      checkbox_value = opts[:checkbox_value]
+      checkbox_label = opts[:checkbox_label]
+      concat(check_box_tag(iname, checkbox_value, false, {}))
+      concat(checkbox_label)
+    elsif opts[:filter] == :like
+      make_tag(:input, :type => :text, :name => "#{iname}[like]",
+        :style => "width:#{opts[:filter_width]}",
+        :value => value ? value[:like] : '')
+    else
+      make_tag(:input, :type => :text, :name => "#{iname}", :style => "width:#{opts[:filter_width]}",
+        :value => value)
+    end # if
+  end
+
+end

data/lib/tabulatr/tabulatr/finder/find_for_active_record_table.rb

@@ -0,0 +1,162 @@
+#--
+# 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 from ActionController instances
+# In a seperate class call only for clearity
+module Tabulatr::Finder
+
+  # -------------------------------------------------------------------
+  # Called if SomeActveRecordSubclass::find_for_table(params) is called
+  #
+  def self.find_for_active_record_table(klaz, params, o={}, &block)
+    form_options = Tabulatr.table_form_options
+    cname = class_to_param(klaz)
+    params ||= {}
+    opts = Tabulatr.finder_options.merge(o)
+    # before we do anything else, we find whether there's something to do for batch actions
+    checked_param = ActiveSupport::HashWithIndifferentAccess.new({:checked_ids => '', :current_page => []}).
+      merge(params["#{cname}#{form_options[:checked_postfix]}"] || {})
+    checked_ids = uncompress_id_list(checked_param[:checked_ids])
+    new_ids = checked_param[:current_page]
+    selected_ids = checked_ids + new_ids
+    batch_param = params["#{cname}#{form_options[:batch_postfix]}"]
+    if batch_param.present? and block_given?
+      batch_param = batch_param.keys.first.to_sym if batch_param.is_a?(Hash)
+      yield(Invoker.new(batch_param, selected_ids))
+    end
+
+    # firstly, get the conditions from the filters
+    includes = []
+    filter_param = (params["#{cname}#{form_options[:filter_postfix]}"] || {})
+    precondition = opts[:precondition] || "(1=1)"
+    conditions = filter_param.inject([precondition.dup, []]) do |c, t|
+      n, v = t
+      # FIXME n = name_escaping(n)
+      if (n != form_options[:associations_filter])
+        condition_from("#{klaz.table_name}.#{n}",v,c)
+      else
+        v.inject(c) do |c,t|
+          n,v = t
+          assoc, att = n.split(".").map(&:to_sym)
+          r = klaz.reflect_on_association(assoc)
+          includes << assoc
+          tname = r.table_name
+          nn = "#{tname}.#{att}"
+          condition_from(nn,v,c)
+        end
+      end
+    end
+    conditions = [conditions.first] + conditions.last
+
+    # secondly, find the order_by stuff
+    sortparam = params["#{cname}#{form_options[:sort_postfix]}"]
+    if sortparam
+      if sortparam[:_resort]
+        order_by = sortparam[:_resort].first.first
+        order_direction = sortparam[:_resort].first.last.first.first
+      else
+        order_by = sortparam.first.first
+        order_direction = sortparam.first.last.first.first
+      end
+      raise "SECURITY violation, sort field name is '#{n}'" unless /^[\w]+$/.match order_direction
+      raise "SECURITY violation, sort field name is '#{n}'" unless /^[\d\w]+$/.match order_by
+      order = "#{order_by} #{order_direction}"
+    else
+      if opts[:default_order]
+        l = opts[:default_order].split(" ")
+        raise(":default_order parameter should be of the form 'id asc' or 'name desc'.") \
+          if l.length == 0 or l.length > 2
+        order_by = l[0]
+        order_direction = l[1] || 'asc'
+        order = "#{order_by} #{order_direction}"
+      else
+        order = order_by = order_direction = nil
+      end
+    end
+
+    # thirdly, get the pagination data
+    pops = params["#{cname}#{form_options[:pagination_postfix]}"] || {}
+    paginate_options = Tabulatr.paginate_options.merge(opts).merge(pops)
+    pagesize = (pops[:pagesize] || opts[:default_pagesize] || paginate_options[:pagesize]).to_f
+    page = paginate_options[:page].to_i
+    page += 1 if paginate_options[:page_right]
+    page -= 1 if paginate_options[:page_left]
+    c = klaz.count :conditions => conditions, :include => includes
+    pages = (c/pagesize).ceil
+    page = [1, [page, pages].min].max
+
+    # then, we obey any "select" buttons if pushed
+    if checked_param[:select_all]
+      all = klaz.find :all, :conditions => precondition, :select => :id
+      selected_ids = all.map { |r| r.id.to_s }
+    elsif checked_param[:select_none]
+      selected_ids = []
+    elsif checked_param[:select_visible]
+      visible_ids = uncompress_id_list(checked_param[:visible])
+      selected_ids = (selected_ids + visible_ids).sort.uniq
+    elsif checked_param[:unselect_visible]
+      visible_ids = uncompress_id_list(checked_param[:visible])
+      selected_ids = (selected_ids - visible_ids).sort.uniq
+    elsif checked_param[:select_filtered]
+      all = klaz.find :all, :conditions => conditions, :select => :id, :include => includes
+      selected_ids = (selected_ids + all.map { |r| r.id.to_s }).sort.uniq
+    elsif checked_param[:unselect_filtered]
+      all = klaz.find :all, :conditions => conditions, :select => :id, :include => includes
+      selected_ids = (selected_ids - all.map { |r| r.id.to_s }).sort.uniq
+    end
+
+
+    # Now, actually find the stuff
+    found = klaz.find :all, :conditions => conditions,
+      :limit => pagesize.to_i, :offset => ((page-1)*pagesize).to_i,
+      :order  => order, :include => includes
+
+    # finally, inject methods to retrieve the current 'settings'
+    fio = Tabulatr.finder_inject_options
+    found.define_singleton_method(fio[:filters]) do filter_param end
+    found.define_singleton_method(fio[:classname]) do cname end
+    found.define_singleton_method(fio[:pagination]) do
+      { :page => page, :pagesize => pagesize, :count => c, :pages => pages,
+        :pagesizes => paginate_options[:pagesizes],
+        :total => klaz.count(:conditions => precondition) }
+    end
+    found.define_singleton_method(fio[:sorting]) do
+      order ? { :by => order_by, :direction => order_direction } : nil
+    end
+    visible_ids = (found.map { |r| r.id.to_s })
+    checked_ids = compress_id_list(selected_ids - visible_ids)
+    visible_ids = compress_id_list(visible_ids)
+    found.define_singleton_method(fio[:checked]) do
+      { :selected => selected_ids,
+        :checked_ids => checked_ids,
+        :visible => visible_ids
+      }
+    end
+    found.define_singleton_method(fio[:store_data]) do
+      opts[:store_data] || {}
+    end
+
+    found
+  end
+
+end

data/lib/tabulatr/tabulatr/finder/find_for_mongoid_table.rb

@@ -0,0 +1,116 @@
+#--
+# 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 from ActionController instances
+# In a seperate class call only for clearity
+module Tabulatr::Finder
+
+  # ----------------------------------------------------------------
+  # Called if SomeMongoidDocument::find_for_table(params) is called
+  #
+  def self.find_for_mongoid_table(klaz, params, opts={})
+    # firstly, get the conditions from the filters
+    cname = class_to_param(klaz)
+    filter_param = (params["#{cname}#{TABLE_FORM_OPTIONS[:filter_postfix]}"] || {})
+    conditions = filter_param.inject({}) do |c, t|
+      n, v = t
+      nc = c
+      # FIXME n = name_escaping(n)
+      raise "SECURITY violation, field name is '#{n}'" unless /^[\d\w]+$/.match n
+      if v.class == String
+        if v.present?
+          nc[n.to_sym] = v
+        end
+      elsif v.is_a?(Hash)
+        if v[:like]
+          if v[:like].present?
+            nc[n.to_sym] = Regexp.new("#{v[:like]}")
+          end
+        else
+          nc[n.to_sym.gte] = "#{v[:from]}" if v[:from].present?
+          nc[n.to_sym.lte] = "#{v[:to]}" if v[:to].present?
+        end
+      else
+        raise "Wrong filter type: #{v.class}"
+      end
+      nc
+    end
+
+    # secondly, find the order_by stuff
+    # FIXME: Implement me! PLEEEZE!
+    sortparam = params["#{cname}#{TABLE_FORM_OPTIONS[:sort_postfix]}"]
+    if sortparam
+      if sortparam[:_resort]
+        order_by = sortparam[:_resort].first.first
+        order_direction = sortparam[:_resort].first.last.first.first
+      else
+        order_by = sortparam.first.first
+        order_direction = sortparam.first.last.first.first
+      end
+      raise "SECURITY violation, sort field name is '#{n}'" unless /^[\w]+$/.match order_direction
+      raise "SECURITY violation, sort field name is '#{n}'" unless /^[\d\w]+$/.match order_by
+      order = [order_by, order_direction]
+    else
+      order = nil
+    end
+
+    # thirdly, get the pagination data
+    paginate_options = PAGINATE_OPTIONS.merge(opts).
+      merge(params["#{cname}#{TABLE_FORM_OPTIONS[:pagination_postfix]}"] || {})
+    page = paginate_options[:page].to_i
+    page += 1 if paginate_options[:page_right]
+    page -= 1 if paginate_options[:page_left]
+    pagesize = paginate_options[:pagesize].to_f
+    c = klaz.count :conditions => conditions
+    pages = (c/pagesize).ceil
+    page = [1, [page, pages].min].max
+
+    # Now, actually find the stuff
+    found = klaz.find(:conditions => conditions)
+    found = found.order_by([order]) if order
+    found = found.paginate(:page => page, :per_page => pagesize)
+
+    # finally, inject methods to retrieve the current 'settings'
+    found.define_singleton_method(fio[:filters]) do filter_param end
+    found.define_singleton_method(fio[:classname]) do cname end
+    found.define_singleton_method(fio[:pagination]) do
+      {:page => page, :pagesize => pagesize, :count => c, :pages => pages,
+        :pagesizes => paginate_options[:pagesizes]}
+    end
+    found.define_singleton_method(fio[:sorting]) do
+      order ? { :by => order_by, :direction => order_direction } : nil
+    end
+    checked_param = params["#{cname}#{TABLE_FORM_OPTIONS[:checked_postfix]}"]
+    checked_ids = checked_param[:checked].split(TABLE_FORM_OPTIONS[:checked_separator])
+    new_ids = checked_param[:current_page] || []
+    selected_ids = checked_ids + new_ids
+    ids = found.map { |r| r.id.to_s }
+    checked_ids = selected_ids - ids
+    found.define_singleton_method(fio[:checked]) do
+      { :selected => selected_ids,
+        :checked_ids => checked_ids.join(TABLE_FORM_OPTIONS[:checked_separator]) }
+    end
+    found
+  end
+
+end