tabulatr2 0.6.0

data/lib/initializers/mark_as_localizable.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.
+#++
+
+# This is probably a REALLY bad idea...
+module MarkAsLocalizable
+  def l
+    @should_localize = true
+    self
+  end
+
+  def should_localize?
+    @should_localize == true
+  end
+end
+
+class String
+  include MarkAsLocalizable
+end
+
+class Symbol
+  include MarkAsLocalizable
+end
+

data/lib/tabulatr/engine.rb

@@ -0,0 +1,3 @@
+class Tabulatr::Engine < Rails::Engine
+
+end

data/lib/tabulatr/tabulatr/adapter/active_record.rb

@@ -0,0 +1,84 @@
+class Tabulatr::Adapter::ActiveRecordAdapter < Tabulatr::Adapter
+
+  def initialize(klaz)
+    set_like_statement unless Tabulatr::SQL_OPTIONS[:like]
+
+    super klaz
+  end
+
+  def primary_key
+    @relation.primary_key.to_sym
+  end
+
+  def key_type
+    @relation.columns_hash[primary_key.to_s].type
+  end
+
+  def selected_ids(opts)
+    preconditions_scope(opts).select(:id)
+  end
+
+  def table_name
+    @relation.table_name
+  end
+
+  def table_name_for_association(assoc)
+    @base.reflect_on_association(assoc).table_name
+  end
+
+  def order_for_query(sortparam, default)
+    context = order(sortparam, default)
+    "#{context[:by]} #{context[:direction]}" if context
+  end
+
+  def order_for_query_new(sort_by, orientation)
+    "#{sort_by} #{orientation}"
+  end
+
+  def includes(inc)
+    @relation.includes(inc)
+  end
+
+  def outer_joins(*args)
+    @relation.outer_joins(*args)
+  end
+
+  def select(s)
+    @relation.select(s)
+  end
+
+  def includes!(inc)
+    @relation = includes(includes)
+  end
+
+  def add_conditions_from(n,v)
+    like ||= Tabulatr.sql_options[:like]
+    if v.is_a?(String)
+      @relation = @relation.where("#{n} = ?", v) unless v.blank?
+    elsif v.is_a?(Hash)
+      if v[:like].present?
+        @relation = @relation.where("#{n} #{like} ?", "%#{v[:like]}%")
+      else
+        @relation = @relation.where("#{n} >= ?", "#{v[:from]}") if v[:from].present?
+        @relation = @relation.where("#{n} <= ?", "#{v[:to]}") if v[:to].present?
+      end
+    else
+      raise "Wrong filter type: #{v.class}"
+    end
+  end
+
+  private
+  def set_like_statement
+    case ActiveRecord::Base.connection.class.to_s
+      when "ActiveRecord::ConnectionAdapters::MysqlAdapter" then Tabulatr.sql_options(:like => 'LIKE')
+      when "ActiveRecord::ConnectionAdapters::Mysql2Adapter" then Tabulatr.sql_options(:like => 'LIKE')
+      when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter" then Tabulatr.sql_options(:like => 'ILIKE')
+      when "ActiveRecord::ConnectionAdapters::SQLiteAdapter" then Tabulatr.sql_options(:like => 'LIKE')
+      when "ActiveRecord::ConnectionAdapters::SQLite3Adapter" then Tabulatr.sql_options(:like => 'LIKE')
+      else
+        warn("Tabulatr Warning: Don't know which LIKE operator to use for the ConnectionAdapter '#{ActiveRecord::Base.connection.class}'.\n" +
+          "Please specify by `Tabulatr.sql_options(:like => '<likeoperator>')`")
+        Tabulatr.sql_options(:like => 'LIKE')
+    end
+  end
+end

data/lib/tabulatr/tabulatr/adapter.rb

@@ -0,0 +1,55 @@
+class Tabulatr::Adapter
+  def initialize(klaz)
+    @base = klaz
+    @relation = klaz
+  end
+
+  delegate :all, :dup, :count, :limit, :to => :@relation
+
+  def to_sql
+    @relation.to_sql if @relation.respond_to? :to_sql
+  end
+
+  def class_to_param
+    @relation.to_s.downcase.gsub("/","_")
+  end
+
+  def preconditions_scope(opts)
+    opts[:precondition].present? ? @base.where(opts[:precondition]) : @base
+  end
+
+  def order(sortparam, default)
+    order_by, order_direction = sort_params(sortparam, default)
+    order_by ? { :by => order_by, :direction => order_direction } : nil
+  end
+
+  def sort_params(sortparam, default)
+    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
+    else
+      if default
+        l = default.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'
+      else
+        order_by = order_direction = nil
+      end
+    end
+
+    return order_by, order_direction
+  end
+end
+
+Dir[File.join(File.dirname(__FILE__), "adapter", "*.rb")].each do |file|
+  require file
+end

