wice_grid 3.5.0 → 3.6.0.pre1

data/lib/wice/columns/common_js_date_datetime_conditions_generator_mixin.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Wice
+  module Columns #:nodoc:
+    module CommonJsDateDatetimeConditionsGeneratorMixin #:nodoc:
+
+      def generate_conditions(table_alias, opts)   #:nodoc:
+
+        datetime = @column_type == :datetime || @column_type == :timestamp
+
+        conditions = [[]]
+        if opts[:fr]
+          conditions[0] << " #{@column_wrapper.alias_or_table_name(table_alias)}.#{@column_wrapper.name} >= ? "
+          date = opts[:fr].to_date
+          if datetime
+            date = date.to_datetime
+          end
+          conditions << date
+        end
+
+        if opts[:to]
+          op = '<='
+          date = opts[:to].to_date
+          if datetime
+            date = (date + 1).to_datetime
+            op = '<'
+          end
+          conditions[0] << " #{@column_wrapper.alias_or_table_name(table_alias)}.#{@column_wrapper.name} #{op} ? "
+          conditions << date
+        end
+
+        return false if conditions.size == 1
+
+        conditions[0] = conditions[0].join(' and ')
+        conditions
+      end
+
+    end
+  end
+end

data/lib/wice/columns/common_js_date_datetime_mixin.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Wice
+  module Columns #:nodoc:
+    module CommonJsDateDatetimeMixin #:nodoc:
+
+      def prepare #:nodoc:
+        query, _, @name1, @dom_id = form_parameter_name_id_and_query(fr: '')
+        query2, _, @name2, @dom_id2 = form_parameter_name_id_and_query(to: '')
+
+        @queris_ids = [[query, @dom_id], [query2, @dom_id2]]
+      end
+
+    end
+  end
+end

data/lib/wice/columns/{column_date.rb → common_rails_date_datetime_conditions_generator_mixin.rb}

@@ -1,24 +1,7 @@
+# encoding: utf-8
 module Wice
-
   module Columns #:nodoc:
-
-    class ViewColumnDate < ViewColumnDatetime #:nodoc:
-
-      def chunk_names
-        %w(year month day)
-      end
-
-      def render_standard_filter_internal(params) #:nodoc:
-        '<div class="date-filter">' +
-        select_date(params[:fr], {include_blank: true, prefix: @name1, id: @dom_id}) + '<br/>' +
-        select_date(params[:to], {include_blank: true, prefix: @name2, id: @dom_id2}) +
-        '</div>'
-      end
-
-    end
-
-
-    class ConditionsGeneratorColumnDate < ConditionsGeneratorColumn  #:nodoc:
+    module CommonJsDateDatetimeConditionsGeneratorMixin #:nodoc:
 
       def generate_conditions(table_alias, opts)   #:nodoc:
         conditions = [[]]
@@ -37,8 +20,7 @@ module Wice
         conditions[0] = conditions[0].join(' and ')
         conditions
       end
-    end
 
+    end
   end
-
-end
+end

data/lib/wice/columns/common_standard_helper_date_datetime_mixin.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Wice
+  module Columns #:nodoc:
+    module CommonStandardDateDatetimeMixin #:nodoc:
+
+      def prepare #:nodoc:
+        x = lambda do|sym|
+          chunk_names.map do|datetime_chunk_name|
+            triple = form_parameter_name_id_and_query(sym => { datetime_chunk_name => '' })
+            [triple[0], triple[3]]
+          end
+        end
+
+        @queris_ids = x.call(:fr) + x.call(:to)
+
+        _, _, @name1, _ = form_parameter_name_id_and_query(fr: '')
+        _, _, @name2, _ = form_parameter_name_id_and_query(to: '')
+      end
+
+    end
+  end
+end

data/lib/wice/grid_output_buffer.rb

@@ -1,40 +1,49 @@
+# encoding: utf-8
 module Wice
