pwice_grid 5.0.0

data/lib/wice/kaminari_monkey_patching.rb

@@ -0,0 +1,12 @@
+# Ugly monkey-patching Kaminari (https://github.com/amatsuda/kaminari/pull/267)
+module Kaminari #:nodoc:
+  module Helpers #:nodoc:
+    class Tag #:nodoc:
+      def page_url_for(page) #:nodoc:
+        current_page_params_as_query_string = @param_name.to_s + '=' + (page <= 1 ? nil : page).to_s
+        current_page_params_as_hash = Rack::Utils.parse_nested_query(current_page_params_as_query_string)
+        @template.url_for Wice::WgHash.rec_merge(@params, current_page_params_as_hash).symbolize_keys
+      end
+    end
+  end
+end

data/lib/wice/table_column_matrix.rb

@@ -0,0 +1,64 @@
+module Wice
+
+  # a matrix for all declared columns
+  class TableColumnMatrix < Hash #:nodoc:
+
+    # a structure to hold generates Arels for all column filters
+    attr_reader :generated_conditions
+
+    # init a matrix of all columns
+    def initialize  #:nodoc:
+      super
+      @generated_conditions = []
+      @by_table_names = HashWithIndifferentAccess.new
+    end
+
+    # add an Arel for a column
+    def add_condition(column, conditions)
+      @generated_conditions << [column, conditions] unless conditions.blank?
+    end
+
+    # returns a list of all Arels
+    def conditions
+      @generated_conditions.collect { |_, cond| cond }
+    end
+
+    # returns Arels for one model
+    alias_method :get, :[]
+
+    # returns the main ActiveRecord model class
+    attr_reader :default_model_class
+
+    # sets the main ActiveRecord model class
+    def default_model_class=(model)  #:nodoc:
+      init_columns_of_table(model) unless key?(model)
+      @default_model_class = model
+    end
+
+    # returns Arels for one model
+    def [](model)  #:nodoc:
+      init_columns_of_table(model) unless key?(model)
+      get(model)
+    end
+
+    def get_column_by_model_class_and_column_name(model_class, column_name)  #:nodoc:
+      self[model_class][column_name]
+    end
+
+    def get_column_in_default_model_class_by_column_name(column_name)  #:nodoc:
+      if @default_model_class.nil?
+        raise WiceGridException.new("Cannot search for this column(#{column_name}) in a default model(#{@default_model_class}) as the default model is not set")
+      end
+
+      self[@default_model_class][column_name]
+    end
+
+    def init_columns_of_table(model) #:nodoc:
+      self[model] = HashWithIndifferentAccess.new(model.columns.index_by(&:name))
+      @by_table_names[model.table_name] = self[model]
+      self[model].each_value { |c| c.model = model }
+    end
+
+    alias_method :<<, :init_columns_of_table
+  end
+end

data/lib/wice/wice_grid_controller.rb

