tabulatr2 0.6.0

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

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

@@ -0,0 +1,64 @@
+#--
+# 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/formattr.rb

@@ -0,0 +1,55 @@
+#--
+# 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.
+#++
+
+module Tabulatr::Formattr
+  ALLOWED_METHODS = [:euro, :dollar, :percent, :lamp]
+  #include ActionView::TagHelpers
+  
+  def self.format(nam, val)
+    nam = nam.to_sym
+    if ALLOWED_METHODS.member?(nam)
+      self.send nam, val
+    else
+      "[Requested unautorized format '#{nam}' for '#{val}'.]" 
+    end
+  end
+  
+  def self.euro(x)
+    ("%.2f €" % x).gsub(".", ",")
+  end
+  
+  def self.dollar(x)
+    "$ %.2f" % x
+  end
+  
+  def self.percent(x)
+    ("%.2f&thinspace;%%" % 100.0*x).gsub(".", ",")
+  end
+  
+  def self.lamp(x, mapping)
+    s = mapping[x].to_s
+    return "?" unless %w{g y r n}.member?(s)
+    image_tag("tabulatr/#{s}state.gif").html_safe
+  end
+  
+end

data/lib/tabulatr/tabulatr/header_cell.rb

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

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

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