tabulatr2 0.6.0 → 0.8.0

data/lib/tabulatr/tabulatr/filter_cell.rb

@@ -1,145 +0,0 @@
-#--
-# 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(name, opts)
-    of = opts[:filter]
-    iname = "#{@classname}#{@table_form_options[:filter_postfix]}[#{name}]"
-    filter_name = "tabulatr_form_#{name}"
-    build_filter(of, filter_name, name, iname, opts) if filterable?(of, name.to_s)
-  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(name, opts)
-
-    of = opts[:filter]
-    iname = "#{@classname}#{@table_form_options[:filter_postfix]}[#{@table_form_options[:associations_filter]}][#{relation}.#{name}]"
-    filter_name = "tabulatr_form_#{relation}_#{name}"
-    build_filter(of, filter_name, name, iname, opts, relation) if filterable?(of, name.to_s, relation)
-  end
-
-  def filter_checkbox(opts={}, &block)
-    raise "Whatever that's for!" if block_given?
-    make_tag(:td, opts[:filter_html]) {}
-  end
-
-  def filter_action(opts={}, &block)
-    raise "Not in filter mode!" if @row_mode != :filter
-    opts = normalize_column_options(:action_column, 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, name, iname, attr_name, opts)
-    if !of
-      ""
-    elsif of.is_a?(Hash) or of.is_a?(Array) or of.is_a?(String)
-      make_tag(:select, :style => "width:#{opts[:filter_width]}",
-        :id => name, 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=\"\" selected=\"selected\""))
-        end
-      end # </select>
-    elsif opts[:filter] == :range
-      filter_text_tag(opts[:filter_width], "#{name}_from", iname, attr_name, 'from')
-      concat(t(opts[:range_filter_symbol]))
-      filter_text_tag(opts[:filter_width], "#{name}_to", iname, attr_name, '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] == :exact
-      filter_text_tag(opts[:filter_width], name, iname, attr_name, 'normal')
-    else
-      filter_text_tag(opts[:filter_width], name, iname, attr_name, 'like')
-    end # if
-  end
-
-  def filter_text_tag width, name, iname, attr_name, type=nil
-    name_attribute = iname
-    name_attribute += "[#{type}]" if type && type != 'normal'
-    make_tag(:input, :type => :text, :id => name,
-        :style => "width:#{width}",
-        :value => '',
-        :'data-type' => type,
-        :'data-tabulatr-attribute' => attr_name,
-        :class => 'tabulatr_filter',
-        :name => name_attribute)
-  end
-
-  def build_filter(of, filter_name, name, iname, opts, relation=nil)
-    if of
-      make_tag(:div, class: 'control-group') do
-        make_tag(:label, class: 'control-label', for: filter_name) do
-          concat(t(opts[:header] || readable_name_for(name, relation)), :escape_html)
-        end
-        make_tag(:div, class: 'controls') do
-          filter_tag(of, filter_name, iname, name, opts)
-        end
-      end
-    end
-  end
-
-  def filterable?(of, name, relation=nil)
-   of && (!(relation && name.to_sym == :count))
-  end
-
-end

data/lib/tabulatr/tabulatr/filter_icon.rb

@@ -1,6 +0,0 @@
-class Tabulatr
-  def render_filter_icon
-    make_tag(:a, class: 'btn btn-info', href: "#tabulatr_filter_dialog_#{@klass.to_s.downcase}",
-      :'data-toggle' => 'modal'){ concat('<i class="icon-filter"></i>Filter') }
-  end
-end

data/lib/tabulatr/tabulatr/finder/find_for_table.rb

@@ -1,187 +0,0 @@
-#--
-# 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
-
-require 'activerecord_outer_joins'
-
-module Tabulatr::Finder
-
-  # -------------------------------------------------------------------
-  # Called if SomeActveRecordSubclass::find_for_table(params) is called
-  #
-  def self.find_for_table(klaz, params, options={}, &block)
-    adapter = if klaz.respond_to?(:descends_from_active_record?) then ::Tabulatr::Adapter::ActiveRecordAdapter.new(klaz)
-      else raise("Don't know how to deal with class '#{klaz}'")
-    end
-
-    Tabulatr::Security.validate!("#{params[:arguments]}-#{params[:salt]}-#{params[:hash]}")
-
-    form_options    = Tabulatr.table_form_options
-    opts            = Tabulatr.finder_options.merge(options)
-    params          ||= {} # just to be sure
-    cname           = adapter.class_to_param
-    sort_name       = "#{cname}#{form_options[:sort_postfix]}"
-    filter_name     = "#{cname}#{form_options[:filter_postfix]}"
-    batch_name      = "#{cname}#{form_options[:batch_postfix]}"
-    check_name      = "tabulatr_checked"
-    append = params[:append].present? ? params[:append] : false
-
-
-    append = string_to_boolean append
-    # 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[check_name] || {})
-
-    id = adapter.primary_key
-
-    serializer = options[:serializer].presence
-
-    # checkboxes
-    checked_ids = checked_param[:checked_ids]
-    selected_ids = checked_ids.split(',')
-
-    execute_batch_actions(params[batch_name], selected_ids, &block)
-
-    # at this point, we've retrieved the filter settings, the sorting setting, the pagination settings and
-    # the selected_ids.
-    filter_param = (params[filter_name] || {})
-    sortparam = params[sort_name]
-
-    includes = []
-    maps = klaz.tabulatr_name_mappings.merge(opts[:name_mapping] || {})
-
-    build_conditions(filter_param, form_options, includes, adapter, maps)
-    order = build_order(params[:sort_by], params[:orientation], params[:default_order], maps, adapter, klaz)
-
-    c = adapter.includes(includes).references(includes).count
-    # Group statments return a hash
-    c = c.count unless c.class == Fixnum
-    pagesize = params[:pagesize]
-    pagination_data = build_offset(params[:page], pagesize, c, opts)
-
-    total = adapter.preconditions_scope(opts).count
-    # here too
-    total = total.count unless total.class == Fixnum
-
-    # Now, actually find the stuff
-    opts[:name_mapping] ||= {}
-    find_on = (klaz.tabulatr_select_attributes(opts[:name_mapping]).try do |s| adapter.select(s) end) || adapter
-    found = find_on.outer_joins(includes)
-            .limit(pagination_data[:pagesize]).offset(pagination_data[:offset])
-            .order(order).to_a
-
-    found.define_singleton_method(:__pagination) do
-      { :page => pagination_data[:page],
-        :pagesize => pagination_data[:pagesize],
-        :count => c,
-        :pages => pagination_data[:pages],
-        :pagesizes => {},
-        :total => total,
-        :append => append,
-        :table_id => params[:table_id] }
-    end
-
-    found.define_singleton_method(:to_tabulatr_json) do |klass=nil|
-      Tabulatr::JsonBuilder.build found, klass, params[:arguments], id
-    end
-
-    found
-  end
-
-  private
-
-  def self.execute_batch_actions batch_param, selected_ids, &block
-    if batch_param.present? && block_given?
-      batch_param = batch_param.keys.first.to_sym if batch_param.is_a?(Hash)
-      yield(Invoker.new(batch_param, selected_ids))
-    end
-  end
-
-  def self.build_conditions filter_param, form_options, includes, adapter, maps
-    filter_param.each do |filter|
-      name, value = filter
-      next unless value.present?
-      if (name != form_options[:associations_filter])
-        table_name = adapter.table_name
-        nn = extract_column_name(table_name, name, maps)
-        adapter.add_conditions_from(nn, value)
-      else
-        value.each do |assoc_filter|
-          name,value = assoc_filter
-          assoc, att = name.split(".").map(&:to_sym)
-          includes << assoc
-          table_name = adapter.table_name_for_association(assoc)
-          nn = extract_column_name(table_name, name, maps, att)
-          adapter.add_conditions_from(nn, value)
-        end
-      end
-    end
-  end
-
-  def self.extract_column_name(table_name, n, maps, att=nil)
-    if maps[n.to_sym]
-      maps[n.to_sym]
-    else
-      if att
-        t = "#{table_name}.#{att}"
-      else
-        t = "#{table_name}.#{n}"
-      end
-      raise "SECURITY violation, field name is '#{t}'" unless /^[\d\w]+(\.[\d\w]+)?$/.match t
-      t
-    end
-  end
-
-  def self.build_order sort_by, orientation, default_order, maps, adapter, klaz
-    if sort_by.present?
-      s_by = maps[sort_by] ? maps[sort_by] : sort_by
-      adapter.order_for_query_new s_by, orientation
-    else
-      default_order || "#{klaz.table_name}.#{klaz.primary_key} asc"
-    end
-  end
-
-  def self.build_offset page, pagesize=10, count, opts
-    page ||= 1
-    pagesize, page = pagesize.to_i, page.to_i
-    pagesize = 10 if pagesize == 0
-
-    pages = (count/pagesize.to_f).ceil
-
-    {offset: ((page-1)*pagesize).to_i, pagesize: pagesize.to_i, pages: pages,
-     page: page
-    }
-  end
-
-  def self.string_to_boolean str
-    if str == 'true'
-      str = true
-    elsif str == 'false'
-      str = false
-    end
-    str
-  end
-
-end

data/lib/tabulatr/tabulatr/finder.rb

@@ -1,64 +0,0 @@
-#--
-# 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
-module Tabulatr::Finder
-
-  require File.join(File.dirname(__FILE__), 'finder', 'find_for_table')
-
-  # compress the list of ids as good as I could imagine ;)
-  # uses fancy base twisting
-  def self.compress_id_list(list)
-    if list.length == 0
-      ""
-    else
-      "GzB" + Base64.encode64(
-        Zlib::Deflate.deflate(
-          list.join(Tabulatr.table_form_options[:checked_separator])))
-    end
-  end
-
-  # inverse of compress_id_list
-  def self.uncompress_id_list(str)
-    if !str.present?
-      []
-    elsif str.starts_with?("GzB")
-      Zlib::Inflate.inflate(Base64.decode64(str[3..-1])).split(
-      Tabulatr.table_form_options[:checked_separator])
-    end
-  end
-
-  class Invoker
-    def initialize(batch_action, ids)
-      @batch_action = batch_action.to_sym
-      @ids = ids
-    end
-
-    def method_missing(name, *args, &block)
-      if @batch_action == name
-        yield(@ids)
-      end
-    end
-  end
-
-end

data/lib/tabulatr/tabulatr/header_cell.rb

@@ -1,146 +0,0 @@
-#--
-# 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 headers of the columns,
-  # taking the name of the attribute and a hash of options.
-  #
-  # The following options are evaluated here:
-  # <tt>:th_html</tt>:: a hash with html-attributes added to the <th>s created
-  # <tt>:header</tt>:: if present, the value will be output in the header cell,
-  #                    otherwise, the capitalized name is used
-  def header_column(name, opts={}, &block)
-    raise "Not in header mode!" if @row_mode != :header
-    sortparam = "#{@classname}#{@table_form_options[:sort_postfix]}"
-    filter_name = "#{@classname}#{@table_form_options[:filter_postfix]}[#{name}]"
-    bid = "#{@classname}#{@table_form_options[:sort_postfix]}"
-
-    create_header_tag(name, opts, sortparam, filter_name, name,
-      nil, bid
-    )
-    # opts = normalize_column_options(name, opts)
-    # opts = normalize_header_column_options opts
-    # opts[:th_html]['data-tabulatr-column-name'] = name
-    # opts[:th_html]['data-tabulatr-form-name'] = filter_name
-    # opts[:th_html]['data-tabulatr-sorting-name'] = "#{@klass.table_name}.#{name}"
-    # make_tag(:th, opts[:th_html]) do
-    #   concat(t(opts[:header] || readable_name_for(name)), :escape_html)
-    #   create_sorting_elements opts, sortparam, name, bid
-    # end # </th>
-  end
-
-  # the method used to actually define the headers of the columns,
-  # taking the name of the attribute and a hash of options.
-  #
-  # The following options are evaluated here:
-  # <tt>:th_html</tt>:: a hash with html-attributes added to the <th>s created
-  # <tt>:header</tt>:: if present, the value will be output in the header cell,
-  #                    otherwise, the capitalized name is used
-  def header_association(relation, name, opts={}, &block)
-    raise "Not in header mode!" if @row_mode != :header
-    create_header_tag(name, opts,
-      "#{@classname}#{@table_form_options[:sort_postfix]}[#{relation.to_s}.#{name.to_s}]",
-      "#{@classname}#{@table_form_options[:filter_postfix]}[#{@table_form_options[:associations_filter]}][#{relation.to_s}.#{name.to_s}]",
-      "#{relation}:#{name}",
-      relation
-    )
-  end
-
-  def header_checkbox(opts={}, &block)
-    raise "Whatever that's for!" if block_given?
-    opts = normalize_column_options(:checkbox_column, opts)
-    opts = normalize_header_column_options opts, :checkbox
-    make_tag(:th, opts[:th_html]) do
-      make_tag(:input, type: 'checkbox', :'data-table' => "#{@klass.to_s.downcase}_table",
-        class: "tabulatr_mark_all"){}
-      render_batch_actions if @table_options[:batch_actions]
-    end
-  end
-
-  def header_action(opts={}, &block)
-    raise "Please specify a block" unless block_given?
-    opts = normalize_column_options(:action_column, opts)
-    opts = normalize_header_column_options opts, :action
-    dummy = DummyRecord.for(@klass)
-    cont = yield(dummy)
-    cont = cont.join(' ') if cont.is_a? Array
-    opts[:th_html]['data-tabulatr-action'] = cont.gsub('"', "'")
-    @attributes = (@attributes + dummy.requested_methods).flatten
-    names = dummy.requested_methods.join(',')
-
-    make_tag(:th, opts[:th_html].merge('data-tabulatr-column-name' => names)) do
-      concat(t(opts[:header] || ""), :escape_html)
-    end
-  end
-
-  private
-
-  def normalize_header_column_options opts, type=nil
-    opts[:th_html] ||= {}
-    opts[:th_html]['data-tabulatr-column-type'] = type if type
-    if opts[:format_methods]
-      opts[:th_html]['data-tabulatr-methods'] = opts[:format_methods].join(',')
-    end
-    opts
-  end
-
-  def create_sorting_elements opts, sortparam, name, bid=""
-    if opts[:sortable] and @table_options[:sortable]
-      if @sorting and @sorting[:by].to_s == name.to_s
-        pname = "#{sortparam}[_resort][#{name}]"
-        bid = "#{bid}_#{name}"
-        sort_dir = @sorting[:direction] == 'asc' ? 'desc' : 'asc'
-        make_tag(:input, :type => :hidden,
-          :name => "#{sortparam}[#{name}][#{@sorting[:direction]}]",
-          :value => "#{@sorting[:direction]}")
-      else
-        pname = "#{sortparam}[_resort][#{name}]"
-        bid = "#{bid}_#{name}"
-        sort_dir = 'desc'
-      end
-      make_image_button(:id => bid, :name => pname, :'data-sort' => sort_dir)
-    end
-  end
-
-
-  def create_header_tag name, opts, sort_param, filter_name, column_name, relation=nil, bid=nil
-    opts = normalize_column_options(name, opts)
-    opts = normalize_header_column_options(opts)
-    opts[:th_html]['data-tabulatr-column-name'] = column_name
-    opts[:th_html]['data-tabulatr-form-name'] = filter_name
-    opts[:th_html]['data-tabulatr-sorting-name'] = sorting_name(name, relation)
-    make_tag(:th, opts[:th_html]) do
-      concat(t(opts[:header] || readable_name_for(name, relation)), :escape_html)
-      create_sorting_elements(opts, sort_param, name, bid) unless relation && name.to_sym == :count
-    end # </th>
-  end
-
-  def sorting_name name, relation=nil
-    return "#{@klass.reflect_on_association(relation).table_name}.#{name}" if relation && @klass.reflect_on_association(relation).klass.column_names.include?(name.to_s)
-    return "#{@klass.table_name}.#{name}" if @klass.column_names.include?(name.to_s)
-    name
-  end
-
-end

data/lib/tabulatr/tabulatr/json_builder.rb

@@ -1,57 +0,0 @@
-module Tabulatr::JsonBuilder
-  def self.build(data, klass, requested_attributes, id)
-    if klass && ActiveModel.const_defined?(:ArraySerializer)
-      ActiveModel::ArraySerializer.new(data,
-        { root: "data", meta: data.__pagination,
-          each_serializer: klass
-        }).as_json
-    else
-      id_included = false
-      attrs = build_hash_from requested_attributes, id
-      result = []
-      data.each do |f|
-        tmp = {}
-        attrs.each do |at|
-          insert_attribute_in_hash(at, f, tmp)
-        end
-        result << tmp
-      end
-      { data: result, meta: data.__pagination }
-    end
-  end
-
-  private
-
-  def self.build_hash_from requested_attributes, id
-    attrs = []
-    id_included = false
-    requested_attributes.split(',').each do |par|
-      if par.include? ':'
-        relation, action = par.split(':')
-        attrs << {action: action, relation: relation}
-      else
-        id_included = true if par == id
-        attrs << {action: par}
-      end
-    end
-    attrs << {action: id} unless id_included
-    attrs
-  end
-
-  def self.insert_attribute_in_hash at, f, r={}
-    if at.has_key? :relation
-      if f.class.reflect_on_association(at[:relation].to_sym).collection?
-        if at[:action].to_sym == :count
-          r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).count
-        else
-          r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).map(&at[:action].to_sym).join(', ')
-        end
-      else
-        r["#{at[:relation]}:#{at[:action]}"] = f.try(at[:relation]).try(at[:action])
-      end
-    else
-      r[at[:action]] = f.send at[:action]
-    end
-    r
-  end
-end

