tabulatr2 0.6.0 → 0.8.0

data/lib/tabulatr/tabulatr/row_builder.rb

@@ -1,128 +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 as a row builder
-# In a seperate class call only for clearity
-
-class Tabulatr
-
-  # called inside the build_table block, branches into data, header,
-  # or filter building methods depending on the current mode
-  def column(name, opts={}, &block)
-    #puts "column: '#{name}'"
-    case @row_mode
-    when :data   then data_column(name, opts, &block)
-    when :header then
-      @attributes << name.to_s
-      header_column(name, opts, &block)
-    when :filter then filter_column(name, opts, &block)
-    when :empty then empty_column(name, opts, &block)
-    else raise "Wrong row mode '#{@row_mode}'"
-    end # case
-  end
-
-  # called inside the build_table block, branches into data, header,
-  # or filter building methods depending on the current mode
-  def association(relation, name, opts={}, &block)
-    #puts "assoc: '#{relation}.#{name}'"
-    case @row_mode
-    when :data   then data_association(relation, name, opts, &block)
-    when :header then
-      @attributes << "#{relation}:#{name}"
-      header_association(relation, name, opts, &block)
-    when :filter then filter_association(relation, name, opts, &block)
-    when :empty then empty_column(name, opts, &block)
-    else raise "Wrong row mode '#{@row_mode}'"
-    end # case
-  end
-
-  # called inside the build_table block, branches into data, header,
-  # or filter building methods depending on the current mode
-  def checkbox(opts={}, &block)
-    #puts "column: '#{name}'"
-    case @row_mode
-    when :data   then data_checkbox(opts, &block)
-    when :header then header_checkbox(opts, &block)
-    when :filter then filter_checkbox(opts, &block)
-    when :empty then nil
-    else raise "Wrong row mode '#{@row_mode}'"
-    end # case
-  end
-
-  def action(opts={}, &block)
-    #puts "column: '#{name}'"
-    case @row_mode
-    when :data   then data_action(opts, &block)
-    when :header then header_action(opts, &block)
-    when :filter then filter_action(opts, &block)
-    when :empty then nil
-    else raise "Wrong row mode '#{@row_mode}'"
-    end # case
-  end
-
-private
-
-  # returns self, sets record to nil and row_mode as required for a
-  # header row
-  def header_row_builder
-    @record = nil
-    @row_mode = :header
-    self
-  end
-
-  def filter_form_builder
-    @record = nil
-    @row_mode = :filter
-    self
-  end
-
-  def empty_row_builder
-    @record = nil
-    @row_mode = :empty
-    self
-  end
-
-  def data_row_builder(record)
-    @record = record
-    @row_mode = :data
-    self
-  end
-
-
-  # some preprocessing of the options
-  def normalize_column_options(name, opts)
-    preset = column_preset_for(opts[:preset] || name)
-    opts = Tabulatr::COLUMN_OPTIONS.merge(preset).merge(opts)
-    {:width => 'width', :align => 'text-align', :valign => 'vertical-align'}.each do |key,css|
-      if opts[key]
-        [:th_html, :filter_html].each do |set|
-          opts[set] ||= {}
-          opts[set][:style] = (opts[set][:style] ? opts[set][:style] << "; " : "") << "#{css}: #{opts[key]}"
-        end # each
-      end # if
-    end # each
-    # more to come!
-    opts
-  end
-end
-

data/lib/tabulatr/tabulatr/security.rb

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

data/lib/tabulatr/tabulatr/settings.rb