-
   class GridOutputBuffer < String #:nodoc:
 
+    # defines behavior for rendering nonexistent filters.
+    # If return_empty_strings_for_nonexistent_filters is true, a call to render a non existent filter will raise an exception
+    # If return_empty_strings_for_nonexistent_filters is false (CSV mode), no exception will be raised.
     attr_accessor :return_empty_strings_for_nonexistent_filters
 
+    # initializes a grid output buffer
     def initialize(*attrs)
       super(*attrs)
       @filters = HashWithIndifferentAccess.new
     end
 
+    # returns HTML code the grid
     def to_s
       super.html_safe
     end
 
+    # stores HTML code for a detached filter
     def add_filter(detach_with_id, filter_code)
-      raise  WiceGridException.new("Detached ID #{detach_with_id} is already used!") if @filters.has_key? detach_with_id
+      fail WiceGridException.new("Detached ID #{detach_with_id} is already used!") if @filters.key? detach_with_id
       @filters[detach_with_id] = filter_code
     end
 
-    def filter_for detach_with_id
-      unless @filters.has_key? detach_with_id
+    # returns HTML code for a detached filter
+    def filter_for(detach_with_id)
+      unless @filters.key? detach_with_id
         if @return_empty_strings_for_nonexistent_filters
           return ''
         else
-          raise  WiceGridException.new("No filter with Detached ID '#{detach_with_id}'!")
+          fail WiceGridException.new("No filter with Detached ID '#{detach_with_id}'!")
         end
       end
-      if @filters[detach_with_id] == false
-        raise  WiceGridException.new("Filter with Detached ID '#{detach_with_id}' has already been requested once! There cannot be two instances of the same filter on one page")
+
+      unless @filters[detach_with_id]
+        fail WiceGridException.new("Filter with Detached ID '#{detach_with_id}' has already been requested once! There cannot be two instances of the same filter on one page")
       end
+
       res = @filters[detach_with_id]
       @filters[detach_with_id] = false
-      return res
+      res
     end
 
+    # returns HTML code for a detached filter
     alias_method :[], :filter_for
-
   end
-end
+end

data/lib/wice/grid_renderer.rb

@@ -1,32 +1,49 @@
+# encoding: utf-8
 module Wice
-  class GridRenderer
 
+  # Instance of `GridRenderer` is injected into the top level block of the `grid` helper.
+  # `g.column`, `g.action_column` are all examples of methods of `GridRenderer`
+  class GridRenderer
     include ActionView::Helpers::TagHelper
     include ActionView::Helpers::CaptureHelper
     include ActionView::Helpers::TextHelper
     include ActionView::Helpers::AssetTagHelper
     include ActionView::Helpers::JavaScriptHelper
 
-    attr_reader :page_parameter_name
+    # a Proc object for the after_row block
     attr_reader :after_row_handler
+
+    # a Proc object for the before_row block
     attr_reader :before_row_handler
+
+    # a Proc object for the replace_row block
     attr_reader :replace_row_handler
+
+    # Configuration or a Proc object for the blank_slate block
     attr_reader :blank_slate_handler
+
+    # a Proc object which returns contents of the last row
     attr_reader :last_row_handler
+
+    # reference to the WiceGrid instance
     attr_reader :grid
+
+    # Contents of <caption></caption>
     attr_reader :kaption
 
-    @@order_parameter_name = "order"
-    @@order_direction_parameter_name = "order_direction"
-    @@page_parameter_name = "page"
+    # HTTP parameter for the order field
+    ORDER_PARAMETER_NAME           = 'order'
+
+    # HTTP parameter for the order direction (asc/desc)
+    ORDER_DIRECTION_PARAMETER_NAME = 'order_direction'
 
     def initialize(grid, view)  #:nodoc:
