add set_model_class method for setup custom model class name

Author: M. Saiqul Haq

README.md

@@ -87,7 +87,6 @@ end
 * For `paginator options`, just uncomment the paginator you would like to use, given
 the gems bundled in your project. For example, if your models are using `Kaminari`, uncomment `AjaxDatatablesRails::Extensions::Kaminari`. You may remove all commented lines.
   * `SimplePaginator` is the most basic of them all, it falls back to passing `offset` and `limit` at the database level (through `ActiveRecord` of course, as that is the only ORM supported for the time being).
-
 * For `sortable_columns`, assign an array of the database columns that correspond to the columns in our view table. For example `[users.f_name, users.l_name, users.bio]`. This array is used for sorting by various columns.
 
 * For `searchable_columns`, assign an array of the database columns that you want searchable by datatables. For example `[users.f_name, users.l_name]`
@@ -230,6 +229,39 @@ So the query using the `.includes()` method is:
   end
 ```
 
+#### NOTE for model class that different from table name 
+currently model class name detected by singularize the table name 
+so if your table name is different, or you have namespaced model, you should set the model name like this 
+
+create the `setup` method (`setup` method will be executed when AjaxDatatablesRails class initialized)
+
+then create `set_model_class` block inside `setup` method
+
+```ruby
+def setup
+  set_model_class do |klass|
+    klass.users = Employee
+  end
+end
+``` 
+now you can use `users.name` at `sortable_columns` and `searchable_columns` methods 
+```ruby
+@sortable_columns ||= [ 'users.name']
+```
+
+##### TIPS, you can use above step to abbreviate long namespaced model 
+```ruby
+def setup
+  set_model_class do |klass|
+    klass.requests = Statistics::Request
+      klass.sessions = Statistics::Session
+  end
+end
+def searchable_columns
+  @sortable_columns ||= [ 'requests.foo', 'sessions.bar']
+end
+```
+
 ### Controller
 Set up the controller to respond to JSON
 

ajax-datatables-rails.gemspec

@@ -24,12 +24,13 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "generator_spec"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "activerecord", "~> 4.l.6"
   gem.add_development_dependency "sqlite3"
 
   if RUBY_VERSION == '1.9.2'
     gem.add_development_dependency "rails", "3.1.0"
+    gem.add_development_dependency "activerecord", "3.1.0"
   else
     gem.add_development_dependency "rails", ">= 3.1.0"
+    gem.add_development_dependency "activerecord", ">= 4.1.6"
   end
 end

lib/ajax-datatables-rails.rb

@@ -1,5 +1,6 @@
 require 'ajax-datatables-rails/version'
 require 'ajax-datatables-rails/config'
+require 'ajax-datatables-rails/models'
 require 'ajax-datatables-rails/base'
 require 'ajax-datatables-rails/extensions/simple_paginator'
 require 'ajax-datatables-rails/extensions/kaminari'

lib/ajax-datatables-rails/base.rb

@@ -9,6 +9,19 @@ class MethodNotImplementedError < StandardError; end
     def initialize(view, options = {})
       @view = view
       @options = options
+      setup
+    end
+
+    def set_model_class
+      @models ||= AjaxDatatablesRails::Models.new
+      yield @models
+    end
+
+    def setup
+    end
+
+    def models
+      @models
     end
 
     def config
@@ -104,13 +117,11 @@ def build_conditions_for(query)
 
     def search_condition(column, value)
       model, column = column.split('.')
-      if model.scan("_").any?
-        model = model.singularize.titleize.gsub( / /, '::' ).constantize
-      else
-        model = model.singularize.titleize.gsub( / /, '' ).constantize
-      end
+      model_class = model.singularize.titleize.gsub( / /, '' ).safe_constantize
+      model_class = models[model] if model_class.nil?
+      raise("Model with class name #{model} not found") if model_class.nil?
 
-      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
+      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model_class.arel_table[column.to_sym].as(typecast)])
       casted_column.matches("%#{value}%")
     end
 

lib/ajax-datatables-rails/models.rb

@@ -0,0 +1,6 @@
+require 'active_support/ordered_options'
+
+module AjaxDatatablesRails
+  class Models < ActiveSupport::OrderedOptions
+  end
+end

spec/ajax-datatables-rails/ajax_datatables_rails_spec.rb

@@ -120,25 +120,57 @@
       end
     end
 
-    describe "#search_condition" do
-      let(:datatable) { AjaxDatatablesRails::Base.new(view) }
+    describe "#configure" do
+      let(:datatable) do
+        class FooDatatable < AjaxDatatablesRails::Base
+          def setup
+            set_model_class do |klass|
+              klass.users = User
+              klass.requests = Statistics::Request
+              klass.purchased_orders = PurchasedOrder
+              klass.statistics_sessions = Statistics::Session
+            end
+          end
+        end
+
+        FooDatatable.new view
+      end
 
-      context "normal model" do
-        it "should return arel object" do
-          expect(datatable.send(:search_condition, 'users.bar', 'bar').class).to eq(Arel::Nodes::Matches)
+      context "when model class name is regular" do
+        it "should successfully get right model class" do
+          datatable.send(:search_condition, 'users.bar', 'bar')
+          expect(datatable.models.users).to eq(User)
         end
       end
 
-      context "namespaced model" do
-        it "should return arel object" do
-          expect(datatable.send(:search_condition, 'statistics_sessions.bar', 'bar').class).to eq(Arel::Nodes::Matches)
+      context "when custom named model class" do
+        it "should successfully get right model class" do
+          expect(datatable.send(:search_condition, 'requests.bar', 'bar').class)
+          .to eq(Arel::Nodes::Matches)
         end
       end
 
-      it "should raise uninitialized constant if column not exist" do
-        expect {
-          datatable.send(:search_condition, 'asdusers.bar', 'bar').class
-        }.to raise_error(/uninitialized constant/)
+
+      context "when model class name camelcased" do
+        it "should successfully get right model class" do
+          expect(datatable.send(:search_condition, 'purchased_orders.bar', 'bar').class)
+          .to eq(Arel::Nodes::Matches)
+        end
+      end
+
+      context "when model class name is namespaced" do
+        it "should successfully get right model class" do
+          expect(datatable.send(:search_condition, 'statistics_sessions.bar', 'bar').class)
+          .to eq(Arel::Nodes::Matches)
+        end
+      end
+
+      context "when model class defined but not found" do
+        it "raise 'uninitialized constant'" do
+          expect {
+            datatable.send(:search_condition, 'non_existed_model.bar', 'bar')
+          }.to raise_error(RuntimeError, /not found/)
+        end
       end
     end
 

spec/ajax-datatables-rails/models_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails::Models do
+  let(:models){ AjaxDatatablesRails::Models.new }
+
+  it "is configurable" do
+    models.user = User
+    expect(models.user).to eq(User)
+  end
+end

spec/schema.rb

@@ -13,6 +13,12 @@
     t.timestamps
   end
 
+  create_table :purchased_orders, :force => true do |t|
+    t.string :foo
+    t.string :bar
+
+    t.timestamps
+  end
 
   create_table :statistics_requests, :force => true do |t|
     t.string :baz

spec/spec_helper.rb

@@ -6,4 +6,4 @@
 ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
 
 load File.dirname(__FILE__) + '/schema.rb'
-require File.dirname(__FILE__) + '/models.rb'
+require File.dirname(__FILE__) + '/test_models.rb'

spec/models.rb renamed to spec/test_models.rb

@@ -2,6 +2,10 @@ class User < ActiveRecord::Base
 end
 
 class UserData < ActiveRecord::Base
+  self.table_name = "user_data"
+end
+
+class PurchasedOrder < ActiveRecord::Base
 end
 
 module Statistics