ajax-datatables-rails 0.3.1 → 0.4.0

data/lib/generators/rails/templates/datatable.rb

@@ -1,29 +1,41 @@
-class <%= @datatable_name %>Datatable < AjaxDatatablesRails::Base
+class <%= datatable_name %> < AjaxDatatablesRails::Base
 
-  def sortable_columns
+  def view_columns
     # Declare strings in this format: ModelName.column_name
-    @sortable_columns ||= []
+    # or in aliased_join_table.column_name format
+    @view_columns ||= {
+      # id: { source: "User.id", cond: :eq },
+      # name: { source: "User.name", cond: :like }
+    }
   end
 
-  def searchable_columns
-    # Declare strings in this format: ModelName.column_name
-    @searchable_columns ||= []
-  end
-
-  private
-
   def data
     records.map do |record|
-      [
-        # comma separated list of the values for each cell of a table row
-        # example: record.attribute,
-      ]
+      {
+        # example:
+        # id: record.id,
+        # name: record.name
+      }
     end
   end
 
+  private
+
   def get_raw_records
     # insert query here
   end
 
+  # ==== These methods represent the basic operations to perform on records
+  # and feel free to override them
+
+  # def filter_records(records)
+  # end
+
+  # def sort_records(records)
+  # end
+
+  # def paginate_records(records)
+  # end
+
   # ==== Insert 'presenter'-like methods below if necessary
 end

data/spec/ajax-datatables-rails/base_spec.rb

