trk_datatables 0.1.0

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'trk_datatables'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/trk_datatables.rb

@@ -0,0 +1,15 @@
+require 'trk_datatables/version'
+# modules
+require 'trk_datatables/preferences.rb'
+
+require 'trk_datatables/base'
+require 'trk_datatables/active_record'
+require 'trk_datatables/dt_params'
+require 'trk_datatables/column_key_options.rb'
+require 'trk_datatables/render_html.rb'
+
+# libs
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/string/output_safety'

data/lib/trk_datatables/active_record.rb

@@ -0,0 +1,110 @@
+module TrkDatatables
+  class ActiveRecord < Base
+    # Global search. All columns are typecasted to string. Search string is
+    # splited by space and "and"-ed.
+    def filter_by_search_all(filtered_items)
+      conditions = @dt_params.search_all.split(' ').map do |search_string|
+        @column_key_options.searchable_and_global_search.map do |column_key_option|
+          filter_column_as_string column_key_option, search_string
+        end.reduce(:or) # any searchable column is 'or'-ed
+      end.reduce(:and) # 'and' for each search_string
+
+      filtered_items.where conditions
+    end
+
+    def filter_by_columns(filtered_items)
+      conditions = @dt_params.dt_columns.each_with_object([]) do |dt_column, cond|
+        next unless dt_column[:searchable] && dt_column[:search_value].present?
+
+        # check both params and configuration
+        column_key_option = @column_key_options[dt_column[:index]]
+        next if column_key_option[:column_options][ColumnKeyOptions::SEARCH_OPTION] == false
+
+        cond << build_condition_for_column(column_key_option, dt_column[:search_value])
+      end.reduce(:and) # 'and' for each searchable column
+
+      filtered_items.where conditions
+    end
+
+    def build_condition_for_column(column_key_option, search_value)
+      # nil is when we use action columns, usually not column searchable
+      return nil if column_key_option[:column_type_in_db].nil?
+
+      select_options = column_key_option[:column_options][ColumnKeyOptions::SELECT_OPTIONS]
+      if select_options.present?
+        filter_column_as_in(column_key_option, search_value)
+      elsif %i[date datetime integer float].include?(column_key_option[:column_type_in_db]) && \
+            search_value.include?(BETWEEN_SEPARATOR)
+        from, to = search_value.split BETWEEN_SEPARATOR
+        filter_column_as_between(column_key_option, from, to)
+      else
+        filter_column_as_string(column_key_option, search_value)
+      end
+    end
+
+    def filter_column_as_string(column_key_option, search_value)
+      search_value.split(' ').map do |search_string|
+        casted_column = ::Arel::Nodes::NamedFunction.new(
+          'CAST',
+          [_arel_column(column_key_option).as(@column_key_options.string_cast)]
+        )
+        casted_column.matches("%#{search_string}%")
+      end.reduce(:and)
+    end
+
+    def filter_column_as_between(column_key_option, from, to)
+      from, to = _parse_from_to(from, to, column_key_option)
+      if from.present? && to.present?
+        _arel_column(column_key_option).between(from..to)
+      elsif from.present?
+        _arel_column(column_key_option).gteq(from)
+      elsif to.present?
+        _arel_column(column_key_option).lteq(to)
+        # else
+        # nil will result in true relation
+      end
+    end
+
+    def filter_column_as_in(column_key_option, search_value)
+      _arel_column(column_key_option).in search_value.split(MULTIPLE_OPTION_SEPARATOR)
+    end
+
+    def _parse_from_to(from, to, column_key_option)
+      case column_key_option[:column_type_in_db]
+      # when :integer, :float
+      # we do not need to cast from string since range will do automatically
+      when :date, :datetime
+        from = _parse_in_zone(from) if from.present?
+        to = _parse_in_zone(to) if to.present?
+      end
+      [from, to]
+    end
+
+    # rubocop:disable Rails/TimeZone
+    def _parse_in_zone(time)
+      # without rails we will parse without zone so make sure params are correct
+      Time.zone ? Time.zone.parse(time) : Time.parse(time)
+    end
+    # rubocop:enable Rails/TimeZone
+
+    def order_and_paginate_items(filtered_items)
+      filtered_items = order_items filtered_items
+      filtered_items = filtered_items.offset(@dt_params.dt_offset).limit(dt_per_page_or_default)
+      filtered_items
+    end
+
+    def order_items(filtered_items)
+      order_by = dt_orders_or_default.each_with_object([]) do |dt_order, queries|
+        column_key_option = @column_key_options[dt_order[:column_index]]
+        next if column_key_option[:column_options][ColumnKeyOptions::ORDER_OPTION] == false
+
+        queries << "#{column_key_option[:column_key]} #{dt_order[:direction]}"
+      end
+      filtered_items.order(Arel.sql(order_by.join(', ')))
+    end
+
+    def _arel_column(column_key_option)
+      column_key_option[:table_class].arel_table[column_key_option[:column_name]]
+    end
+  end
+end