@@ -0,0 +1,174 @@
+module Wice
+  module Controller #:nodoc:
+    def self.included(base) #:nodoc:
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods #:nodoc:
+      # Used to add query processing action methods into a controller.
+      # Read section "Saving Queries How-To" in README for more details.
+      def save_wice_grid_queries
+        include Wice::SerializedQueriesControllerMixin
+      end
+    end
+
+    protected
+
+    attr_accessor :wice_grid_instances #:nodoc:
+
+    # Creates a grid object to be used in the view. This is the <i>main</i> model, and the underlying table is the default table -
+    # if in other parameters a column name is mentioned without the name of the table, this table is implied.
+    # Just like in an ordinary ActiveRecord <tt>find</tt> you can use <tt>:joins</tt>, <tt>:include</tt>, and <tt>:conditions</tt>.
+    #
+    # The first parameter is an ActiveRecord class name or an  ActiveRecord::Relation instance. The generated ActiveRecord call will use it as the
+    # receiver of the <tt>paginate</tt> method: <tt>klass.paginate(...)</tt>
+    #
+    # The second parameters is a hash of parameters:
+    # * <tt>:joins</tt> - ActiveRecord <tt>:joins</tt> option.
+    # * <tt>:include</tt> - ActiveRecord <tt>:include</tt> option.
+    #   The value of `:include` can be an array of association names `include:  [:category, :users, :status]`,
+    #   If you need to join tables to joined tables, use hashes: `include:  [:category, {users: :group}, :status]`
+    # * <tt>:conditions</tt> - ActiveRecord <tt>:conditions</tt> option.
+    # * <tt>:per_page</tt> - Number of rows per one page. The default is 10.
+    # * <tt>:page</tt> - The page to show when rendering the grid for the first time. The default is one, naturally.
+    # * <tt>:order</tt> - Name of the column to sort by. Can be of a short form (just the name of the column) if this
+    #   is a column of the main table (the table of the main ActiveRecord model, the first parameter of <tt>initialize_grid</tt>),
+    #   or a fully qualified name with the name of the table.
+    # * <tt>:order_direction</tt> - <tt>:asc</tt> for ascending or <tt>:desc</tt> for descending. The default is <tt>:asc</tt>.
+    # * <tt>:name</tt> - name of the grid. Only needed if there is a second grid on a page. The name serves as the base name for
+    #   HTTP parametes, DOM IDs, etc. The shorter the name, the shorter the GET request is. The name can only contain alphanumeruc characters.
+    # * <tt>:enable_export_to_csv</tt> - <Enable export of the table to CSV. Read the How-To to learn what else is needed to enable CSV export.
+    # * <tt>:csv_file_name</tt> - Name of the exported CSV file. If the parameter is missing, the name of the grid will be used instead.
+    # * <tt>:csv_field_separator</tt> - field separator for CSV files. The default is defined in +CSV_FIELD_SEPARATOR+ in the config file.
+    # * <tt>:custom_order</tt> - used for overriding the ORDER BY clause with custom sql code (for example, using an SQL
+    #   function). A Hash with keys of the fully qualified names of database columns and with values that specify the
+    #   ordering to be used, without specifying the direction (no ASC or DESC). The values of this Hash can any String
+    #   of SQL that can be passed to the ActiveRecord order clause, an instance of Arel::Attributes::Attribute, or a
+    #   Proc that receives the fully qualified column name and returns a String or Arel::Attributes::Attribute. See
+    #   section 'Custom Ordering' in the README.
+    # * <tt>:saved_query</tt> - id of the saved query or the query object itself to load initially.
+    #   Read section "Saving Queries How-To" in README for more details.
+    # * <tt>:after</tt> - defined a name of a controller method which would be called by the grid after all user input has been processed,
+    #   with a single parameter which is a Proc object. Once called, the object returns a list of all records of the current selection
+    #   throughout all pages. See section "Integration With The Application" in the README.
+    # * <tt>:select</tt> - ActiveRecord <tt>:select</tt> option. Please do not forget that <tt>:select</tt> is ignored
+    #   when <tt>:include</tt> is present. It is unlikely you would need <tt>:select</tt> with WiceGrid, but if you do,
+    #   use it with care :)
+    # * <tt>:group</tt> - ActiveRecord <tt>:group</tt> option. Use it if you are sure you know what you are doing :)
+    # * <tt>:with_paginated_resultset</tt> - a callback executed from within the plugin to process records of the current page.
+    #   Can be a lambda object or a controller method name (symbol). The argument to the callback is the array of the records.
+    # * <tt>:with_resultset</tt> - a callback executed from within the plugin to process all records browsable through
+    #   all pages with the current filters. Can be a lambda object or a controller method name (symbol). The argument to
+    #   the callback is a lambda object which returns the list of records when called. See the README for the explanation.
+    #
+    # Defaults for parameters <tt>:per_page</tt>, <tt>:order_direction</tt>, and <tt>:name</tt>
+    # can be changed in <tt>lib/wice_grid_config.rb</tt>, this is convenient if you want to set a project wide setting
+    # without having to repeat it for every grid instance.
+
+    def initialize_grid(klass, opts = {})
+      wg = WiceGrid.new(klass, self, opts)
+      self.wice_grid_instances = [] if self.wice_grid_instances.nil?
+      self.wice_grid_instances << wg
+      wg
+    end
+
+    # +export_grid_if_requested+ is a controller method which should be called at the end of each action containing grids with enabled
+    # CSV export.
+    #
+    # CSV export will only work if each WiceGrid helper is placed in a partial of its own (requiring it from the master template
+    # of course for the usual flow).
+    # +export_grid_if_requested+ intercepts CSV export requests and evaluates the corresponding partial with the required  grid helper.
+    # By default for each grid +export_grid_if_requested+ will look for a partial
+    # whose name follows the following pattern:
+    #
+    #     _GRID_NAME_grid.html.erb
+    #
+    # For example, a grid named +orders+ is supposed to be found in a template called <tt>_orders_grid.html.erb</tt>,
+    # Remember that the default name of grids is +grid+.
+    #
+    # This convention can be easily overridden by supplying a hash parameter to +export_grid_if_requested+ where each key is the name of
+    # a grid, and the value is the name of the template (like it is specified for +render+, i.e. without '_' and extensions):
+    #
+    #   export_grid_if_requested('grid' => 'orders', 'grid2' => 'invoices')
+    #
+    # If the request is not a CSV export request, the method does nothing and returns +false+, if it is a CSV export request,
+    # the method returns +true+.
+    #
+    # If the action has no explicit +render+ call, it's OK to just place +export_grid_if_requested+ as the last line of the action. Otherwise,
+    # to avoid double rendering, use the return value of the method to conditionally call your +render+ :
+    #
+    #    export_grid_if_requested || render(action: 'index')
+    #
+    # It's also possible to supply a block which will be called if no CSV export is requested:
+    #
+    #    export_grid_if_requested do
+    #     render(action: 'index')
+    #    end
+
+    def export_grid_if_requested(opts = {})
+      grid = self.wice_grid_instances.detect(&:output_csv?)
+
+      if grid
+        template_name = opts[grid.name] || opts[grid.name.intern]
+        template_name ||= grid.name + '_grid'
+        temp_filename = render_to_string(partial: template_name)
+        temp_filename = temp_filename.strip
+        filename = (grid.csv_file_name || grid.name) + '.csv'
+        grid.csv_tempfile.close
+        send_file temp_filename, filename: filename, type: "text/csv; charset=#{get_output_encoding grid.csv_encoding}"
+        grid.csv_tempfile = nil
+        true
+      else
+        yield if block_given?
+        false
+      end
+    end
+
+    # +wice_grid_custom_filter_params+ generates HTTP parameters understood by WiceGrid custom filters.
+    # Combined with Rails route helpers it allows to generate links leading to
+    # grids with pre-selected custom filters.
+    #
+    # Parameters:
+    # * <tt>:grid_name</tt> - The name of the grid. Just like parameter <tt>:name</tt> of
+    #   <tt>initialize_grid</tt>, the parameter is optional, and when absent, the name
+    #   <tt>'grid'</tt> is assumed
+    # * <tt>:attribute</tt> and <tt>:model</tt> - should be the same as <tt>:attribute</tt> and
+    #   <tt>:model</tt> of the column declaration with the target custom filter.
+    # * <tt>:value</tt> - the value of the column filter.
+    def wice_grid_custom_filter_params(opts = {})
+      options = {
+        grid_name: 'grid',
+        attribute: nil,
+        model:     nil,
+        value:     nil
+      }
+      options.merge!(opts)
+
+      [:attribute, :value].each do |key|
+        raise ::Wice::WiceGridArgumentError.new("wice_grid_custom_filter_params: :#{key} is a mandatory argument") unless options[key]
+      end
+
+      attr_name = if options[:model]
+        unless options[:model].nil?
+          options[:model] = options[:model].constantize if options[:model].is_a? String
+          raise Wice::WiceGridArgumentError.new('Option :model can be either a class or a string instance') unless options[:model].is_a? Class
+        end
+        options[:model].table_name + '.' + options[:attribute]
+      else
+        options[:attribute]
+      end
+
+      { "#{options[:grid_name]}[f][#{attr_name}][]" => options[:value] }
+    end
+
+    private
+
+    def get_output_encoding(csv_encoding)
+      if csv_encoding.blank?
+        'utf-8'
+      else
+        csv_encoding.split(':').first
+      end
+    end
+  end
+end