@@ -0,0 +1,190 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails::Base do
+
+  describe 'an instance' do
+    let(:view) { double('view', params: sample_params) }
+
+    it 'requires a view_context' do
+      expect { AjaxDatatablesRails::Base.new }.to raise_error ArgumentError
+    end
+
+    it 'accepts an options hash' do
+      datatable = AjaxDatatablesRails::Base.new(view, foo: 'bar')
+      expect(datatable.options).to eq(foo: 'bar')
+    end
+  end
+
+  context 'Public API' do
+    let(:view) { double('view', params: sample_params) }
+    let(:datatable) { AjaxDatatablesRails::Base.new(view) }
+
+    describe '#view_columns' do
+      it 'raises an error if not defined by the user' do
+        expect { datatable.view_columns }.to raise_error AjaxDatatablesRails::NotImplemented
+      end
+
+      context 'child class implements view_columns' do
+        it 'expects an array based defining columns' do
+          datatable = SampleDatatable.new(view)
+          expect(datatable.view_columns).to be_a(Array)
+        end
+
+        it 'expects a hash based defining columns' do
+          datatable = ComplexDatatable.new(view)
+          expect(datatable.view_columns).to be_a(Hash)
+        end
+      end
+    end
+
+    describe '#get_raw_records' do
+      it 'raises an error if not defined by the user' do
+        expect { datatable.get_raw_records }.to raise_error AjaxDatatablesRails::NotImplemented
+      end
+    end
+
+    describe '#data' do
+      it 'raises an error if not defined by the user' do
+        expect { datatable.data }.to raise_error AjaxDatatablesRails::NotImplemented
+      end
+
+      context 'when data is defined as a hash' do
+        it 'should return an array of hashes' do
+          datatable = ComplexDatatableHash.new(view)
+          create_list(:user, 5)
+          expect(datatable.data).to be_a(Array)
+          expect(datatable.data.size).to eq 5
+          item = datatable.data.first
+          expect(item).to be_a(Hash)
+        end
+
+        it 'should html escape data' do
+          datatable = ComplexDatatableHash.new(view)
+          create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
+          data = datatable.send(:sanitize, datatable.data)
+          item = data.first
+          expect(item[:first_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
+          expect(item[:last_name]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
+        end
+      end
+
+      context 'when data is defined as a array' do
+        it 'should return an array of arrays' do
+          datatable = ComplexDatatableArray.new(view)
+          create_list(:user, 5)
+          expect(datatable.data).to be_a(Array)
+          expect(datatable.data.size).to eq 5
+          item = datatable.data.first
+          expect(item).to be_a(Array)
+        end
+
+        it 'should html escape data' do
+          datatable = ComplexDatatableArray.new(view)
+          create(:user, first_name: 'Name "><img src=x onerror=alert("first_name")>', last_name: 'Name "><img src=x onerror=alert("last_name")>')
+          data = datatable.send(:sanitize, datatable.data)
+          item = data.first
+          expect(item[2]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;first_name&quot;)&gt;'
+          expect(item[3]).to eq 'Name &quot;&gt;&lt;img src=x onerror=alert(&quot;last_name&quot;)&gt;'
+        end
+      end
+    end
+
+    describe '#as_json' do
+      it 'should return a hash' do
+        datatable = ComplexDatatableHash.new(view)
+        create_list(:user, 5)
+        data = datatable.as_json
+        expect(data[:recordsTotal]).to eq 5
+        expect(data[:recordsFiltered]).to eq 5
+        expect(data[:data]).to be_a(Array)
+        expect(data[:data].size).to eq 5
+      end
+
+      context 'with additional_datas' do
+        it 'should return a hash' do
+          datatable = ComplexDatatableHash.new(view)
+          create_list(:user, 5)
+          expect(datatable).to receive(:additional_datas){ { foo: 'bar' } }
+          data = datatable.as_json
+          expect(data[:recordsTotal]).to eq 5
+          expect(data[:recordsFiltered]).to eq 5
+          expect(data[:data]).to be_a(Array)
+          expect(data[:data].size).to eq 5
+          expect(data[:foo]).to eq 'bar'
+        end
+      end
+    end
+  end
+
+
+  context 'Private API' do
+
+    let(:view) { double('view', params: sample_params) }
+    let(:datatable) { ComplexDatatable.new(view) }
+
+    before(:each) do
+      allow_any_instance_of(AjaxDatatablesRails::Configuration).to receive(:orm) { nil }
+    end
+
+    describe '#fetch_records' do
+      it 'raises an error if it does not include an ORM module' do
+        expect { datatable.send(:fetch_records) }.to raise_error NoMethodError
+      end
+    end
+
+    describe '#filter_records' do
+      it 'raises an error if it does not include an ORM module' do
+        expect { datatable.send(:filter_records) }.to raise_error NoMethodError
+      end
+    end
+
+    describe '#sort_records' do
+      it 'raises an error if it does not include an ORM module' do
+        expect { datatable.send(:sort_records) }.to raise_error NoMethodError
+      end
+    end
+
+    describe '#paginate_records' do
+      it 'raises an error if it does not include an ORM module' do
+        expect { datatable.send(:paginate_records) }.to raise_error NoMethodError
+      end
+    end
+
+    describe 'helper methods' do
+      describe '#offset' do
+        it 'defaults to 0' do
+          default_view = double('view', params: {})
+          datatable = AjaxDatatablesRails::Base.new(default_view)
+          expect(datatable.datatable.send(:offset)).to eq(0)
+        end
+
+        it 'matches the value on view params[:start] minus 1' do
+          paginated_view = double('view', params: { start: '11' })
+          datatable = AjaxDatatablesRails::Base.new(paginated_view)
+          expect(datatable.datatable.send(:offset)).to eq(10)
+        end
+      end
+
+      describe '#page' do
+        it 'calculates page number from params[:start] and #per_page' do
+          paginated_view = double('view', params: { start: '11' })
+          datatable = AjaxDatatablesRails::Base.new(paginated_view)
+          expect(datatable.datatable.send(:page)).to eq(2)
+        end
+      end
+
+      describe '#per_page' do
+        it 'defaults to 10' do
+          datatable = AjaxDatatablesRails::Base.new(view)
+          expect(datatable.datatable.send(:per_page)).to eq(10)
+        end
+
+        it 'matches the value on view params[:length]' do
+          other_view = double('view', params: { length: 20 })
+          datatable = AjaxDatatablesRails::Base.new(other_view)
+          expect(datatable.datatable.send(:per_page)).to eq(20)
+        end
+      end
+    end
+  end
+end

data/spec/ajax-datatables-rails/configuration_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails do
+  describe 'configurations' do
+    context 'configurable from outside' do
+      before(:each) do
+        AjaxDatatablesRails.configure do |config|
+          config.db_adapter = :mysql
+        end
+      end
+
+      it 'should have custom value' do
+        expect(AjaxDatatablesRails.config.db_adapter).to eq(:mysql)
+      end
+    end
+  end
+end
+
+describe AjaxDatatablesRails::Configuration do
+  let(:config) { AjaxDatatablesRails::Configuration.new }
+
+  describe 'default config' do
+    it 'default orm should :active_record' do
+      expect(config.orm).to eq(:active_record)
+    end
+
+    it 'default db_adapter should :postgresql' do
+      expect(config.db_adapter).to eq(:postgresql)
+    end
+  end
+
+  describe 'custom config' do
+    it 'should accept db_adapter custom value' do
+      config.db_adapter = :mysql
+      expect(config.db_adapter).to eq(:mysql)
+    end
+
+    it 'accepts a custom orm value' do
+      config.orm = :mongoid
+      expect(config.orm).to eq(:mongoid)
+    end
+  end
+end

data/spec/ajax-datatables-rails/datatable/column_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails::Datatable::Column do
+
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view) }
+
+  describe 'username column' do
+
+    let(:column) { datatable.datatable.columns.first }
+
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'username', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'searchvalue', 'regex'=>'false'}}}
+    end
+
+    it 'should be orderable' do
+      expect(column.orderable?).to eq(true)
+    end
+
+    it 'should be searchable' do
+      expect(column.searchable?).to eq(true)
+    end
+
+    it 'should be searched' do
+      expect(column.searched?).to eq(true)
+    end
+
+    it 'should have connected to id column' do
+      expect(column.data).to eq('username')
+    end
+
+    describe '#search' do
+      it 'child class' do
+        expect(column.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
+      end
+
+      it 'should have search value' do
+        expect(column.search.value).to eq('searchvalue')
+      end
+
+      it 'should not regex' do
+        expect(column.search.regexp?).to eq false
+      end
+    end
+
+    describe '#cond' do
+      it 'should be :like by default' do
+        expect(column.cond).to eq(:like)
+      end
+    end
+
+    describe '#source' do
+      it 'should be :like by default' do
+        expect(column.source).to eq('User.username')
+      end
+    end
+
+    describe '#search_query' do
+      it 'should buld search query' do
+        expect(column.search_query.to_sql).to include('%searchvalue%')
+      end
+    end
+
+    describe '#sort_query' do
+      it 'should build sort query' do
+        expect(column.sort_query).to eq('users.username')
+      end
+    end
+
+    describe '#use_regex?' do
+      it 'should be true by default' do
+        expect(column.use_regex?).to be true
+      end
+    end
+
+    describe '#delimiter' do
+      it 'should be - by default' do
+        expect(column.delimiter).to eq('-')
+      end
+    end
+  end
+
+  describe 'last_name column' do
+    let(:column) { datatable.datatable.columns.last }
+
+    before do
+      datatable.params[:columns] = {'0'=>{'data'=>'last_name', 'name'=>'', 'searchable'=>'true', 'orderable'=>'true', 'search'=>{'value'=>'', 'regex'=>'false'}}}
+    end
+
+    it 'should be orderable' do
+      expect(column.orderable?).to eq(true)
+    end
+
+    it 'should be searchable' do
+      expect(column.searchable?).to eq(true)
+    end
+
+    it 'should have connected to id column' do
+      expect(column.data).to eq('last_name')
+    end
+
+    describe '#formater' do
+      it 'should be a proc' do
+        expect(column.formater).to be_a(Proc)
+      end
+    end
+  end
+
+end

data/spec/ajax-datatables-rails/datatable/datatable_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe AjaxDatatablesRails::Datatable::Datatable do
+
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view).datatable }
+  let(:order_option) { {'0'=>{'column'=>'0', 'dir'=>'asc'}, '1'=>{'column'=>'1', 'dir'=>'desc'}} }
+
+  describe 'order methods' do
+    it 'should be orderable' do
+      expect(datatable.orderable?).to eq(true)
+    end
+
+    it 'should not be orderable' do
+      datatable.options[:order] = nil
+      expect(datatable.orderable?).to eq(false)
+    end
+
+    it 'should have 2 orderable columns' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.count).to eq(2)
+    end
+
+    it 'first column ordered by ASC' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.first.direction).to eq('ASC')
+    end
+
+    it 'first column ordered by DESC' do
+      datatable.options[:order] = order_option
+      expect(datatable.orders.last.direction).to eq('DESC')
+    end
+
+    it 'child class' do
+      expect(datatable.orders.first).to be_a(AjaxDatatablesRails::Datatable::SimpleOrder)
+    end
+  end
+
+  describe 'search methods' do
+    it 'should be searchable' do
+      datatable.options[:search][:value] = 'atom'
+      expect(datatable.searchable?).to eq(true)
+    end
+
+    it 'should not be searchable' do
+      datatable.options[:search][:value] = nil
+      expect(datatable.searchable?).to eq(false)
+    end
+
+    it 'child class' do
+      expect(datatable.search).to be_a(AjaxDatatablesRails::Datatable::SimpleSearch)
+    end
+  end
+
+  describe 'columns methods' do
+    it 'should have 4 columns' do
+      expect(datatable.columns.count).to eq(6)
+    end
+
+    it 'child class' do
+      expect(datatable.columns.first).to be_a(AjaxDatatablesRails::Datatable::Column)
+    end
+  end
+
+  describe 'option methods' do
+    before :each do
+      datatable.options[:start] = '50'
+      datatable.options[:length] = '15'
+    end
+
+    it 'paginate?' do
+      expect(datatable.paginate?).to be(true)
+    end
+
+    it 'offset' do
+      expect(datatable.offset).to eq(45)
+    end
+
+    it 'page' do
+      expect(datatable.page).to eq(4)
+    end
+
+    it 'per_page' do
+      expect(datatable.per_page).to eq(15)
+    end
+  end
+end