Added support for belongs_to columns. Version 0.3.16

matt-riemer · matt-riemer · commit 83df1d2ed146 · 2014-11-18T16:20:47.000-07:00
diff --git a/README.md b/README.md
@@ -140,6 +140,8 @@ module Effective
 
       table_column :updated_at, :proc => Proc.new { |post| nicetime(post.updated_at) } # just a standard helper as defined in helpers/application_helper.rb
 
+      table_column :user
+
       table_column :post_category_id, :filter => {:type => :select, :values => Proc.new { PostCategory.all } } do |post|
         post.post_category.name.titleize
       end
@@ -214,6 +216,16 @@ table_column :stripe_customer_id, :column => 'customers.stripe_customer_id'
 # Any SQL used to search this field will take the form of
 # "to_char(#{column} AT TIME ZONE 'GMT', 'YYYY-MM-DD HH24:MI') ILIKE '%?%'"
 table_column :created_at
+
+# If the name of the table column matches a belongs_to in our collection's main class
+# This column will be detected as a belongs_to and some predefined filters will be set up
+# So declaring the following
+table_column :user
+
+# Will have the same behaviour as declaring
+table_column :user_id, :if => Proc.new { attributes[:user_id].blank? }, :filter => {:type => :select, :values => Proc.new { User.all.map { |user| [user.id, user.to_s] }.sort { |x, y| x[1] <=> y[1] } } } do |post|
+  post.user.to_s
+end
 ```
 
 All table_columns are :visible => true, :sortable => true by default.
@@ -398,14 +410,16 @@ end
 and/or your table_column definition:
 
 ```ruby
-table_column :user, :if => Proc.new { attributes[:user_id].blank? }
+table_column :user_id, :if => Proc.new { attributes[:user_id].blank? } do |post|
+  post.user.email
+end
 ```
 
 ## Array Backed collection
 
 Don't want to use ActiveRecord? Not a problem.
 
-Define your collection as an Array of Arrays, and only array_columns, everything works as expected.
+Define your collection as an Array of Arrays, declare only array_columns, and everything works as expected.
 
 ```ruby
 module Effective
@@ -440,13 +454,13 @@ The finalize method provides a hook to process the final collection as an Array
 
 This final collection is available after searching, sorting and pagination.
 
-I can't think of any reason you would actually need or want this:
+As you have full control over the table_column presentation, I can't think of any reason you would actually need or want this:
 
 ```ruby
 def finalize(collection)
   collection.each do |row|
-    row.each do |col|
-      col.gsub!('horse', 'force') if col.kind_of?(String)
+    row.each do |column|
+      column.gsub!('horse', 'force') if column.kind_of?(String)
     end
   end
 end
diff --git a/app/models/effective/datatable.rb b/app/models/effective/datatable.rb
@@ -216,6 +216,8 @@ def arrayize(collection)
             view.instance_exec(obj, collection, self, &opts[:block])
           elsif opts[:proc]
             view.instance_exec(obj, collection, self, &opts[:proc])
+          elsif opts[:type] == :belongs_to
+            val = (obj.send(name) rescue nil).to_s
           else
             val = (obj.send(name) rescue nil)
             val = (obj[opts[:index]] rescue nil) if val == nil
@@ -266,9 +268,27 @@ def table_columns_with_defaults
 
     def initalize_table_columns(cols)
       sql_table = (collection.table rescue nil)
+
+      # Here we identify all belongs_to associations and build up a Hash like:
+      # {:user => {:foreign_key => 'user_id', :klass => User}, :order => {:foreign_key => 'order_id', :klass => Effective::Order}}
+      belong_tos = (collection.ancestors.first.reflect_on_all_associations(:belongs_to) rescue []).inject(HashWithIndifferentAccess.new()) do |retval, bt|
+        klass = bt.klass || (bt.foreign_type.gsub('_type', '').classify.safe_constantize rescue nil)
+
+        if bt.foreign_key.present? && klass.present?
+          retval[bt.name] = {:foreign_key => bt.foreign_key, :klass => klass} # Set the value into our Hash
+        end
+
+        retval
+      end
+
       index = -1
 
       cols.each do |name, _|
+        # If this is a belongs_to, add an :if clause specifying a collection scope if
+        if belong_tos.key?(name)
+          cols[name][:if] ||= Proc.new { attributes[belong_tos[name][:foreign_key]].blank? } # :if => Proc.new { attributes[:user_id].blank? }
+        end
+
         # If an :if => ... option is passed, evaluate it now.
         # if the value is false, skip setting up this table_column and ensure col[name][:index] is nil
         # in table_column_with_defaults, we will select only table columns with an index
@@ -277,27 +297,28 @@ def initalize_table_columns(cols)
           next
         end
 
-        sql_column = (collection.columns rescue []).find { |column| column.name == name.to_s }
+        sql_column = (collection.columns rescue []).find do |column|
+          column.name == name.to_s || (belong_tos.key?(name) && column.name == belong_tos[name][:foreign_key])
+        end
 
         cols[name][:index] = (index += 1)  # So first one is assigned 0
         cols[name][:array_column] ||= false
 
         cols[name][:name] ||= name
         cols[name][:label] ||= name.titleize
         cols[name][:column] ||= (sql_table && sql_column) ? "\"#{sql_table.name}\".\"#{sql_column.name}\"" : name
-        cols[name][:type] ||= sql_column.try(:type) || :string
+        cols[name][:type] ||= (belong_tos.key?(name) ? :belongs_to : sql_column.try(:type)).presence || :string
         cols[name][:width] ||= nil
         cols[name][:sortable] = true if cols[name][:sortable] == nil
-        cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type])
+        cols[name][:filter] = initialize_table_column_filter(cols[name][:filter], cols[name][:type], belong_tos[name])
 
         if cols[name][:partial]
           cols[name][:partial_local] ||= (sql_table.try(:name) || cols[name][:partial].split('/').last(2).first.presence || 'obj').singularize.to_sym
         end
       end
-
     end
 
-    def initialize_table_column_filter(filter, col_type)
+    def initialize_table_column_filter(filter, col_type, belongs_to)
       return {:type => :null, :when_hidden => false} if filter == false
 
       if filter.kind_of?(Symbol)
@@ -309,6 +330,12 @@ def initialize_table_column_filter(filter, col_type)
       end
 
       case col_type # null, number, select, number-range, date-range, checkbox, text(default)
+      when :belongs_to
+        {
+          :type => :select,
+          :when_hidden => false,
+          :values => Proc.new { belongs_to[:klass].all.map { |obj| [obj.id, obj.to_s] }.sort { |x, y| x[1] <=> y[1] } }
+        }.merge(filter)
       when :integer
         {:type => :number, :when_hidden => false}.merge(filter)
       when :boolean
diff --git a/lib/effective_datatables/version.rb b/lib/effective_datatables/version.rb
@@ -1,3 +1,3 @@
 module EffectiveDatatables
-  VERSION = "0.3.15"
+  VERSION = "0.3.16"
 end