data/lib/wice/wice_grid_core_ext.rb

@@ -0,0 +1,145 @@
+module Wice
+  module WgHash #:nodoc:
+    class << self #:nodoc:
+      # if there's a hash of hashes, the original structure and the
+      # returned structure should not contain any shared deep hashes
+      def deep_clone(hash)  #:nodoc:
+        cloned = hash.clone
+        cloned.keys.each do |k|
+          if cloned[k].is_a?(Hash)
+            cloned[k] = Wice::WgHash.deep_clone cloned[k]
+          end
+        end
+        cloned
+      end
+
+      # Used to modify options submitted to view helpers. If there is no :klass option,
+      # it will be added, if there is, the css class name will be appended to the existing
+      # class name(s)
+      def add_or_append_class_value!(hash, klass_value, prepend = false) #:nodoc:
+        if hash.key?('class')
+          hash[:class] = hash['class']
+          hash.delete('class')
+        end
+
+        hash[:class] = if hash.key?(:class)
+          if prepend
+            "#{klass_value} #{hash[:class]}"
+          else
+            "#{hash[:class]} #{klass_value}"
+          end
+        else
+          klass_value
+        end
+
+        hash
+      end
+
+      # Used mostly for submitting options to view helpers, that is, like this:
+      #   content_tag(:th, col_link, Wice::WgHash.make_hash(:class, css_class))
+      # In some it is important that if the value is empty, no option
+      # is submitted at all. Thus, there's a check for an empty value
+      def make_hash(key, value) #:nodoc:
+        value.blank? ? {} : { key => value }
+      end
+
+      # A deep merge of two hashes.
+      # That is, if both hashes have the same key and the values are hashes, these two hashes should also be merged.
+      # Used for merging two sets of params.
+      def rec_merge(hash, other)  #:nodoc:
+        res = hash.clone
+        other.each do |key, other_value|
+          value = res[key]
+          if value.is_a?(Hash) && other_value.is_a?(Hash)
+            res[key] = rec_merge value, other_value
+          else
+            res[key] = other_value
+          end
+        end
+        res
+      end
+
+      # Used to transform a traditional params hash
+      # into an array of two element arrays where element zero is a parameter name as it appears in HTTP requests,
+      # and the first element is the value:
+      # { a: { b: 3, c: 4, d: { e: 5 }} }.parameter_names_and_values #=>  [["a[d][e]", 5], ["a[b]", 3], ["a[c]", 4]]
+      # The parameter is an optional array of parameter names to prepend:
+      # { a: { b: 3, c: 4, d: { e: 5 }} }.parameter_names_and_values(['foo', 'baz']) #=>
+      #                         [["foo[baz][a][d][e]", 5], ["foo[baz][a][b]", 3], ["foo[baz][a][c]", 4]]
+      def parameter_names_and_values(hash, initial = []) #:nodoc:
+        res = []
+        recursively_gather_finite_non_hash_values_with_key_path(hash, res, [])
+        res.collect do |parameter_struct|
+          parameter_struct[0] = initial + parameter_struct[0]
+          [Wice::WgArray.to_parameter_name(parameter_struct[0]), parameter_struct[1]]
+        end
+      end
+
+      protected
+
+      def recursively_gather_finite_non_hash_values_with_key_path(hash, res, stack = []) #:nodoc:
+        hash.each do |key, value|
+          if value.is_a?(Hash)
+            recursively_gather_finite_non_hash_values_with_key_path(value, res, stack + [key])
+          else
+            res << [stack + [key], value]
+          end
+        end
+      end
+    end
+  end
+
+  module WgEnumerable #:nodoc:
+    # Used to check the validity of :custom_filter parameter of column
+    def self.all_items_are_of_class(enumerable, klass)  #:nodoc:
+      return false if enumerable.empty?
+      enumerable.inject(true) { |memo, o| (o.is_a? klass) && memo }
+    end
+  end
+
+  module WgArray #:nodoc:
+    # Only used by Hash#parameter_names_and_values
+    # Transforms ['foo', 'bar', 'baz'] to 'foo[bar][baz]'
+    def self.to_parameter_name(array) #:nodoc:
+      array[0].to_s + (array[1..-1] || []).collect { |k| '[' + k.to_s + ']' }.join('')
+    end
+  end
+end
+
+# tag_options is a Rails views private method that takes a hash op options for
+# an HTM hash and produces a string ready to be added to the tag.
+# Here we are changing its visibility in order to be able to use it.
+module ActionView #:nodoc:
+  module Helpers #:nodoc:
+    module TagHelper #:nodoc:
+      def public_tag_options(options, escape = true) #:nodoc:
+        if respond_to?(:tag_options, true)
+          tag_options(options, escape)
+        else
+          tag_builder.tag_options(options, escape)
+        end
+      end
+    end
+  end
+end
+
+module WGObjectExtensions #:nodoc:
+  # takes a list of messages, sends message 1 to self, then message 2 is sent to the result of the first message, ans so on
+  # returns nil as soon as the current receiver does not respond to such a message
+  def deep_send(*messages)  #:nodoc:
+    obj = self
+    messages.each do |message|
+      if obj.respond_to? message
+        obj = obj.send(message)
+      else
+        return nil
+      end
+      # return obj if obj.nil?
+    end
+    obj
+  end
+end
+
+class Object #:nodoc:
+  include WGObjectExtensions
+end

