data_tables 0.1.0

data/lib/data_tables/data_tables_helper.rb

@@ -0,0 +1,116 @@
+module DataTablesHelper
+  def datatables(source, opts = {})
+
+    options = opts[:jquery] ? opts[:jquery].dup : {}
+    options[:bJQueryUI] = true unless options.has_key?(:bJQueryUI)
+    options[:bProcessing] = true unless options.has_key?(:bProcessing)
+    options[:bServerSide] = true unless options.has_key?(:bServerSide)
+    options[:bAutoWidth] = false unless options.has_key?(:bAutoWidth)
+    options[:bStateSave] = true unless options.has_key?(:bStateSave)
+    options[:oColVis] ||= {}
+    options[:oColVis][:aiExclude] ||= []
+    unless options[:oColVis][:aiExclude].include?(0)
+      options[:oColVis][:aiExclude].unshift(0)
+    end
+
+    options[:fnInitComplete] ||= "function() {
+      if (eval('typeof ' + initDatatablesTable) == 'function') {
+        initDatatablesTable('#{source}');
+      }
+    }"
+
+    sdom = '<"#datatables_search_hint">lfrtip'
+    sdom = "C<\"clear\">" + sdom if options[:oColVis]
+    sdom = 'T' + sdom if options[:oTableTools]
+    options[:sDom] ||= sdom
+
+    datatable = controller.datatable_source(source)
+    options[:sAjaxSource] = method("#{datatable[:action]}_url".to_sym).call
+    columns = datatable[:attrs].keys.collect { |a| "<th>#{a}</th>" }.join
+
+    index = 0
+    targets = datatable[:attrs].inject([]) do |memo, (column, searchable)|
+      memo << index unless searchable
+      index += 1
+      memo
+    end
+    options[:aoColumnDefs] ||= []
+    options[:aoColumnDefs].unshift({
+                                     :aTargets => targets,
+                                     :bSearchable => false,
+                                     :bSortable => false
+                                   })
+
+    if options[:html]
+      html_opts = options[:html].collect { |k,v| "#{k}=\"#{v}\"" }.join(' ')
+    end
+    pad_ao_columns(options, datatable[:attrs].keys.size)
+
+    table_header = "<tr>#{columns}</tr>"
+    html = "
+<script>
+$(document).ready(function() {
+  var oTable = $('##{datatable[:action]}').dataTable({
+#{datatables_option_string(options)}
+  });
+  $('tfoot input').keyup( function () {
+                /* Filter on the column (the index) of this element */
+                oTable.fnFilter( this.value, $('tfoot input').index(this) );
+        } );
+
+});
+</script>
+<table id=\"#{datatable[:action]}\" #{html_opts}>
+<thead>
+#{table_header}
+</thead>
+<tbody>
+</tbody>
+</table>
+"
+    return raw(html)
+  end
+end
+
+def datatables_option_string(options, indent = 4)
+  arr = []
+  options.each do |key, value|
+    if value.is_a?(String) && value[0..7] != "function"
+      arr << "#{' ' * indent}#{key}: '#{value}'"
+    elsif value.is_a?(Array)
+      indent += 2
+      item_arr = []
+      value.each do |item|
+        if item.is_a?(Hash)
+          str = "#{' ' * indent}{\n"
+          str += "#{datatables_option_string(item, indent + 2)}\n"
+          str += "#{' ' * indent}}"
+          item_arr << str
+        elsif item.is_a?(String) && item[0..7] != "function"
+          item_arr << "#{' ' * indent}'#{item}'"
+        else
+          item_arr << "#{' ' * indent}#{item}"
+        end
+      end
+      indent -= 2
+      arr << "#{' ' * indent}#{key}: [\n#{item_arr.join(",\n")}\n#{' ' * indent}]"
+    elsif value.is_a?(Hash)
+      str = "#{' ' * indent}#{key}: {\n"
+      str += "#{datatables_option_string(value, indent + 2)}\n"
+      str += "#{' ' * indent}}"
+      arr << str
+    else
+      arr << "#{' ' * indent}#{key}: #{value}"
+    end
+  end
+
+  arr.join(",\n")
+end
+
+def pad_ao_columns(options, count)
+  return unless options[:aoColumns]
+
+  (count - options[:aoColumns].size).times do
+    options[:aoColumns] << 'null'
+  end
+end