data/lib/tabulatr/tabulatr/batch_actions.rb

@@ -0,0 +1,51 @@
+#--
+# 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 or the buttons for batch actions
+  def render_batch_actions
+    iname = "#{@classname}#{TABLE_FORM_OPTIONS[:batch_postfix]}"
+    make_tag(:span, :class => 'dropdown') do
+      make_tag(:button,
+                :class => 'disabled btn btn-small tabulatr-wrench',
+                :'data-toggle' => "dropdown") do
+        concat("<i class='icon-wrench'></i>#{I18n.t('tabulatr.batch_actions')}
+                <span class='caret'></span>")
+      end
+      make_tag(:ul, class: 'dropdown-menu', role: 'menu',
+                :'aria-labelledby' => 'dLabel') do
+        @table_options[:batch_actions].each do |n,v|
+          make_tag(:li) do
+            make_tag(:a, :value => v,
+              :name => "#{iname}[#{n}]",
+              :class => "btn batch-action-inputs") do
+              concat(v)
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/tabulatr/tabulatr/data_cell.rb

@@ -0,0 +1,132 @@
+#--
+# 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(name, 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(@view.instance_exec(@record, &block))
+        else
+          val = @record.send(opts[:method] || name)
+          format = opts[:format]
+          concat(
+            if format.is_a?(Proc) then @view.instance_exec(val, &format)
+            elsif format.is_a?(String) then h(format % val)
+            elsif format.is_a?(Symbol) then @view.send(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>:format</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(name, opts)
+    if block_given?
+      return @view.instance_exec(@record, &block)
+    end
+    assoc = @record.class.reflect_on_association(relation)
+    make_tag(:td, opts[:td_html]) do
+      format = opts[:format]
+      ass = @record.send(relation.to_sym)
+      if opts[:sort_by]
+        # TODO: SORTING specified by opts[:sort_by]
+      end
+      concat(if (ass.is_a?(Array) || ass.respond_to?(:to_ary)) && (opts[:map] != false)
+        ass.map do |r|
+          val = h(r.send(opts[:method] || name))
+          if format.is_a?(Proc) then format.call(val)
+          elsif format.is_a?(String) then h(format % val)
+          elsif format.is_a?(Symbol) then @view.send(format, val)
+          else h(val.to_s)
+          end
+        end.join(opts[:join_symbol] || ', ')
+      else
+        return '' unless ass
+        #puts ass.to_s
+        val = h(ass.send(opts[:method] || name))
+        val = if format.is_a?(Proc) then @view.instance_exec(val, &format)
+        elsif format.is_a?(String) then h(format % val)
+        elsif format.is_a?(Symbol) then @view.send(format, val)
+        else h(val.to_s)
+        end
+      end)
+    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.send(@id)) ? :checked : nil
+      make_tag(:input, :type => 'checkbox', :name => iname,
+        :id => "#{@classname}#{@table_form_options[:checked_postfix]}_#{@record.send(@id).to_s}",
+        :value => @record.send(@id), :checked => checked)
+    end
+  end
+
+  def data_action(opts={}, &block)
+    raise "Not in data mode!" if @row_mode != :data
+    opts = normalize_column_options(:action_column, 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/dummy_record.rb

@@ -0,0 +1,40 @@
+class Tabulatr::DummyRecord
+
+  def self.for(klaz)
+    c = Class.new(self)
+    c.instance_variable_set("@model_name", klaz.model_name)
+    c.new
+  end
+
+  def to_s
+    @methods ||= []
+    if @methods.any?
+      m = @methods.join(':')
+      @method_names ||= []
+      @method_names << m
+      @methods.clear
+      "{{#{m}}}"
+    else
+      "{{id}}"
+    end
+  end
+
+  def method_missing(sym, *args)
+    @methods ||= []
+    @methods << sym.to_s
+    self
+  end
+
+  def to_key
+    ["{{id}}"]
+  end
+
+  def requested_methods
+    Array(@method_names).try(:uniq)
+  end
+
+  def self.model_name
+    @model_name
+  end
+
+end

data/lib/tabulatr/tabulatr/empty_cell.rb

@@ -0,0 +1,44 @@
+#--
+# 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 empty_column(name, opts={}, &block)
+    raise "Not in empty mode!" if @row_mode != :empty
+    opts = normalize_column_options(name, opts)
+    make_tag(:td, opts[:filter_html])
+  end
+end

data/lib/tabulatr/tabulatr/filter_cell.rb

@@ -0,0 +1,145 @@
+#--
+# 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

@@ -0,0 +1,6 @@
+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