data/lib/wice/wice_grid_misc.rb

@@ -0,0 +1,208 @@
+module Wice
+  class << self
+
+    # a flag storing whether the saved query class is a valid storage for saved queries
+    @@model_validated = false
+
+    def assoc_list_to_hash(assocs) #:nodoc:
+      head = assocs[0]
+      tail = assocs[1..-1]
+
+      if tail.blank?
+        head
+      elsif tail.size == 1
+        {head => tail[0]}
+      else
+        {head => assoc_list_to_hash(tail)}
+      end
+    end
+
+    def build_includes(existing_includes, new_assocs) #:nodoc:
+      new_includes = if new_assocs.blank?
+        existing_includes
+      else
+        existing_includes = if existing_includes.is_a?(Symbol)
+          [existing_includes]
+        elsif existing_includes.nil?
+          []
+        else
+          existing_includes
+        end
+
+        assocs_as_hash = assoc_list_to_hash(new_assocs)
+        build_includes_int(existing_includes, assocs_as_hash)
+      end
+
+      if new_includes.is_a?(Array) && new_includes.size == 1
+        new_includes[0]
+      else
+        new_includes
+      end
+    end
+
+    def build_includes_int(includes, assocs) #:nodoc:
+      if includes.is_a?(Array)
+        build_includes_includes_is_array(includes, assocs)
+      elsif includes.is_a?(Hash)
+        build_includes_includes_is_hash(includes, assocs)
+      end
+    end
+
+    # TODO: refactor
+    def build_includes_includes_is_hash(includes, assocs) #:nodoc:
+
+      includes_key   = includes.keys[0]
+      includes_value = includes.values[0]
+
+      if assocs.is_a?(Hash)
+        assocs_key   = assocs.keys[0]
+        assocs_value = assocs.values[0]
+
+        if includes_value.is_a?(Symbol) && includes_value == assocs_key
+          {includes_key => assocs}
+        elsif includes_value.is_a?(Hash)
+          if includes_value.keys[0] == assocs_key
+            if includes_value.values[0] == assocs_value
+              {includes_key => assocs}
+            else
+              {includes_key => [includes_value.values[0], assocs_value]}
+            end
+          end
+        end
+      elsif includes_value == assocs
+        {includes_key => assocs}
+      else
+        includes
+      end
+    end
+
+    def build_includes_includes_is_array(includes, assocs) #:nodoc:
+
+      hash_keys = Hash[
+        *(
+          includes
+          .each_with_index
+          .to_a
+          .select{ |e, _idx| e.is_a?(Hash)}
+          .map{ |hash, idx| [ hash.keys[0], idx ] }
+          .flatten
+        )
+      ]
+
+      key_to_search, finished = if assocs.is_a?(Hash)
+        [assocs.keys[0], false]
+      else
+        [assocs, true]
+      end
+
+      if idx = includes.index(key_to_search)
+        if finished #  [:a, :b, :c]  vs  :a
+          includes
+        else        #  [:a, :b, :c]  vs  {:a => x}
+          includes[idx] = assocs
+          includes
+        end
+
+      elsif hash_keys.key?(key_to_search)
+        if finished # [{a: :x}, :b, :c, :d, :e] vs :a
+          includes
+        else
+          hash_idx = hash_keys[key_to_search]
+          assocs_value = assocs[key_to_search]
+          includes[hash_idx] = build_includes_int(includes[hash_idx], assocs_value)
+          includes
+        end
+
+      else  # [:a, :b, :c]  vs  :x
+            # [:a, :b, :c]  vs  {:x => y}
+        includes + [assocs]
+      end
+
+    end
+
+    # checks whether the class is a valid storage for saved queries
+    def validate_query_model(query_store_model)  #:nodoc:
+      unless query_store_model.respond_to?(:list)
+        raise ::Wice::WiceGridArgumentError.new("Model for saving queries #{query_store_model.class.name} is invalid - there is no class method #list defined")
+      end
+      arit = query_store_model.method(:list).arity
+      unless arit == 2
+        raise ::Wice::WiceGridArgumentError.new("Method list in the model for saving queries #{query_store_model.class.name} has wrong arity - it should be 2 instead of #{arit}")
+      end
+      @@model_validated = true
+    end
+
+    # Retrieves and constantizes (if needed ) the Query Store model
+    def get_query_store_model #:nodoc:
+      query_store_model = Wice::ConfigurationProvider.value_for(:QUERY_STORE_MODEL)
+      query_store_model = query_store_model.constantize if query_store_model.is_a? String
+      raise ::Wice::WiceGridArgumentError.new('Defaults::QUERY_STORE_MODEL must be an ActiveRecord class or a string which can be constantized to an ActiveRecord class') unless query_store_model.is_a? Class
+      validate_query_model(query_store_model) unless @@model_validated
+      query_store_model
+    end
+
+    def get_string_matching_operators(model)   #:nodoc:
+      if defined?(Wice::Defaults::STRING_MATCHING_OPERATORS) && (ops = Wice::ConfigurationProvider.value_for(:STRING_MATCHING_OPERATORS)) &&
+          ops.is_a?(Hash) && (str_matching_operator = ops[model.connection.class.to_s])
+        str_matching_operator
+      else
+        Wice::ConfigurationProvider.value_for(:STRING_MATCHING_OPERATOR)
+      end
+    end
+
+    def deprecated_call(old_name, new_name, opts) #:nodoc:
+      if opts[old_name] && !opts[new_name]
+        opts[new_name] = opts[old_name]
+        opts.delete(old_name)
+        STDERR.puts "WiceGrid: Parameter :#{old_name} is deprecated, use :#{new_name} instead!"
+      end
+    end
+
+    def log(message) #:nodoc:
+      ActiveRecord::Base.logger.info('WiceGrid: ' + message) if ActiveRecord::Base.logger
+    end
+  end
+
+  module NlMessage #:nodoc:
+    class << self
+      def [](key) #:nodoc:
+        I18n.t(key, scope: 'wice_grid')
+      end
+    end
+  end
+
+  module ConfigurationProvider #:nodoc:
+    class << self
+      def value_for(key, strict: true) #:nodoc:
+        if Wice::Defaults.const_defined?(key)
+          Wice::Defaults.const_get(key)
+        else
+          if strict
+            raise WiceGridMissingConfigurationConstantException.new("Could not find constant #{key} in the configuration file!" \
+                ' It is possible that the version of WiceGrid you are using is newer than the installed configuration file in config/initializers. ' \
+                "Constant Wice::Defaults::#{key} is missing  and you need to add it manually to wice_grid_config.rb or run the generator task=:\n" \
+                '   rails g wice_grid:install')
+          end # else nil
+        end
+      end
+    end
+  end
+
+  module Defaults  #:nodoc:
+  end
+
+  module ExceptionsMixin  #:nodoc:
+    def initialize(str)  #:nodoc:
+      super('WiceGrid: ' + str)
+    end
+  end
+  class WiceGridArgumentError < ArgumentError #:nodoc:
+    include ExceptionsMixin
+  end
+  class WiceGridException < Exception #:nodoc:
+    include ExceptionsMixin
+  end
+  class WiceGridMissingConfigurationConstantException < Exception #:nodoc:
+    include ExceptionsMixin
+  end
+end