datatables-net 0.4.0

data/lib/ajax-datatables-rails/datatable/simple_search.rb

@@ -0,0 +1,19 @@
+module AjaxDatatablesRails
+  module Datatable
+    class SimpleSearch
+      attr_reader :options
+
+      def initialize options
+        @options = options || {}
+      end
+
+      def value
+        options[:value]
+      end
+
+      def regexp?
+        options[:regex] == TRUE_VALUE
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/orm/active_record.rb

@@ -0,0 +1,52 @@
+module AjaxDatatablesRails
+  module ORM
+    module ActiveRecord
+
+      def fetch_records
+        get_raw_records
+      end
+
+      def filter_records records
+        records.where(build_conditions)
+      end
+
+      def sort_records records
+        sort_by = datatable.orders.inject([]) do |queries, order|
+          column = order.column
+          queries << order.query(column.sort_query) if column
+        end
+        records.order(sort_by.join(", "))
+      end
+
+      def paginate_records records
+        records.offset(datatable.offset).limit(datatable.per_page)
+      end
+
+      # ----------------- SEARCH HELPER METHODS --------------------
+
+      def build_conditions
+        if datatable.searchable?
+          build_conditions_for_datatable
+        else
+          build_conditions_for_selected_columns
+        end
+      end
+
+      def build_conditions_for_datatable
+        search_for = datatable.search.value.split(' ')
+        criteria = search_for.inject([]) do |criteria, atom|
+          search = Datatable::SimpleSearch.new({ value: atom, regex: datatable.search.regexp? })
+          criteria << searchable_columns.map do |simple_column|
+            simple_column.search = search
+            simple_column.search_query
+          end.reduce(:or)
+        end.reduce(:and)
+        criteria
+      end
+
+      def build_conditions_for_selected_columns
+        search_columns.map(&:search_query).reduce(:and)
+      end
+    end
+  end
+end

data/lib/ajax-datatables-rails/version.rb

@@ -0,0 +1,3 @@
+module AjaxDatatablesRails
+  VERSION = '0.4.0'
+end

data/lib/generators/datatable/config_generator.rb

@@ -0,0 +1,17 @@
+require 'rails/generators'
+
+module Datatable
+  module Generators
+    class ConfigGenerator < ::Rails::Generators::Base
+      source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+      desc <<DESC
+Description:
+  Creates an initializer file for AjaxDatatablesRails configuration at config/initializers.
+DESC
+
+      def copy_config_file
+        template 'ajax_datatables_rails_config.rb', 'config/initializers/ajax_datatables_rails.rb'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+AjaxDatatablesRails.configure do |config|
+  # available options for db_adapter are: :pg, :mysql, :mysql2, :sqlite, :sqlite3, :oracle
+  # config.db_adapter = :pg
+
+  # available options for orm are: :active_record, :mongoid
+  # config.orm = :active_record
+end

data/lib/generators/rails/datatable_generator.rb

@@ -0,0 +1,27 @@
+require 'rails/generators'
+
+module Rails
+  module Generators
+    class DatatableGenerator < ::Rails::Generators::Base
+      desc 'Creates a *_datatable model in the app/datatables directory.'
+      source_root File.expand_path('../templates', __FILE__)
+      argument :name, type: :string
+
+      def generate_datatable
+        template 'datatable.rb', File.join(
+          'app/datatables', "#{datatable_path}.rb"
+        )
+      end
+
+      def datatable_name
+        datatable_path.classify
+      end
+
+      private
+      def datatable_path
+        "#{name.underscore}_datatable"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+class <%= datatable_name %> < AjaxDatatablesRails::Base
+
+  def view_columns
+    # Declare strings in this format: ModelName.column_name
+    # or in aliased_join_table.column_name format
+    @view_columns ||= {
+      # id: { source: "User.id", cond: :eq },
+      # name: { source: "User.name", cond: :like }
+    }
+  end
+
+  def data
+    records.map do |record|
+      {
+        # 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,140 @@
+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 '#data' do
+      it 'raises an error if not defined by the user' do
+        expect { datatable.data }.to raise_error AjaxDatatablesRails::NotImplemented
+      end
+
+      context 'child class implements data' do
+        let(:datatable) { ComplexDatatable.new(view) }
+
+        it 'can return an array of hashes' do
+          allow(datatable).to receive(:data) { [{}, {}] }
+          expect(datatable.data).to be_a(Array)
+          item = datatable.data.first
+          expect(item).to be_a(Hash)
+        end
+
+        it 'can return an array of arrays' do
+          allow(datatable).to receive(:data) { [[], []] }
+          expect(datatable.data).to be_a(Array)
+          item = datatable.data.first
+          expect(item).to be_a(Array)
+        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
+  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
+      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
+      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
+      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
+      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 :pg (postgresql)" do
+      expect(config.db_adapter).to eq(:pg)
+    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,65 @@
+require 'spec_helper'
+
+describe 'AjaxDatatablesRails::Datatable::Column' do
+  let(:view) { double('view', params: sample_params) }
+  let(:datatable) { ComplexDatatable.new(view) }
+  before {
+    datatable.params[:columns] = {"0"=>{"data"=>"username", "name"=>"", "searchable"=>"true", "orderable"=>"true", "search"=>{"value"=>"searchvalue", "regex"=>"false"}}}
+  }
+
+  describe 'helper methods' do
+    describe 'order methods' do
+      let(:column) { datatable.datatable.columns.first }
+
+      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('username')
+      end
+
+      context '#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
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+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"}} }
+
+  before(:each) do
+    AjaxDatatablesRails.configure do |config|
+      config.db_adapter = :sqlite
+      config.orm = :active_record
+    end
+  end
+
+  describe 'helper methods' do
+    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.send :dir).to eq('ASC')
+      end
+
+      it 'first column ordered by DESC' do
+        datatable.options[:order] = order_option
+        expect(datatable.orders.last.send :dir).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(4)
+      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
+end