datatables-net 0.4.0

data/Rakefile

@@ -0,0 +1,14 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec
+
+task :console do
+  require 'pry'
+  require 'rails'
+  require 'ajax-datatables-rails'
+  ARGV.clear
+  Pry.start
+end

data/lib/ajax-datatables-rails.rb

@@ -0,0 +1,11 @@
+require 'ajax-datatables-rails/version'
+require 'ajax-datatables-rails/config'
+require 'ajax-datatables-rails/base'
+require 'ajax-datatables-rails/datatable/datatable'
+require 'ajax-datatables-rails/datatable/simple_search'
+require 'ajax-datatables-rails/datatable/simple_order'
+require 'ajax-datatables-rails/datatable/column'
+require 'ajax-datatables-rails/orm/active_record'
+
+module AjaxDatatablesRails
+end

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

@@ -0,0 +1,205 @@
+module AjaxDatatablesRails
+  class NotImplemented < StandardError; end
+
+  class Base
+    extend Forwardable
+<<<<<<< HEAD
+    include ActiveRecord::Sanitization::ClassMethods
+    class MethodNotImplementedError < StandardError; end
+=======
+>>>>>>> v-0-4-0
+
+    attr_reader :view, :options
+    def_delegator :@view, :params, :params
+
+    def initialize(view, options = {})
+      @view = view
+      @options = options
+      load_orm_extension
+    end
+
+    def config
+      @config ||= AjaxDatatablesRails.config
+    end
+
+    def datatable
+      @datatable ||= Datatable::Datatable.new self
+    end
+
+    # Must overrited methods
+    def view_columns
+      fail(NotImplemented, view_columns_error_text)
+    end
+
+    def data
+      fail(NotImplemented, data_error_text)
+    end
+
+    def get_raw_records
+      fail(NotImplemented, raw_records_error_text)
+    end
+
+    def as_json
+      {
+        recordsTotal: total_records,
+        recordsFiltered: filter_records,
+        data: data
+      }
+    end
+
+    def total_records
+      get_raw_records.count(:all)
+    end
+
+    def filtered_records
+      get_raw_records.model.from("(#{filter_records(get_raw_records).except(:limit, :offset, :order).to_sql}) AS foo").count
+    end
+
+    def records
+      @records ||= retrieve_records
+    end
+
+    # helper methods
+    def searchable_columns
+      @searchable_columns ||= begin
+        connected_columns.select &:searchable?
+      end
+    end
+
+    def search_columns
+      @search_columns ||= begin
+        searchable_columns.select { |column| column.search.value.present? }
+      end
+    end
+
+    def connected_columns
+      @connected_columns ||= begin
+        view_columns.keys.map do |field_name|
+          datatable.column_by(:data, field_name.to_s)
+        end.compact
+      end
+    end
+
+    private
+    # view_columns can be an Array or Hash. we have to support all these formats of defining columns
+    def connect_view_columns
+      # @connect_view_columns ||= begin
+      #   adapted_options =
+      #     case view_columns
+      #     when Hash
+      #     when Array
+      #       cols = {}
+      #       view_columns.each_with_index({}) do |index, source|
+      #         cols[index.to_s] = { source: source }
+      #       end
+      #       cols
+      #     else
+      #       view_columns
+      #     end
+      #   ActiveSupport::HashWithIndifferentAccess.new adapted_options
+      # end
+    end
+
+    def retrieve_records
+      records = fetch_records
+      records = filter_records(records)
+      records = sort_records(records)     if datatable.orderable?
+      records = paginate_records(records) if datatable.paginate?
+      records
+    end
+
+    # Private helper methods
+    def load_orm_extension
+      case config.orm
+      when :mongoid then nil
+      when :active_record then extend ORM::ActiveRecord
+      else
+        nil
+      end
+    end
+
+<<<<<<< HEAD
+    def new_search_condition(column, value)
+      model, column = column.split('.')
+      model = model.constantize
+      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
+      casted_column.matches("%#{sanitize_sql_like(value)}%")
+    end
+
+    def deprecated_search_condition(column, value)
+      model, column = column.split('.')
+      model = model.singularize.titleize.gsub( / /, '' ).constantize
+
+      casted_column = ::Arel::Nodes::NamedFunction.new('CAST', [model.arel_table[column.to_sym].as(typecast)])
+      casted_column.matches("%#{sanitize_sql_like(value)}%")
+    end
+
+    def aggregate_query
+      conditions = searchable_columns.each_with_index.map do |column, index|
+        value = params[:columns]["#{index}"][:search][:value] if params[:columns]
+        search_condition(column, value) unless value.blank?
+      end
+      conditions.compact.reduce(:and)
+    end
+
+    def typecast
+      case config.db_adapter
+      when :oracle then 'VARCHAR2(4000)'  
+      when :pg then 'VARCHAR'
+      when :mysql2 then 'CHAR'
+      when :sqlite3 then 'TEXT'
+      end
+    end
+
+    def offset
+      (page - 1) * per_page
+    end
+
+    def page
+      (params[:start].to_i / per_page) + 1
+    end
+
+    def per_page
+      params.fetch(:length, 10).to_i
+    end
+
+    def sort_column(item)
+      new_sort_column(item)
+    rescue
+      ::AjaxDatatablesRails::Base.deprecated '[DEPRECATED] Using table_name.column_name notation is deprecated. Please refer to: https://github.com/antillas21/ajax-datatables-rails#searchable-and-sortable-columns-syntax'
+      deprecated_sort_column(item)
+    end
+
+    def deprecated_sort_column(item)
+      sortable_columns[sortable_displayed_columns.index(item[:column])]
+    end
+=======
+    def raw_records_error_text
+      return <<-eos
+
+        You should implement this method in your class and specify
+        how records are going to be retrieved from the database.
+      eos
+    end
+
+    def data_error_text
+      return <<-eos
+>>>>>>> v-0-4-0
+
+        You should implement this method in your class and return an array
+        of arrays, or an array of hashes, as defined in the jQuery.dataTables
+        plugin documentation.
+      eos
+    end
+
+    def view_columns_error_text
+      return <<-eos
+
+        You should implement this method in your class and return an array
+        of database columns based on the columns displayed in the HTML view.
+        These columns should be represented in the ModelName.column_name,
+        or aliased_join_table.column_name notation.
+      eos
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'active_support/configurable'
+
+module AjaxDatatablesRails
+
+  # configure AjaxDatatablesRails global settings
+  #   AjaxDatatablesRails.configure do |config|
+  #     config.db_adapter = :pg
+  #   end
+  def self.configure &block
+    yield @config ||= AjaxDatatablesRails::Configuration.new
+  end
+
+  # AjaxDatatablesRails global settings
+  def self.config
+    @config ||= AjaxDatatablesRails::Configuration.new
+  end
+
+  class Configuration
+    include ActiveSupport::Configurable
+
+    config_accessor(:orm) { :active_record }
+    config_accessor(:db_adapter) { :pg }
+  end
+end

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