data/lib/tabulatr/tabulatr/paginator.rb

@@ -1,76 +0,0 @@
-#--
-# 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 paginator controls, inputs etc.
-  def render_paginator
-    # get the current pagination state
-    if (@table_options[:paginate].is_a?(Fixnum)) && @klass.count > @table_options[:paginate] ||
-      @table_options[:paginate] === true
-      send(Tabulatr.bootstrap_paginator)
-    end
-    make_tag(:div, :class => 'btn-group tabulatr-per-page', :'data-table' => "#{@klass.to_s.downcase}_table") do
-      make_tag(:button, :class => 'btn') do
-        concat(I18n.t('tabulatr.rows_per_page'))
-      end
-      make_tag(:button, :class => 'btn dropdown-toggle', :'data-toggle' => 'dropdown') do
-        make_tag(:span, :class => 'caret'){}
-      end
-      make_tag(:ul, :class => 'dropdown-menu') do
-        [10, 25, 50, 100].push(@table_options[:default_pagesize]).uniq.sort.each do |n|
-          create_pagination_select(n, n == @table_options[:default_pagesize])
-        end
-      end
-    end
-  end
-
-  def create_pagination_select n, default=false
-    make_tag(:li) do
-      params = { :href => "javascript: void(0);",
-                 :'data-items-per-page' => n }
-      params[:class] = 'active' if default
-      make_tag(:a, params) do
-        concat(n)
-      end
-    end
-  end
-
-  private
-
-  # bootstrap 3
-  def create_ul_paginator
-    make_tag(:ul, :class => @table_options[:paginator_div_class],
-      :'data-table' => "#{@klass.to_s.downcase}_table") do
-    end
-  end
-
-  # bootstrap 2
-  def create_div_paginator
-    make_tag(:div, :class => @table_options[:paginator_div_class],
-      :'data-table' => "#{@klass.to_s.downcase}_table") do
-      make_tag(:ul){}
-    end
-  end
-
-end