wice_grid 3.5.0 → 3.6.0.pre1

data/lib/wice/kaminari_monkey_patching.rb

@@ -1,4 +1,6 @@
-# It is here only until this pull request is pulled: https://github.com/amatsuda/kaminari/pull/267
+# encoding: utf-8
+
+# Ugly monkey-patching Kaminari (https://github.com/amatsuda/kaminari/pull/267)
 module Kaminari #:nodoc:
   module Helpers #:nodoc:
     class Tag #:nodoc:

data/lib/wice/table_column_matrix.rb

@@ -1,32 +1,44 @@
+# encoding: utf-8
 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
 
-    def initialize()  #:nodoc:
+    # 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}
+      @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 has_key?(model)
+      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 has_key?(model)
+      init_columns_of_table(model) unless key?(model)
       get(model)
     end
 
@@ -35,16 +47,19 @@ module Wice
     end
 
     def get_column_in_default_model_class_by_column_name(column_name)  #:nodoc:
-      raise WiceGridException.new("Cannot search for a column in a default model as the default model is not set") if @default_model_class.nil?
+      if @default_model_class.nil?
+        fail 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}
+      self[model].each_value { |c| c.model = model }
     end
-    alias_method :<< , :init_columns_of_table
 
+    alias_method :<<, :init_columns_of_table
   end
-end
+end

data/lib/wice/wice_grid_controller.rb

@@ -1,12 +1,11 @@
+# encoding: utf-8
 module Wice
-  module Controller
-
+  module Controller #:nodoc:
     def self.included(base) #:nodoc:
       base.extend(ClassMethods)
     end
 
-    module ClassMethods
-
+    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
@@ -28,6 +27,8 @@ module Wice
     # 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.
@@ -63,7 +64,6 @@ module Wice
     # 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?
@@ -112,7 +112,7 @@ module Wice
         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'
+        filename = (grid.csv_file_name || grid.name) + '.csv'
         grid.csv_tempfile.close
         send_file_rails2 temp_filename, filename: filename, type: 'text/csv; charset=utf-8'
         grid.csv_tempfile = nil
@@ -144,29 +144,28 @@ module Wice
       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]
+        fail ::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
+          fail 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]}
+      { "#{options[:grid_name]}[f][#{attr_name}][]" => options[:value] }
     end
 
     private
 
-
     def send_file_rails2(path, options = {}) #:nodoc:
-      raise "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
+      fail "Cannot read file #{path}" unless File.file?(path) && File.readable?(path)
 
-      options[:length]   ||= File.size(path)
+      options[:length] ||= File.size(path)
       options[:filename] ||= File.basename(path) unless options[:url_based_filename]
       send_file_headers_rails2! options
 
@@ -176,7 +175,6 @@ module Wice
       File.open(path, 'rb') { |file| render status: options[:status], text: file.read }
     end
 
-
     DEFAULT_SEND_FILE_OPTIONS_RAILS2 = { #:nodoc:
       type:         'application/octet-stream'.freeze,
       disposition:  'attachment'.freeze,
@@ -186,10 +184,9 @@ module Wice
     }.freeze
 
     def send_file_headers_rails2!(options) #:nodoc:
-
       options.update(DEFAULT_SEND_FILE_OPTIONS_RAILS2.merge(options))
       [:length, :type, :disposition].each do |arg|
-        raise ArgumentError, ":#{arg} option required" if options[arg].nil?
+        fail ArgumentError, ":#{arg} option required" if options[arg].nil?
       end
 
       disposition = options[:disposition].dup || 'attachment'
@@ -214,6 +211,5 @@ module Wice
       # is called for handling the download is run, so let's workaround that
       headers['Cache-Control'] = 'private' if headers['Cache-Control'] == 'no-cache'
     end
-
   end
 end

data/lib/wice/wice_grid_core_ext.rb

@@ -1,13 +1,13 @@
+# encoding: utf-8
 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].kind_of?(Hash)
+          if cloned[k].is_a?(Hash)
             cloned[k] = Wice::WgHash.deep_clone cloned[k]
           end
         end
@@ -18,12 +18,12 @@ module Wice
       # 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.has_key?('class')
+        if hash.key?('class')
           hash[:class] = hash['class']
           hash.delete('class')
         end
 
-        hash[:class] = if hash.has_key?(:class)
+        hash[:class] = if hash.key?(:class)
           if prepend
             "#{klass_value} #{hash[:class]}"
           else
@@ -41,10 +41,9 @@ module Wice
       # 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}
+        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.
@@ -81,53 +80,47 @@ module Wice
 
       def recursively_gather_finite_non_hash_values_with_key_path(hash, res, stack = []) #:nodoc:
         hash.each do |key, value|
-          if value.kind_of?(Hash)
+          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}
+      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('')
+      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:
-      public :tag_options
+      def public_tag_options(options, escape = true) #:nodoc:
+        tag_options(options, escape)
+      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:
@@ -140,11 +133,10 @@ module WGObjectExtensions #:nodoc:
       end
       # return obj if obj.nil?
     end
-    return obj
+    obj
   end
 end
 
 class Object #:nodoc:
   include WGObjectExtensions
 end
-

data/lib/wice/wice_grid_misc.rb

@@ -1,34 +1,150 @@
+# encoding: utf-8
 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")
+        fail ::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}")
+        fail ::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.kind_of? Class
+      fail ::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) && Wice::ConfigurationProvider.value_for(:STRING_MATCHING_OPERATORS).is_a?(Hash) &&
-          str_matching_operator = Wice::ConfigurationProvider.value_for(:STRING_MATCHING_OPERATORS)[model.connection.class.to_s]
+      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)
@@ -36,7 +152,7 @@ module Wice
     end
 
     def deprecated_call(old_name, new_name, opts) #:nodoc:
-      if opts[old_name] && ! opts[new_name]
+      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!"
@@ -48,65 +164,28 @@ module Wice
     end
   end
 
-  module MergeConditions #:nodoc:
-    def self.included(base) #:nodoc:
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods #:nodoc:
-
-      def _sanitize_sql_hash_for_conditions(attrs, default_table_name = self.table_name)
-        attrs = expand_hash_conditions_for_aggregates(attrs)
-
-        table = Arel::Table.new(table_name, arel_engine).alias(default_table_name)
-        ActiveRecord::PredicateBuilder.build_from_hash(self, attrs, table).map { |b|
-          connection.visitor.accept b
-        }.join(' AND ')
-      end
-
-
-      def merge_conditions(*conditions) #:nodoc:
-        segments = []
-
-        conditions.each do |condition|
-          unless condition.blank?
-            sql = condition.is_a?(Hash) ? _sanitize_sql_hash_for_conditions(condition) : sanitize_sql_array(condition)
-            segments << sql unless sql.blank?
-          end
-        end
-
-        "(#{segments.join(') AND (')})" unless segments.empty?
-      end
-    end
-  end
-
-
   module NlMessage #:nodoc:
     class << self
-
       def [](key) #:nodoc:
-        translated = I18n.t(key, scope: 'wice_grid')
+        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")
+            fail 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
 
@@ -115,7 +194,7 @@ module Wice
 
   module ExceptionsMixin  #:nodoc:
     def initialize(str)  #:nodoc:
-      super("WiceGrid: " + str)
+      super('WiceGrid: ' + str)
     end
   end
   class WiceGridArgumentError < ArgumentError #:nodoc:
@@ -127,5 +206,4 @@ module Wice
   class WiceGridMissingConfigurationConstantException < Exception #:nodoc:
     include ExceptionsMixin
   end
-
-end
+end