@@ -0,0 +1,106 @@
+module AjaxDatatablesRails
+  module Datatable
+    class Column
+      attr_reader :datatable, :index, :options
+
+      def initialize(datatable, index, options)
+        @datatable, @index, @options = datatable, index, options
+        @view_column = datatable.view_columns[options["data"].to_sym]
+      end
+
+      def data
+        options[:data].presence || options[:name]
+      end
+
+      def searchable?
+        options[:searchable] == TRUE_VALUE
+      end
+
+      def orderable?
+        options[:orderable] == TRUE_VALUE
+      end
+
+      def search
+        @search ||= SimpleSearch.new(options[:search])
+      end
+
+      def search= value
+        @search = value
+      end
+
+      def cond
+        @view_column[:cond] || :like
+      end
+
+      def filter value
+        @view_column[:cond].call self
+      end
+
+      def source
+        @view_column[:source]
+      end
+
+      def table
+        model = source.split('.').first.constantize
+        model.arel_table rescue model
+      end
+
+      def field
+        source.split('.').last.to_sym
+      end
+
+      def search_query
+        search.regexp? ? regex_search : non_regex_search
+      end
+
+      def sort_query
+        if custom_field?
+          source
+        else
+          "#{ table.name }.#{ field }"
+        end
+      end
+
+      private
+      def custom_field?
+        !source.include?('.')
+      end
+
+      def config
+        @config ||= AjaxDatatablesRails.config
+      end
+
+      def regex_search
+        ::Arel::Nodes::Regexp.new((custom_field? ? field : table[field]), ::Arel::Nodes.build_quoted(search.value))
+      end
+
+      def non_regex_search
+        case cond
+        when Proc
+          filter search.value
+        when :eq, :not_eq, :lt, :gt, :lteq, :gteq, :in
+          if custom_field?
+            ::Arel::Nodes::SqlLiteral.new(field).eq(search.value)
+          else
+            table[field].send(cond, search.value)
+          end
+        else
+          casted_column = ::Arel::Nodes::NamedFunction.new(
+            'CAST', [table[field].as(typecast)]
+          )
+          casted_column.matches("%#{ search.value }%")
+        end
+      end
+
+      def typecast
+        case config.db_adapter
+        when :mysql, :mysql2   then 'CHAR'
+        when :sqlite, :sqlite3 then 'TEXT'
+        else
+          'VARCHAR'
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module AjaxDatatablesRails
+  module Datatable
+
+    TRUE_VALUE = 'true'
+
+    class Datatable
+      attr_reader :datatable, :options
+
+      def initialize datatable
+        @datatable = datatable
+        @options = datatable.params
+      end
+
+      # ----------------- ORDER METHODS --------------------
+
+      def orderable?
+        options[:order].present?
+      end
+
+      def orders
+        @orders ||= options[:order].map { |index, order_options| SimpleOrder.new(self, order_options) }
+      end
+
+      def order_by(how, what)
+        orders.find { |simple_order| simple_order.send(how) == what }
+      end
+
+      # ----------------- SEARCH METHODS --------------------
+
+      def searchable?
+        options[:search].present? && options[:search][:value].present?
+      end
+
+      def search
+        @search ||= SimpleSearch.new(options[:search])
+      end
+
+      # ----------------- COLUMN METHODS --------------------
+
+      def columns
+        @columns ||= options[:columns].map do |index, column_options|
+          Column.new(datatable, index, column_options)
+        end
+      end
+
+      def column_by how, what
+        columns.find { |simple_column| simple_column.send(how) == what }
+      end
+
+      # ----------------- OPTIONS METHODS --------------------
+
+      def paginate?
+        per_page != -1
+      end
+
+      def offset
+        (page - 1) * per_page
+      end
+
+      def page
+        (options[:start].to_i / per_page) + 1
+      end
+
+      def per_page
+        options.fetch(:length, 10).to_i
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module AjaxDatatablesRails
+  module Datatable
+    class SimpleOrder
+      attr_reader :datatable, :options
+
+      DIRECTIONS = %w(DESC ASC)
+
+      def initialize(datatable, options)
+        @datatable = datatable
+        @options = options || {}
+      end
+
+      def query sort_column
+        "#{ sort_column } #{ dir }"
+      end
+
+      def column
+        datatable.column_by(:index, column_index)
+      end
+
+      private
+      def dir
+        DIRECTIONS.find { |direction| direction == options[:dir].upcase } || 'ASC'
+      end
+
+      def column_index
+        options[:column]
+      end
+    end
+  end
+end