data/lib/trk_datatables/base.rb

@@ -0,0 +1,189 @@
+module TrkDatatables
+  BETWEEN_SEPARATOR = ' - '.freeze
+  MULTIPLE_OPTION_SEPARATOR = '|'.freeze
+  DEFAULT_ORDER = [{ column_index: 0, direction: :desc }].freeze
+  DEFAULT_PAGE_LENGTH = 10
+
+  class Error < StandardError
+  end
+
+  class Base
+    include TrkDatatables::Preferences
+    attr_accessor :column_key_options
+
+    def initialize(view)
+      @view = view
+      @dt_params = DtParams.new view.params
+      @column_key_options = ColumnKeyOptions.new columns, global_search_columns
+
+      # if @dt_params.dt_columns.size != @column_key_options.size
+      #   raise Error, "dt_columns size of columns is #{@dt_params.dt_columns.size} \
+      #   but column_key_options size is #{@column_key_options.size}"
+      # end
+    end
+
+    # Get all items from db
+    #
+    # @example
+    #   def all_items
+    #     Post.joins(:users).published
+    #   end
+    # @return [ActiveRecord::Relation]
+    def all_items
+      raise NotImplementedError, "You should implement #{__method__} method"
+    end
+
+    # Define columns of a table
+    # For simplest version you can notate column_keys as Array of strings
+    # @example
+    #   def column
+    #     %w[posts.id posts.status users.name]
+    #   end
+    #
+    # When you need customisation of some columns, you need to define Hash of column_key => { column_options }
+    # @example
+    #   def columns
+    #     {
+    #       'posts.id': {},
+    #       'posts.status' => { search: false },
+    #       'users.name' => { order: false },
+    #     }
+    #   end
+    # @return Array of Hash
+    def columns
+      raise NotImplementedError, "You should implement #{__method__} method #{link_to_rdoc self.class, __method__}"
+    end
+
+    # Define columns that are not returned to page but only used as mathing for
+    # global search
+    # @example
+    #   def global_search_columns
+    #     %w[name email].map {|col| "users.#{col}" } + %w[posts.body]
+    #   end
+    def global_search_columns
+      []
+    end
+
+    # Define page data
+    # @example
+    #   def rows(page_items)
+    #     page_items.map do |post|
+    #     post_status = @view.content_tag :span, post.status, class: "label label-#{@view.convert_status_to_class post.status}"
+    #       [
+    #         post.id,
+    #         post_status,
+    #         @view.link_to(post.user.name, post.user)
+    #       ]
+    #     end
+    #   end
+    def rows(_page_items)
+      raise NotImplementedError, "You should implement #{__method__} method"
+    end
+
+    def filter_by_search_all(_all)
+      raise 'filter_by_columns_is_defined_in_specific_orm'
+    end
+
+    def filter_by_columns(_all)
+      raise 'filter_by_columns_is_defined_in_specific_orm' \
+        "\n  Extent from TrkDatatables::ActiveRecord instead of TrkDatatables::Base"
+    end
+
+    def order_and_paginate_items(_filtered_items)
+      raise 'order_and_paginate_items_is_defined_in_specific_orm'
+    end
+
+    # Returns dt_orders or default
+    # @return
+    #   [
+    #     { column_index: 0, direction: :desc },
+    #   ]
+    def dt_orders_or_default
+      return @dt_orders_or_default if defined? @dt_orders_or_default
+
+      if @dt_params.dt_orders.present?
+        @dt_orders_or_default = @dt_params.dt_orders
+        set_preference :order, @dt_params.dt_orders
+      else
+        @dt_orders_or_default = get_preference(:order) || DEFAULT_ORDER
+      end
+      @dt_orders_or_default
+    end
+
+    def dt_per_page_or_default
+      return @dt_per_page_or_default if defined? @dt_per_page_or_default
+
+      @dt_per_page_or_default = \
+        if @dt_params.dt_per_page.present?
+          set_preference :per_page, @dt_params.dt_per_page
+          @dt_params.dt_per_page
+        else
+          get_preference(:per_page) || DEFAULT_PAGE_LENGTH
+        end
+    end
+
+    # Set params for columns. This is class method so you do not need datatable
+    # instance.
+    #
+    # @example
+    #   link_to 'Published posts for my@email.com',
+    #   posts_path(PostsDatatable.params('posts.status': :published,
+    #   'users.email: 'my@email.com')
+    #
+    # You can always use your params for filtering outside of datatable
+    # @example
+    #   link_to 'Published posts for user1',
+    #   posts_path(PostsDatatable.params_set('posts.status': :published).merge(user_id: user1.id))
+    def self.params_set(attr)
+      datatable = new OpenStruct.new(params: {})
+      result = {}
+      attr.each do |column_key, value|
+        value = value.join MULTIPLE_OPTION_SEPARATOR if value.is_a? Array
+        column_index = datatable.index_by_column_key column_key
+        result = result.deep_merge DtParams.param_set column_index, value
+      end
+      result
+    end
+
+    # We need this method publicly available since we use it for class method
+    # params_set
+    def index_by_column_key(column_key)
+      @column_key_options.index_by_column_key column_key
+    end
+
+    # Helper to populate column search from params, used in
+    # RenderHtml#thead
+    # @example
+    #   @datatable.param_get('users.email')
+    def param_get(column_key)
+      column_index = index_by_column_key column_key
+      @dt_params.param_get column_index
+    end
+
+    # _attr is given by Rails template, prefix, layout... not used
+    def as_json(_attr = nil)
+      # get the value if it is not a relation
+      all_count = all_items.count
+      filtered_items = filter_by_search_all filter_by_columns all_items
+      ordered_paginated_filtered_items = order_and_paginate_items filtered_items
+      @dt_params.as_json(
+        all_count,
+        filtered_items.count,
+        rows(ordered_paginated_filtered_items)
+      )
+    end
+
+    def link_to_rdoc(klass, method)
+      "http://localhost:8808/docs/TrkDatatables/#{klass.name}##{method}-instance_method"
+    end
+
+    def render_html(search_link = nil, html_options = {})
+      if search_link.is_a? Hash
+        html_options = search_link
+        search_link = nil
+      end
+      render = RenderHtml.new(search_link, self, html_options)
+      render.result
+    end
+  end
+end