data/lib/data_tables.rb

@@ -0,0 +1,210 @@
+require 'data_tables/data_tables_helper'
+module DataTablesController
+  def self.included(cls)
+    cls.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def datatables_source(action, model,  *attrs)
+      modelCls = Kernel.const_get(model.to_s.split("_").collect(&:capitalize).join)
+      modelAttrs = nil
+      if modelCls < Ohm::Model
+        modelAttrs = Hash[*modelCls.new.attributes.collect  { |v| [v.to_s, nil] }.flatten]
+      else
+        modelAttrs = modelCls.new.attributes
+      end
+      columns = []
+      modelAttrs.each_key { |k| columns << k }
+
+      options = {}
+      attrs.each do |option|
+        option.each { |k,v| options[k] = v }
+      end
+
+      # override columns
+      columns = options_to_columns(options) if options[:columns]
+
+      # define columns so they are accessible from the helper
+      define_columns(modelCls, columns, action)
+
+      # define method that returns the data for the table
+      define_datatables_action(self, action, modelCls, columns, options)
+    end
+
+    # named_scope is a combination table that include everything shown in UI.
+    # except is the codition used for Ohm's except method, it should be key-value format,
+    # such as [['name', 'bluesocket'],['id','1']].
+    def define_datatables_action(controller, action, modelCls, columns, options = {})
+      conditions = options[:conditions] || []
+      scope = options[:scope] || :domain
+      named_scope = options[:named_scope]
+      except = options[:except]
+
+      if modelCls < Ohm::Model
+        define_method action.to_sym do
+          if scope == :domain
+            domain = ActiveRecord::Base.connection.schema_search_path.to_s.split(",")[0]
+            return if domain.nil?
+          end
+          search_condition = params[:sSearch].blank? ? nil : params[:sSearch].to_s
+          records = scope == :domain ? modelCls.find(:domain => domain) : modelCls.all
+          if except
+            except.each do |f|
+              records = records.except(f[0].to_sym => f[1])
+            end
+          end
+          total_records = records.size
+          sort_column = params[:iSortCol_0].to_i
+          sort_column = 1 if sort_column == 0
+          current_page = (params[:iDisplayStart].to_i/params[:iDisplayLength].to_i rescue 0) + 1
+          objects = nil
+          if search_condition.nil?
+            objects = records.sort_by(columns[sort_column][:name].to_sym, :order=>"ALPHA " + params[:sSortDir_0].capitalize, :limit=>params[:iDisplayLength].to_i, :start=>(params[:iDisplayStart].to_i))
+            total_display_records = total_records
+          else
+            options = {}
+            domain_id = domain.split("_")[1].to_i if scope == :domain
+            options[:domain] = domain_id .. domain_id if scope == :domain
+            options[:fuzzy] = {columns[sort_column][:name].to_sym => search_condition}
+            objects = Lunar.search(modelCls, options)
+            total_display_records = objects.size
+            objects = objects.sort(:by => columns[sort_column][:name].to_sym, :order=>"ALPHA " + params[:sSortDir_0].capitalize, :limit=>params[:iDisplayLength].to_i, :start=>(params[:iDisplayStart].to_i))
+          end
+          data = objects.collect do |instance|
+            columns.collect { |column| datatables_instance_get_value(instance, column) }
+          end
+          render :text => {:iTotalRecords => total_records,
+            :iTotalDisplayRecords => total_display_records,
+            :aaData => data,
+            :sEcho => params[:sEcho].to_i}.to_json
+        end
+      else
+        # add_search_option will determine whether the search text is empty or not
+        init_conditions = conditions.clone
+        add_search_option = false
+        define_method action.to_sym do
+          condition_local = ''
+          unless params[:sSearch].blank?
+            sort_column_id = params[:iSortCol_0].to_i
+            sort_column_id = 1 if sort_column_id == 0
+            sort_column = columns[sort_column_id]
+            if sort_column && sort_column.has_key?(:attribute)
+              condstr = params[:sSearch].gsub(/_/, '\\\\_').gsub(/%/, '\\\\%')
+              condition_local = "(text(#{sort_column[:name]}) ILIKE '#{condstr}%')"
+            end 
+          end
+
+          # We just need one conditions string for search at a time.  Every time we input
+          # something else in the search bar we will pop the previous search condition
+          # string and push the new string.
+          if condition_local != ''
+            if add_search_option == false
+              conditions << condition_local
+              add_search_option = true
+            else
+              if conditions != []
+                conditions.pop
+                conditions << condition_local
+              end
+            end
+          else
+            if add_search_option == true
+              if conditions != []
+                conditions.pop
+                add_search_option = false
+              end
+            end
+          end
+
+          if named_scope
+            total_records = modelCls.send(named_scope).count :conditions => init_conditions.join(" AND ")
+            total_display_records = modelCls.send(named_scope).count :conditions => conditions.join(" AND ")
+          else
+            total_records = modelCls.count :conditions => init_conditions.join(" AND ")
+            total_display_records = modelCls.count :conditions => conditions.join(" AND ")
+          end
+          sort_column = params[:iSortCol_0].to_i
+          sort_column = 1 if sort_column == 0
+          current_page = (params[:iDisplayStart].to_i/params[:iDisplayLength].to_i rescue 0)+1
+          if named_scope
+              objects = modelCls.send(named_scope).paginate(:page => current_page,
+                                          :order => "#{columns[sort_column][:name]} #{params[:sSortDir_0]}",
+                                          :conditions => conditions.join(" AND "),
+                                          :per_page => params[:iDisplayLength])
+          else
+              objects = modelCls.paginate(:page => current_page,
+                                          :order => "#{columns[sort_column][:name]} #{params[:sSortDir_0]}",
+                                          :conditions => conditions.join(" AND "),
+                                          :per_page => params[:iDisplayLength])
+          end
+          #logger.info("------conditions is #{conditions}")
+          data = objects.collect do |instance|
+            columns.collect { |column| datatables_instance_get_value(instance, column) }
+          end
+          render :text => {:iTotalRecords => total_records,
+            :iTotalDisplayRecords => total_display_records,
+            :aaData => data,
+            :sEcho => params[:sEcho].to_i}.to_json
+        end
+      end
+    end
+
+    private
+
+    #
+    # Takes a list of columns from options and transforms them
+    #
+    def options_to_columns(options)
+      columns = []
+      options[:columns].each do |column|
+        if column.kind_of? Symbol # a column from the database, we don't need to do anything
+          columns << {:name => column, :attribute => column}
+        elsif column.kind_of? Hash
+          columns << {:name => column[:name], :special => column}
+        end
+      end
+      columns
+    end
+
+    def define_columns(cls, columns, action)
+      define_method "datatable_#{action}_columns".to_sym do
+        columnNames = {}
+        columns.each do |column|
+          columnName = ''
+          if column[:method] or column[:eval]
+            columnName << I18n.t(column[:name], :default => column[:name].to_s)
+          else
+            columnName << I18n.t(column[:name].to_sym, :default => column[:name].to_s)
+          end
+          columnName << ' *' unless column.has_key?(:attribute)
+          columnNames[columnName] = column.has_key?(:attribute) ? true : false
+        end
+
+        columnNames
+      end
+    end
+  end
+
+  # gets the value for a column and row
+  def datatables_instance_get_value(instance, column)
+    if column[:attribute]
+      val = instance.send(column[:attribute].to_sym)
+      return I18n.t(val.to_s.to_sym, :default => val.to_s) if not val.blank?
+      return ''
+    elsif column[:special]
+      special = column[:special]
+
+      if special[:method]
+        return method(special[:method].to_sym).call(instance)
+      elsif special[:eval]
+        proc = lambda { obj = instance; binding }
+        return Kernel.eval(special[:eval], proc.call)
+      end
+    end
+    return "value not found"
+  end
+
+  def datatable_source(name)
+    {:action => name, :attrs => method("datatable_#{name}_columns".to_sym).call}
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: data_tables
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Duane Compton
+- Calvin Bascom
+- Yi Su
+- Chris Moos
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-10 00:00:00.000000000 Z
+dependencies: []
+description: Originally a plugin
+email: Duane.Compton@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/data_tables.rb
+- lib/data_tables/data_tables_helper.rb
+homepage: http://rubygems.org/gems/data_tables
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rails friendly interface into DataTables
+test_files: []