@@ -1,158 +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.
-#++
-
-require 'whiny_hash'
-
-class Tabulatr
-
-  # Hash keeping the defaults for the table options, may be overriden in the
-  # table_for call
-  TABLE_OPTIONS = WhinyHash.new({ # WhinyHash.new({
-    :table_class => 'tabulatr_table',               # class for the actual data table
-    :control_div_class_before => 'table-controls',  # class of the upper div containing the paging and batch action controls
-    :control_div_class_after => 'table-controls',   # class of the lower div containing the paging and batch action controls
-    :paginator_div_class => 'pagination',            # class of the div containing the paging controls
-
-    # which controls to be rendered above and below the tabel and in which order
-    :before_table_controls => [:filter, :paginator],
-    :after_table_controls => [],
-
-    :table_html => false,              # a hash with html attributes for the table
-    :row_html => false,                # a hash with html attributes for the normal trs
-    :header_html => false,             # a hash with html attributes for the header trs
-    :filter_html => false,             # a hash with html attributes for the filter trs
-    :filter => true,                   # false for no filter row at all
-    :paginate => false,                # true to show paginator
-    :default_pagesize => 10,           # default pagesize
-    :sortable => true,                 # true to allow sorting (can be specified for every sortable column)
-    :batch_actions => false,           # :name => value hash of batch action stuff
-    :footer_content => false,          # if given, add a <%= content_for <footer_content> %> before the </table>
-    :path => '#'                       # where to send the AJAX-requests to
-  })
-
-  # these settings are considered constant for the whole application, can not be overridden
-  # on a per-table basis.
-  # That's necessary to allow find_for_table to work properly
-  TABLE_FORM_OPTIONS = WhinyHash.new({
-    :filter_postfix => '_filter',               # postfix for name of the filter in the params :hash => xxx_filter
-    :sort_postfix => '_sort',                   # postfix for name of the filter in the params :hash => xxx_filter
-    :associations_filter => '__association',    # name of the associations in the filter hash
-    :batch_postfix => '_batch',                 # postfix for name of the batch action select
-    :checked_separator => ','                   # symbol to separate the checked ids
-  })
-
-  # these settings are considered constant for the whole application, can not be overridden
-  # on a per-table basis.
-  # That's necessary to allow find_for_table to work properly
-  PAGINATE_OPTIONS = ActiveSupport::HashWithIndifferentAccess.new({
-    :page => 1,
-    :pagesize => 10,
-    :pagesizes => [10, 20, 50]
-  })
-
-  # Hash keeping the defaults for the column options
-  COLUMN_OPTIONS = ActiveSupport::HashWithIndifferentAccess.new({
-    :header => false,                   # a string to write into the header cell
-    :width => false,                    # the width of the cell
-    :align => false,                    # horizontal alignment
-    :valign => false,                   # vertical alignment
-    :wrap => true,                      # wraps
-    :type => :string,                   # :integer, :date
-    :th_html => false,                  # a hash with html attributes for the header cell
-    :filter_html => false,              # a hash with html attributes for the filter cell
-    :filter => true,                    # false for no filter field,
-                                     # container for options_for_select
-                                     # String from options_from_collection_for_select or the like
-                                     # :range for range spec
-                                     # :checkbox for a 0/1 valued checkbox
-    :checkbox_value => '1',             # value if checkbox is checked
-    :checkbox_label => '',              # text behind the checkbox
-    :filter_width => '97%',             # width of the filter <input>
-    :range_filter_symbol => '&ndash;',  # put between the <inputs> of the range filter
-    :sortable => true,                  # if set, sorting-stuff is added to the header cell
-    :format_methods => []               # javascript methods to execute on this column
-  })
-
-  # defaults for the find_for_table
-  FINDER_OPTIONS = WhinyHash.new({
-    :default_order => false,
-    :precondition => false,
-    :store_data => false,
-    :name_mapping => nil,
-    :action => nil
-  })
-
-  # Stupid hack
-  SQL_OPTIONS = WhinyHash.new({
-    :like => nil
-  })
-
-  def self.finder_options(n=nil)
-    FINDER_OPTIONS.merge!(n) if n
-    FINDER_OPTIONS
-  end
-
-  def self.column_options(n=nil)
-    COLUMN_OPTIONS.merge!(n) if n
-    COLUMN_OPTIONS
-  end
-
-  def self.table_options(n=nil)
-    TABLE_OPTIONS.merge!(n) if n
-    TABLE_OPTIONS
-  end
-
-  def self.paginate_options(n=nil)
-    PAGINATE_OPTIONS.merge!(n) if n
-    PAGINATE_OPTIONS
-  end
-
-  def self.table_form_options(n=nil)
-    TABLE_FORM_OPTIONS.merge!(n) if n
-    TABLE_FORM_OPTIONS
-  end
-
-  def self.table_design_options(n=nil)
-    raise("table_design_options stopped existing. Use table_options instead.")
-  end
-  def table_design_options(n=nil) self.class.table_design_options(n) end
-
-  def self.sql_options(n=nil)
-    SQL_OPTIONS.merge!(n) if n
-    SQL_OPTIONS
-  end
-  def sql_options(n=nil) self.class.sql_options(n) end
-
-  COLUMN_PRESETS = {}
-  def self.column_presets(n=nil)
-    COLUMN_PRESETS.merge!(n) if n
-    COLUMN_PRESETS
-  end
-  def column_presets(n=nil) self.class.column_presets(n) end
-  def column_preset_for(name)
-    h = COLUMN_PRESETS[name.to_sym]
-    return {} unless h
-    return h if h.is_a? Hash
-    COLUMN_PRESETS[h] || {}
-  end
-end