data/lib/trk_datatables/column_key_options.rb

@@ -0,0 +1,165 @@
+module TrkDatatables
+  # rubocop:disable ClassLength
+  class ColumnKeyOptions
+    include Enumerable
+
+    # All options that you can use for columns:
+    #
+    # search: if you want to enable global and column search, default is true
+    # order: `:asc` or `:desc` or `false`, default is `:desc`
+    # @code
+    #   def columns
+    #     {
+    #       'users.name': { search: false }
+    #     }
+    SEARCH_OPTION = :search
+    ORDER_OPTION = :order
+    TITLE_OPTION = :title
+    SELECT_OPTIONS = :select_options
+    # this will load date picker
+    # SEARCH_OPTION_DATE_VALUE = :date
+    # SEARCH_OPTION_DATETIME_VALUE = :datetime
+    COLUMN_OPTIONS = [SEARCH_OPTION, ORDER_OPTION, TITLE_OPTION, SELECT_OPTIONS].freeze
+
+    STRING_TYPE_CAST_POSTGRES = 'VARCHAR'.freeze
+    STRING_TYPE_CAST_MYSQL    = 'CHAR'.freeze
+    STRING_TYPE_CAST_SQLITE   = 'TEXT'.freeze
+    STRING_TYPE_CAST_ORACLE   = 'VARCHAR2(4000)'.freeze
+
+    DB_ADAPTER_STRING_TYPE_CAST = {
+      psql: STRING_TYPE_CAST_POSTGRES,
+      mysql: STRING_TYPE_CAST_MYSQL,
+      mysql2: STRING_TYPE_CAST_MYSQL,
+      sqlite: STRING_TYPE_CAST_SQLITE,
+      sqlite3: STRING_TYPE_CAST_SQLITE,
+      oracle: STRING_TYPE_CAST_ORACLE,
+      oracleenhanced: STRING_TYPE_CAST_ORACLE
+    }.freeze
+
+    attr_accessor :string_cast
+
+    # @return
+    #   {
+    #     column_key: :'users.name',
+    #     column_options: { order: false, select_options: User.statuses },
+    #     table_class: User,
+    #     column_name: :name,
+    #     column_type_in_db: :string,
+    #     title: 'Name',
+    #     html_options: { class: 'my-class' },
+    #   }
+    def initialize(cols, global_search_cols)
+      # if someone use Array instead of hash, we will use first element
+      if cols.is_a? Array
+        cols = cols.each_with_object({}) do |column_key, hash|
+          hash[column_key.to_sym] = {}
+        end
+      end
+      _set_data(cols)
+      _set_global_search_cols(global_search_cols)
+      @string_cast = _determine_string_type_cast
+    end
+
+    def _set_data(cols)
+      @data = cols.each_with_object([]) do |(column_key, column_options), arr|
+        raise Error, 'Column options needs to be a Hash' unless column_options.is_a? Hash
+
+        column_options.assert_valid_keys(*COLUMN_OPTIONS)
+        table_name, column_name = column_key.to_s.split '.'
+        raise Error, 'Column key needs to have one dot table.column' if table_name.present? && column_name.nil?
+
+        if table_name.blank?
+          column_name = 'actions' # some default name for a title
+        else
+          table_class = table_name.singularize.camelcase.constantize
+          column_type_in_db = _determine_db_type_for_column(table_class, column_name)
+        end
+        arr << {
+          column_key: column_key.to_sym,
+          column_options: column_options,
+          table_class: table_class,
+          column_name: column_name,
+          column_type_in_db: column_type_in_db,
+          # the following are used for RenderHtml
+          title: column_options[TITLE_OPTION] || column_name.humanize,
+          html_options: html_options(column_options, column_type_in_db),
+        }
+      end
+    end
+
+    def _set_global_search_cols(global_search_cols)
+      @global_search_cols = global_search_cols.each_with_object([]) do |column_key, arr|
+        table_name, column_name = column_key.to_s.split '.'
+        table_class = table_name.singularize.camelcase.constantize
+        column_type_in_db = _determine_db_type_for_column(table_class, column_name)
+        arr << {
+          column_key: column_key.to_sym,
+          column_options: {},
+          table_class: table_class,
+          column_name: column_name,
+          column_type_in_db: column_type_in_db,
+        }
+      end
+    end
+
+    # This is helper
+    def _determine_string_type_cast # :nodoc:
+      raise NotImplementedError unless defined?(::ActiveRecord::Base)
+
+      DB_ADAPTER_STRING_TYPE_CAST[::ActiveRecord::Base.connection_config[:adapter].to_sym]
+    end
+
+    # @return
+    #   :string, :integer, :date, :datetime
+    def _determine_db_type_for_column(table_class, column_name)
+      raise NotImplementedError unless defined?(::ActiveRecord::Base)
+
+      ar_column = table_class.columns_hash[column_name]
+      raise Error, "Can't find column #{column_name} in #{table_class.name}" unless ar_column
+
+      ar_column.type
+    end
+
+    def searchable
+      @data.reject do |column_key_option|
+        column_key_option[:column_options][SEARCH_OPTION] == false
+      end
+    end
+
+    def searchable_and_global_search
+      searchable + @global_search_cols
+    end
+
+    def [](index)
+      raise Error, "You asked for column index=#{index} but there is only #{@data.size} columns" if index >= @data.size
+
+      @data[index]
+    end
+
+    def each(&block)
+      @data.each(&block)
+    end
+
+    def size
+      @data.size
+    end
+
+    def index_by_column_key(column_key)
+      i = @data.find_index do |column_key_option|
+        column_key_option[:column_key] == column_key.to_sym
+      end
+      raise Error, "Can't find index for #{column_key} in #{@data.map { |d| d[:column_key] }.join(', ')}" if i.nil?
+
+      i
+    end
+
+    def html_options(column_options, column_type_in_db)
+      res = {}
+      res['data-searchable'] = false if column_options[SEARCH_OPTION] == false
+      res['data-orderable'] = false if column_options[ORDER_OPTION] == false
+      res['data-datatable-range'] = true if %i[date datetime].include? column_type_in_db
+      res
+    end
+  end
+  # rubocop:enable ClassLength
+end