-      @grid = grid
-      @grid.renderer = self
-      @columns = []
-      @columns_table = {}
+      @grid                  = grid
+      @grid.renderer         = self
+      @columns               = []
+      @columns_table         = {}
       @action_column_present = false
-      @view = view
+      @view                  = view
     end
 
     def config  #:nodoc:
@@ -37,7 +54,6 @@ module Wice
       @view.controller
     end
 
-
     def add_column(vc)  #:nodoc:
       @columns_table[vc.fully_qualified_attribute_name] = vc if vc.attribute
       @columns << vc
@@ -52,7 +68,7 @@ module Wice
     end
 
     def each_column_label(filter = nil)  #:nodoc:
-      filter_columns(filter).each{|col| yield col.name}
+      filter_columns(filter).each { |col| yield col.name }
     end
 
     def column_labels(filter = nil)  #:nodoc:
@@ -60,12 +76,12 @@ module Wice
     end
 
     def each_column(filter = nil)  #:nodoc:
-      filter_columns(filter).each{|col| yield col}
+      filter_columns(filter).each { |col| yield col }
     end
 
     def each_column_aware_of_one_last_one(filter = nil)  #:nodoc:
       cols = filter_columns(filter)
-      cols[0..-2].each{|col| yield col, false}
+      cols[0..-2].each { |col| yield col, false }
       yield cols.last, true
     end
 
@@ -74,23 +90,24 @@ module Wice
     end
 
     def select_for(filter)  #:nodoc:
-      filter_columns(filter).select{|col| yield col}
+      filter_columns(filter).select { |col| yield col }
     end
 
     def find_one_for(filter)  #:nodoc:
-      filter_columns(filter).find{|col| yield col}
+      filter_columns(filter).find { |col| yield col }
     end
 
-
     def each_column_with_attribute  #:nodoc:
-      @columns.select(&:attribute).each{|col| yield col}
+      @columns.select(&:attribute).each { |col| yield col }
     end
 
     alias_method :each, :each_column
     include Enumerable
 
     def csv_export_icon #:nodoc:
-      content_tag(:div, '',
+      content_tag(
+        :div,
+        content_tag(:i, '', class: 'fa fa-file-excel-o'),
         title: NlMessage['csv_export_tooltip'],
         class: 'clickable export-to-csv-button'
       )
@@ -99,7 +116,7 @@ module Wice
     def pagination_panel(number_of_columns, hide_csv_button)  #:nodoc:
       panel = yield
 
-      render_csv_button = @grid.export_to_csv_enabled && ! hide_csv_button
+      render_csv_button = @grid.export_to_csv_enabled && !hide_csv_button
 
       if panel.nil?
         if render_csv_button
@@ -116,9 +133,9 @@ module Wice
       end
     end
 
-    # Takes one argument and adds the  <caption></caption> tag to the table with the argument value as
-    # the contents of <caption>.
-    def caption kaption
+    # Takes one argument and adds the  <caption></caption> tag to the table with the
+    # argument value as the contents of <caption>.
+    def caption(kaption)
       @kaption = kaption
     end
 
@@ -140,9 +157,8 @@ module Wice
     # +g.column+ definition. If the block returns +nil+ or +false+ no checkbox will be rendered.
 
     def action_column(opts = {}, &block)
-
       if @action_column_present
-        raise Wice::WiceGridException.new('There can be only one action column in a WiceGrid')
+        fail Wice::WiceGridException.new('There can be only one action column in a WiceGrid')
       end
 
       options = {
@@ -150,7 +166,7 @@ module Wice
         html:                {},
         select_all_buttons:  true,
         object_property:     :id,
-        html_check_box:      true,
+        html_check_box:      true
       }
 
       opts.assert_valid_keys(options.keys)
@@ -182,7 +198,7 @@ module Wice
     # * <tt>:class</tt> - a shortcut for <tt>html: {class: 'css_class'}</tt>
     # * <tt>:attribute</tt> - name of a database column (which normally correspond to a model attribute with the
     #   same name). By default the field is assumed to belong to the default table (see documentation for the
-    #   +initialize_grid+ method). Parameter <tt>:model</tt> allows to specify another table. Presence of
+    #   +initialize_grid+ method). Parameter <tt>:assoc</tt> (association) allows to specify another joined table. Presence of
     #   this parameter
     #   * adds sorting capabilities by this field
     #   * automatically creates a filter based on the type of the field unless parameter <tt>:filter</tt> is set to false.
@@ -202,7 +218,7 @@ module Wice
     #   list of available filters.
     # * <tt>:ordering</tt> - Enable/disable ordering links in the column titles. The default is +true+
     #   (i.e. if <tt>:attribute</tt> is defined, ordering is enabled)
-    # * <tt>:model</tt> - Name of the model class to which <tt>:attribute</tt> belongs to if this is not the main table.
+    # * <tt>:assoc</tt> - Name of the model association. <tt>:attribute</tt> belongs to the table joined via this association.
     # * <tt>:table_alias</tt> - In case there are two joined assocations both referring to the same table, ActiveRecord
     #   constructs a query where the second join provides an alias for the joined table. Setting <tt>:table_alias</tt>
     #   to this alias will enable WiceGrid to order and filter by columns belonging to different associatiations  but
@@ -258,9 +274,6 @@ module Wice
     #   to false will prohibit the column from inclusion into the export.
     # * <tt>:in_html</tt> - When CSV export is enabled and it is needed to use a column for CSV export only and ignore it
     #   in HTML, set this parameter to false.
-    # * <tt>:helper_style</tt> - Changes the flavor of Date and DateTime filters. The values are:
-    #   * <tt>:standard</tt> - the default Rails Date/DateTime helper
-    #   * <tt>:calendar</tt> - a Javascript popup calendar control
     # * <tt>:negation</tt> - turn on/off the negation checkbox in string filters
     # * <tt>:auto_reload</tt> - a boolean value specifying if a change in a filter triggers reloading of the grid. Works with all
     #   filter types including the JS calendar, the only exception is the standard Rails date/datetime filters.
@@ -282,44 +295,59 @@ module Wice
 
     def column(opts = {}, &block)
       options = {
-        allow_multiple_selection:    Defaults::ALLOW_MULTIPLE_SELECTION,
-        ordering:                    true,
+        allow_multiple_selection:    ConfigurationProvider.value_for(:ALLOW_MULTIPLE_SELECTION),
+        assoc:                       nil,
         attribute:                   nil,
-        auto_reload:                 Defaults::AUTO_RELOAD,
+        auto_reload:                 ConfigurationProvider.value_for(:AUTO_RELOAD),
         boolean_filter_false_label:  NlMessage['boolean_filter_false_label'],
         boolean_filter_true_label:   NlMessage['boolean_filter_true_label'],
         class:                       nil,
-        name:                        '',
         custom_filter:               nil,
         detach_with_id:              nil,
-        filter_all_label:            Defaults::CUSTOM_FILTER_ALL_LABEL,
-        helper_style:                Defaults::HELPER_STYLE,
-        in_csv:                      true,
-        in_html:                     true,
-        model:                       nil,
-        negation:                    Defaults::NEGATION_IN_STRING_FILTERS,
         filter:                      true,
+        filter_all_label:            ConfigurationProvider.value_for(:CUSTOM_FILTER_ALL_LABEL),
         filter_type:                 nil,
-        table_alias:                 nil,
-        html:                        {}
+        html:                        {},
+        in_csv:                      true,
+        in_html:                     true,
+        model:                       nil, # will throw an exception with instructions
+        name:                        '',
+        negation:                    ConfigurationProvider.value_for(:NEGATION_IN_STRING_FILTERS),
+        ordering:                    true,
+        table_alias:                 nil
       }
 
       opts.assert_valid_keys(options.keys)
       options.merge!(opts)
 
-      unless options[:model].nil?
-        options[:model] = options[:model].constantize if options[:model].is_a? String
-        raise WiceGridArgumentError.new("Option :model can be either a class or a string instance") unless options[:model].is_a? Class
+      assocs = nil
+
+      if options[:model]
+        fail WiceGridArgumentError.new('Instead of specifying a model of a joined table please use assoc: :name_of_association')
+      end
+
+      unless options[:assoc].nil?
+
+        unless options[:assoc].is_a?(Symbol) ||
+              (options[:assoc].is_a?(Array) && ! options[:assoc].empty? && options[:assoc].all?{ |assoc| assoc.is_a?(Symbol)})
+
+          fail WiceGridArgumentError.new('Option :assoc can only be a symbol or an array of symbols')
+        end
+
+        assocs = options[:assoc].is_a?(Symbol) ? [options[:assoc]] : options[:assoc]
+
+        options[:model] = get_model_from_associations(@grid.klass, assocs)
       end
 
       if options[:attribute].nil? && options[:model]
-        raise WiceGridArgumentError.new("Option :model is only used together with :attribute")
+        fail WiceGridArgumentError.new('Option :assoc is only used together with :attribute')
       end
 
       if options[:attribute] && options[:attribute].index('.')
-        raise WiceGridArgumentError.new("Invalid attribute name #{options[:attribute]}. An attribute name must not contain a table name!")
+        fail WiceGridArgumentError.new("Invalid attribute name #{options[:attribute]}. An attribute name must not contain a table name!")
       end
 
+
       if options[:class]
         options[:html] ||= {}
         Wice::WgHash.add_or_append_class_value!(options[:html], options[:class])
@@ -327,29 +355,41 @@ module Wice
       end
 
       if block.nil?
-        if ! options[:attribute].blank?
-          block = lambda{|obj| obj.send(options[:attribute])}
+        if !options[:attribute].blank?
+          if assocs.nil?
+            block = ->(obj) { obj.send(options[:attribute]) }
+          else
+            messages = assocs + [ options[:attribute] ]
+            block = ->(obj) { obj.deep_send(*messages) }
+          end
         else
-          raise WiceGridArgumentError.new(
-            "Missing column block without attribute defined. You can only omit the block if attribute is present.")
+          fail WiceGridArgumentError.new(
+            'Missing column block without attribute defined. You can only omit the block if attribute is present.')
         end
       end
 
       klass = Columns::ViewColumn
       if options[:attribute] &&
-          col_type_and_table_name = @grid.declare_column(options[:attribute], options[:model],
-            options[:custom_filter],  options[:table_alias], options[:filter_type])
-
+        col_type_and_table_name = @grid.declare_column(
+          column_name:          options[:attribute],
+          model:                options[:model],
+          custom_filter_active: options[:custom_filter],
+          table_alias:          options[:table_alias],
+          filter_type:          options[:filter_type],
+          assocs:               assocs
+        )
+
+        # [ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::Column, String, Boolean]
         db_column, table_name, main_table = col_type_and_table_name
         col_type = db_column.type
 
         if options[:custom_filter]
 
           custom_filter = if options[:custom_filter] == :auto
-            lambda{ @grid.distinct_values_for_column(db_column) } # Thank God Ruby has higher order functions!!!
+            -> { @grid.distinct_values_for_column(db_column) } # Thank God Ruby has higher order functions!!!
 
           elsif options[:custom_filter].class == Symbol
-            lambda{ @grid.distinct_values_for_column_in_resultset([options[:custom_filter]])}
+            -> { @grid.distinct_values_for_column_in_resultset([options[:custom_filter]]) }
 
           elsif options[:custom_filter].class == Hash
             options[:custom_filter].keys
@@ -360,19 +400,19 @@ module Wice
             if options[:custom_filter].empty?
               []
             elsif Wice::WgEnumerable.all_items_are_of_class(options[:custom_filter], Symbol)
-              lambda{ @grid.distinct_values_for_column_in_resultset(options[:custom_filter]) }
+              -> { @grid.distinct_values_for_column_in_resultset(options[:custom_filter]) }
 
             elsif Wice::WgEnumerable.all_items_are_of_class(options[:custom_filter], String) || WgEnumerable.all_items_are_of_class(options[:custom_filter], Numeric)
-              options[:custom_filter].map{|i| [i,i]}
+              options[:custom_filter].map { |i| [i, i] }
 
             elsif Wice::WgEnumerable.all_items_are_of_class(options[:custom_filter], Array)
               options[:custom_filter]
             else
-              raise WiceGridArgumentError.new(
-                ':custom_filter can equal :auto, an array of string and/or numbers (direct values for the dropdown), ' +
-                'a homogeneous array of symbols (a sequence of methods to send to AR objects in the result set to ' +
-                'retrieve unique values for the dropdown), a Symbol (a shortcut for a one member array of symbols), ' +
-                'a hash where keys are labels and values are values for the dropdown option, or an array of two-item arrays, ' +
+              fail WiceGridArgumentError.new(
+                ':custom_filter can equal :auto, an array of string and/or numbers (direct values for the dropdown), ' \
+                'a homogeneous array of symbols (a sequence of methods to send to AR objects in the result set to ' \
+                'retrieve unique values for the dropdown), a Symbol (a shortcut for a one member array of symbols), ' \
+                'a hash where keys are labels and values are values for the dropdown option, or an array of two-item arrays, ' \
                 'each of which contains the label (first element) and the value (second element) for a dropdown option'
                 )
             end
@@ -382,6 +422,18 @@ module Wice
         elsif options[:filter_type]
           klass = Columns.get_view_column_processor(options[:filter_type])
         else
+
+          col_type = case col_type
+          when :date
+            Wice::Defaults::DEFAULT_FILTER_FOR_DATE
+          when :datetime
+            Wice::Defaults::DEFAULT_FILTER_FOR_DATETIME
+          when :timestamp
+            Wice::Defaults::DEFAULT_FILTER_FOR_DATETIME
+          else
+            col_type
+          end
+
           klass = Columns.get_view_column_processor(col_type)
         end # custom_filter
 
@@ -391,14 +443,30 @@ module Wice
 
       vc.negation = options[:negation] if vc.respond_to? :negation=
 
-      vc.filter_all_label = options[:filter_all_label] if vc.kind_of?(Columns.get_view_column_processor(:custom))
-      if vc.kind_of?(Columns.get_view_column_processor(:boolean))
+      vc.filter_all_label = options[:filter_all_label] if vc.is_a?(Columns.get_view_column_processor(:custom))
+      if vc.is_a?(Columns.get_view_column_processor(:boolean))
         vc.boolean_filter_true_label = options[:boolean_filter_true_label]
         vc.boolean_filter_false_label = options[:boolean_filter_false_label]
       end
       add_column(vc)
     end
 
+    def get_model_from_associations(model, assocs) # :nodoc:
+      if assocs.empty?
+        model
+      else
+        head = assocs[0]
+        tail = assocs[1..-1]
+
+        if reflection = model.reflect_on_association(head)
+          next_model = reflection.klass
+          get_model_from_associations(next_model, tail)
+        else
+          fail WiceGridArgumentError.new("Association #{head} not found in #{model}")
+        end
+      end
+    end
+
     # Optional method inside the +grid+ block, to which every ActiveRecord instance is injected, just like +column+.
     # Unlike +column+, it returns a hash which will be used as HTML attributes for the row with the given ActiveRecord instance.
     #
@@ -431,28 +499,28 @@ module Wice
     def last_row(&block)
       @last_row_handler = block
     end
+
     # The output of the block submitted to +blank_slate+ is rendered instead of the whole grid if no filters are active
     # and there are no records to render.
     # In addition to the block style two other variants are accepted:
     # *   <tt>g.blank_slate "some text to be rendered"</tt>
     # *   <tt>g.blank_slate partial: "partial_name"</tt>
     def blank_slate(opts = nil, &block)
-      if (opts.is_a?(Hash) && opts.has_key?(:partial) && block.nil?) || (opts.is_a?(String) && block.nil?)
+      if (opts.is_a?(Hash) && opts.key?(:partial) && block.nil?) || (opts.is_a?(String) && block.nil?)
         @blank_slate_handler = opts
       elsif opts.nil? && block
         @blank_slate_handler = block
       else
-        raise WiceGridArgumentError.new("blank_slate accepts only a string, a block, or template: 'path_to_template' ")
+        fail WiceGridArgumentError.new("blank_slate accepts only a string, a block, or template: 'path_to_template' ")
       end
     end
 
-
     def get_row_attributes(ar_object) #:nodoc:
       if @row_attributes_handler
         row_attributes = @row_attributes_handler.call(ar_object)
         row_attributes = {} if row_attributes.blank?
         unless row_attributes.is_a?(Hash)
-          raise WiceGridArgumentError.new("row_attributes block must return a hash containing HTML attributes. The returned value is #{row_attributes.inspect}")
+          fail WiceGridArgumentError.new("row_attributes block must return a hash containing HTML attributes. The returned value is #{row_attributes.inspect}")
         end
         row_attributes
       else
@@ -460,13 +528,12 @@ module Wice
       end
     end
 
-
     def no_filter_needed?   #:nodoc:
-      not @columns.inject(false){|a,b| a || b.filter_shown? }
+      !@columns.inject(false) { |a, b| a || b.filter_shown? }
     end
 
     def no_filter_needed_in_main_table?   #:nodoc:
-      not @columns.inject(false){|a,b| a || b.filter_shown_in_main_table? }
+      !@columns.inject(false) { |a, b| a || b.filter_shown_in_main_table? }
     end
 
     def base_link_for_filter(controller, extra_parameters = {})   #:nodoc:
@@ -500,19 +567,17 @@ module Wice
       controller.url_for(new_params)
     end
 
-
     def column_link(column, direction, params, extra_parameters = {})   #:nodoc:
-
-      column_attribute_name = if column.attribute.index('.') or column.main_table
+      column_attribute_name = if column.attribute.index('.') || column.main_table
         column.attribute
       else
         column.table_alias_or_table_name + '.' + column.attribute
       end
 
-      query_params = {@grid.name => {
-        @@order_parameter_name           => column_attribute_name,
-        @@order_direction_parameter_name => direction
-      }}
+      query_params = { @grid.name => {
+        ORDER_PARAMETER_NAME           => column_attribute_name,
+        ORDER_DIRECTION_PARAMETER_NAME => direction
+      } }
 
       cleaned_params =  Wice::WgHash.deep_clone params
       cleaned_params.merge!(extra_parameters)
@@ -520,16 +585,13 @@ module Wice
       cleaned_params.delete(:controller)
       cleaned_params.delete(:action)
 
-
       query_params = Wice::WgHash.rec_merge(cleaned_params, query_params)
 
       '?' + query_params.to_query
     end
 
-
     protected
 
-
     def filter_columns(method_name = nil) #:nodoc:
       method_name ? @columns.select(&method_name) : @columns
     end
@@ -541,8 +603,7 @@ module Wice
       # /foo?grid=some_value --> /foo?grid=some_value
 
       empty_hash_rx = Regexp.new "([&?])#{Regexp.escape @grid.name}=([&?]|$)" # c.f., issue #140
-      url.gsub(empty_hash_rx, '\1').gsub /\?+$/, ''
+      url.gsub(empty_hash_rx, '\1').gsub(/\?+$/, '')
     end
-
   end
 end