data/lib/tabulatr/tabulatr.rb

@@ -1,343 +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.
-#++
-
-# Tabulatr is a class to allow easy creation of data tables as you
-# frequently find them on 'index' pages in rails. The 'table convention'
-# here is that we consider every table to consist of three parts:
-# * a header containing the names of the attribute of the column
-# * a filter which is an input element to allow for searching the
-#   particular attribute
-# * the rows with the actual data.
-#
-# Additionally, we expect that people want to 'select' rows and perform
-# batch actions on these rows.
-#
-# Author::    Peter Horn, (mailto:peter.horn@provideal.net)
-# Copyright:: Copyright (c) 2010-2011 by Provideal GmbH (http://www.provideal.net)
-# License::   MIT Licence
-class Tabulatr
-
-  include ActionView::Helpers::TagHelper
-  include ActionView::Helpers::FormTagHelper
-  include ActionView::Helpers::FormOptionsHelper
-  include ActionView::Helpers::TranslationHelper
-  include ActionView::Helpers::RecordTagHelper
-#  include ActionView::Helpers::AssetTagHelper
-#  include Rails::Application::Configurable
-
-  # Constructor of Tabulatr
-  #
-  # Parameters:
-  # <tt>klass</tt>:: the klass of the data for the table
-  # <tt>view</tt>:: the current instance of ActionView
-  # <tt>opts</tt>:: a hash of options specific for this table
-  def initialize(klass_or_record, view=nil, toptions={})
-    if klass_or_record.is_a?(Class) && klass_or_record < ActiveRecord::Base
-      @klass = klass_or_record
-      @records = nil
-    elsif klass_or_record.respond_to?(:each)
-      @records = klass_or_record
-      @klass = @records.first.try(:class)
-      toptions = toptions.merge! \
-        :filter => false,
-        :paginate => false,
-        :sortable => false
-    else
-      raise "Give a model-class or an collection to `table_for'"
-    end
-    @view = view
-    @table_options = TABLE_OPTIONS.merge(toptions)
-    @table_form_options = TABLE_FORM_OPTIONS
-    @val = []
-    @record = nil
-    @row_mode = false
-    @classname = @klass.to_s.downcase.gsub("/","_")
-    @attributes = []
-  end
-
-  cattr_accessor :bootstrap_paginator, instance_accessor: false do
-    'create_ul_paginator'
-  end
-
-  def self.config &block
-    yield self
-  end
-
-  def self.secret_tokens=(secret_tokens)
-    @@secret_tokens = secret_tokens
-  end
-
-  def self.secret_tokens
-    @@secret_tokens ||= []
-  end
-
-  # the actual table definition method. It takes an Array of records, a hash of
-  # options and a block with the actual <tt>column</tt> calls.
-  #
-  # The following options are evaluated here:
-  # <tt>:table_html</tt>:: a hash with html-attributes added to the <table> created
-  # <tt>:header_html</tt>:: a hash with html-attributes added to the <tr> created
-  #                         for the header row
-  # <tt>:filter_html</tt>:: a hash with html-attributes added to the <tr> created
-  #                         for the filter row
-  # <tt>:row_html</tt>:: a hash with html-attributes added to the <tr>s created
-  #                      for the data rows
-  # <tt>:filter</tt>:: if set to false, no filter row is output
-  def build_table(&block)
-    return nil if @records && @records.blank?
-    @val = []
-    # TODO: make_tag(:input, :type => 'submit', :style => 'display:inline; width:1px; height:1px', :value => '__submit')
-    unless @records
-      render_table_controls(:control_div_class_before, :before_table_controls)
-    end
-
-    render_element(:table, &block)
-
-    unless @records
-      render_table_controls(:control_div_class_after, :after_table_controls)
-      make_tag(:div, class: "tabulatr_count",
-        :'data-table' => "#{@klass.to_s.downcase}_table",
-        :'data-format-string' => I18n.t('tabulatr.count')){}
-
-      render_filter_dialog &block
-      sec_hash = Tabulatr::Security.sign(@attributes.join(','))
-      make_tag(:span, :id => "tabulatr_security_#{@klass.to_s.downcase}",
-        :'data-salt' => sec_hash.split('-')[1],
-        :'data-hash' => sec_hash.split('-')[2]){}
-    end
-    @val.join("").html_safe
-  end
-
-  def render_element(element, &block)
-    case element
-    when :filter then render_filter_icon
-    when :paginator then render_paginator
-    when :table then render_table &block
-    else
-      if element.is_a?(String)
-        concat(element)
-      else
-        raise "unknown element '#{element}'"
-      end
-    end
-  end
-
-
-  def render_table(&block)
-    to = @table_options[:table_html]
-    to = (to || {}).merge(:class => "#{@table_options[:table_class]} table",
-      :'data-path' => @table_options[:path], :id => "#{@klass.to_s.downcase}_table")
-    make_tag(:table, to) do
-      make_tag(:thead) do
-        render_table_header(&block)
-      end # </thead>
-      if @records
-        make_tag(:tbody) do
-          render_table_rows(&block)
-        end # </tbody>
-      else
-        make_tag(:tbody) do
-          render_empty_start_row(&block)
-        end # </tbody>
-      end
-      content_for(@table_options[:footer_content]) if @table_options[:footer_content]
-    end # </table>
-  end
-
-private
-
-  def readable_name_for(name, relation=nil)
-    if relation
-      "#{@klass.human_attribute_name(relation).titlecase}
-       #{@klass.reflect_on_association(relation).klass.
-          human_attribute_name(name).titlecase}"
-    else
-      @klass.human_attribute_name(name).titlecase
-    end
-  end
-
-  # either append to the internal string buffer or use
-  # ActionView#concat to output if an instance is available.
-  def concat(s, html_escape=false)
-    #@view.concat(s) if (Rails.version.to_f < 3.0 && @view)
-    #puts "\##{Rails.version.to_f} '#{s}'"
-    if s.present? then @val << (html_escape ? h(s) : s) end
-  end
-
-  def h(s)
-    ERB::Util.h(s)
-  end
-
-  def t(s)
-    return '' unless s.present?
-    begin
-      if s.respond_to?(:should_localize?) and s.should_localize?
-        translate(s)
-      else
-        case @should_translate
-        when :translate then translate(s)
-        when true then translate(s)
-        when :localize then localize(s)
-        else
-          if !@should_translate
-            s
-          elsif @should_translate.respond_to?(:call)
-            @should_translate.call(s)
-          else
-            raise "Wrong value '#{@should_translate}' for table option ':translate', should be false, true, :translate, :localize or a proc."
-          end
-        end
-      end
-    rescue
-      raise "Translating '#{s}' failed!"
-    end
-  end
-
-  # render the header row
-  def render_table_header(&block)
-    make_tag(:tr, @table_options[:header_html]) do
-      yield(header_row_builder)
-    end # </tr>"
-  end
-
-
-  def render_filter_options(&block)
-      yield(filter_form_builder)
-      make_tag(:input, :type => 'hidden', :name => 'sort_by')
-      make_tag(:input, :type => 'hidden', :name => 'orientation')
-  end
-
-  def render_empty_start_row(&block)
-    row_html = @table_options[:row_html] || {}
-    row_html[:class] = 'empty_row'
-    make_tag(:tr, row_html) do
-      yield empty_row_builder
-    end
-  end
-
-  def render_table_controls div_class, before_or_after
-    make_tag(:div,  :class => @table_options[div_class]) do
-      @table_options[before_or_after].each do |element|
-        render_element(element)
-      end
-    end if @table_options[before_or_after].present? # </div>
-  end
-
-  def render_filter_dialog &block
-    make_tag(:div, class: 'modal fade', id: "tabulatr_filter_dialog_#{@klass.to_s.downcase}", style: "display:none ;") do
-      make_tag(:div, class: 'modal-dialog') do
-        make_tag(:div, class: 'modal-content') do
-          make_tag(:div, class: 'modal-header') do
-            make_tag(:button, class: :close, :'data-dismiss' => :modal,
-              :'aria-hidden' => true) do
-              concat "&times"
-            end
-            make_tag(:h3, class: 'modal-title') do
-              concat I18n.t('tabulatr.filter')
-            end
-          end
-          make_tag(:form, :'data-table' => "#{@klass.to_s.downcase}_table",
-            class: 'form-horizontal tabulatr_filter_form', :'data-remote' => true) do
-            make_tag(:div, class: 'modal-body') do
-              render_filter_options &block
-            end
-            make_tag(:div, class: 'modal-footer') do
-              make_tag(:input, :type => 'submit',
-                :class => 'submit-table btn btn-primary',
-                :value => I18n.t('tabulatr.apply_filters'))
-            end
-          end
-        end # modal-content
-      end # modal-dialog
-    end # modal fade
-  end
-
-  # render the table rows, only used if records are passed
-  def render_table_rows(&block)
-    #   row_classes = @table_options[:row_classes] || []
-    #   row_html = @table_options[:row_html] || {}
-    #   row_class = row_html[:class] || ""
-    @records.each_with_index do |record, i|
-      #concat("<!-- Row #{i} -->")
-      # if row_classes.present?
-      #   rc = row_class.present? ? row_class + " " : ''
-      #   rc += row_classes[i % row_classes.length]
-      # else
-      #   rc = nil
-      # end
-      rc = nil
-      make_tag(:tr, :class => rc, :id => dom_id(record)) do
-        yield(data_row_builder(record))
-      end # </tr>
-    end
-  end
-
-  def render_table_row(&block)
-    row_html = @table_options[:row_html] || {}
-    row_html[:class] = 'empty_row'
-    make_tag(:tr, row_html) do
-      yield empty_row_builder
-    end
-  end
-
-
-  # stringly produce a tag w/ some options
-  def make_tag(name, hash={}, &block)
-    attrs = hash ? tag_options(hash) : ''
-    if block_given?
-      if name
-        concat("<#{name}#{attrs}>")
-        yield
-        concat("</#{name}>")
-      else
-        yield
-      end
-    else
-      concat("<#{name}#{attrs} />")
-    end
-    nil
-  end
-
-  def make_image_button(options)
-    inactive = options.delete(:inactive)
-    if(options['data-sort'] == 'desc')
-      icon_class = 'icon-arrow-down'
-    else
-      icon_class = 'icon-arrow-up'
-    end
-    if !inactive
-      make_tag(:i,
-        options.merge(
-          :class => "tabulatr-sort #{icon_class}"
-        )
-      )
-    else
-      make_tag(:i, :class => "tabulatr-sort #{icon_class}")
-    end
-  end
-
-end
-
-Dir[File.join(File.dirname(__FILE__), "tabulatr", "*.rb")].each do |file|
-  require file
-end