pwice_grid 5.0.0

data/lib/generators/wice_grid/add_migration_for_serialized_queries_generator.rb

@@ -0,0 +1,19 @@
+module WiceGrid #:nodoc:
+  module Generators #:nodoc:
+    class AddMigrationForSerializedQueriesGenerator < Rails::Generators::Base  #:nodoc:
+      include Rails::Generators::Migration
+
+      desc 'Add a migration which creates a table for serialized queries'
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def self.next_migration_number(_path)
+        Time.now.utc.strftime('%Y%m%d%H%M%S')
+      end
+
+      def create_model_file
+        migration_template 'create_wice_grid_serialized_queries.rb', 'db/migrate/create_wice_grid_serialized_queries.rb'
+      end
+    end
+  end
+end

data/lib/generators/wice_grid/install_generator.rb

@@ -0,0 +1,13 @@
+module WiceGrid #:nodoc:
+  module Generators #:nodoc:
+    class InstallGenerator < Rails::Generators::Base #:nodoc:
+      desc 'Copy WiceGrid wice_grid_config.rb to config/initializers'
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_stuff #:nodoc:
+        template 'wice_grid_config.rb', 'config/initializers/wice_grid_config.rb'
+      end
+    end
+  end
+end

data/lib/generators/wice_grid/templates/create_wice_grid_serialized_queries.rb

@@ -0,0 +1,13 @@
+class CreateWiceGridSerializedQueries < ::ActiveRecord::Migration #:nodoc:
+  def change #:nodoc:
+    create_table :wice_grid_serialized_queries do |t|
+      t.column :name,      :string
+      t.column :grid_name, :string
+      t.column :query,     :text
+
+      t.timestamps
+    end
+    add_index :wice_grid_serialized_queries, :grid_name
+    add_index :wice_grid_serialized_queries, [:grid_name, :id]
+  end
+end

data/lib/generators/wice_grid/templates/wice_grid_config.rb

@@ -0,0 +1,191 @@
+if defined?(Wice::Defaults)
+
+  # Default number of rows to show per page.
+  Wice::Defaults::PER_PAGE = 20
+
+  # Default order direction
+  Wice::Defaults::ORDER_DIRECTION = 'asc'
+
+  # Default name for a grid. A grid name is the basis for a lot of
+  # names including parameter names, DOM IDs, etc
+  # The shorter the name is the shorter the request URI will be.
+  Wice::Defaults::GRID_NAME = 'grid'
+
+  # If REUSE_LAST_COLUMN_FOR_FILTER_ICONS is true and the last column doesn't have any filter and column name, it will be used
+  # for filter related icons (filter icon, reset icon, show/hide icon), otherwise an additional table column is added.
+  Wice::Defaults::REUSE_LAST_COLUMN_FOR_FILTER_ICONS = true
+
+  # The label of the first option of a custom dropdown list meaning 'All items'
+  Wice::Defaults::CUSTOM_FILTER_ALL_LABEL = '--'
+
+  # A list of classes for the table tag of the grid
+  Wice::Defaults::DEFAULT_TABLE_CLASSES = ['table', 'table-bordered', 'table-striped']
+
+  # Allow switching between a single and multiple selection modes in custom filters (dropdown boxes)
+  Wice::Defaults::ALLOW_MULTIPLE_SELECTION = true
+
+  # Show the upper pagination panel by default or not
+  Wice::Defaults::SHOW_UPPER_PAGINATION_PANEL = false
+
+  # Disabling CSV export by default
+  Wice::Defaults::ENABLE_EXPORT_TO_CSV = false
+
+  # Default CSV field separator
+  Wice::Defaults::CSV_FIELD_SEPARATOR = ','
+
+  # Default CSV encoding (p.e. 'CP1252:UTF-8' to make Microsoft Excel(tm) happy)
+  Wice::Defaults::CSV_ENCODING = nil
+
+  # The strategy when to show the filter.
+  # * <tt>:when_filtered</tt> - when the table is the result of filtering
+  # * <tt>:always</tt>        - show the filter always
+  # * <tt>:no</tt>            - never show the filter
+  Wice::Defaults::SHOW_FILTER = :always
+
+  # A boolean value specifying if a change in a filter triggers reloading of the grid.
+  Wice::Defaults::AUTO_RELOAD = false
+
+  # SQL operator used for matching strings in string filters.
+  Wice::Defaults::STRING_MATCHING_OPERATOR = 'LIKE'
+  # STRING_MATCHING_OPERATOR = 'ILIKE' # Use this for Postgresql case-insensitive matching.
+
+  # Defining one string matching operator globally for the whole application turns is not enough
+  # when you connect to two databases one of which is MySQL and the other is Postgresql.
+  # If the key for an adapter is missing it will fall back to Wice::Defaults::STRING_MATCHING_OPERATOR.
+  #
+  # 'CI_LIKE' is a special value. Setting a value in STRING_MATCHING_OPERATORS to CI_LIKE will result in the following SQL:
+  #
+  #    UPPER(table.field) LIKE  UPPER(?)"
+  Wice::Defaults::STRING_MATCHING_OPERATORS = {
+    'ActiveRecord::ConnectionAdapters::MysqlAdapter'      => 'LIKE',
+    'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter' => 'ILIKE'
+  }
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+  #                              Advanced Filters                             #
+
+  # Switch of the negation checkbox in all text filters
+  Wice::Defaults::NEGATION_IN_STRING_FILTERS = false
+
+  # Each WiceGrid filter column is defined in two classes, one used for rendering the filter, the other
+  # for generating query conditions. All these columns are in lib/wice/columns/*.rb .
+  # File lib/wice/columns/column_processor_index.rb lists all predefined processors.
+  # In most cases a processor is chosen automatically based on the DB column type,
+  # for example, integer columns
+  # can have two of processors, the default one with one input field, and a processor called "range",
+  # with 2 input fields. In this case it is possible to specify a processor in the column definition:
+  #
+  #     g.column filter_type: :range
+  #
+  # It is also possible to define you own processors:
+  #
+  #     Wice::Defaults::ADDITIONAL_COLUMN_PROCESSORS = {
+  #       some_key_identifying_new_column_type:  ['AViewColumnProcessorClass', 'ConditionsGeneratorClass'],
+  #       another_key_identifying_new_column_type:  ['AnotherViewColumnProcessorClass', 'AnotherConditionsGeneratorClass']
+  #     }
+  #
+  # Column processor keys/names should not coincide with the existing keys/names (see lib/wice/columns/column_processor_index.rb)
+  # the value is a 2-element array with 2 strings, the first should be a name of view processor class inherited from
+  # Wice::Columns::ViewColumn, the second should be a name of conditions generator class inherited from
+  # Wice::Columns::ConditionsGeneratorColumn .
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+  #                              Showing All Records                          #
+
+  # Enable or disable showing all records (non-paginated table)
+  Wice::Defaults::ALLOW_SHOWING_ALL_RECORDS = true
+
+  # If number of all queries is more than this value, the user will be given a warning message
+  Wice::Defaults::START_SHOWING_WARNING_FROM = 100
+
+  # Hide the "show all" link if the number of all records is more than...
+  # Force-resets back to pagination starting from this value.
+  # Set to nil to always show it
+  Wice::Defaults::SHOW_ALL_ALLOWED_UP_TO = nil
+
+  #
+  # set to nil to skip the check
+  Wice::Defaults::SWITCH_BACK_TO_PAGINATION_FROM = nil
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+  #                               Saving Queries                              #
+
+  # ActiveRecord model to store queries. Read the documentation for details
+  # QUERY_STORE_MODEL = 'WiceGridSerializedQuery'
+  Wice::Defaults::QUERY_STORE_MODEL = 'WiceGridSerializedQuery'
+
+  # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+  #            Here go settings related to the date/datetime filters          #
+
+  # Default column filters
+  # Possible values:
+  # * <tt>:jquery_datepicker</tt> - Jquery datepicker (works for datetime, too)
+  # * <tt>:bootstrap_datepicker</tt> - Bootstrap datepicker (works for datetime, too)
+  # * <tt>:rails_date_helper</tt> - standard Rails date helper
+  # * <tt>:rails_datetime_helper</tt> - standard Rails datetime helper
+
+  Wice::Defaults::DEFAULT_FILTER_FOR_DATE     = :jquery_datepicker
+  Wice::Defaults::DEFAULT_FILTER_FOR_DATETIME = :jquery_datepicker
+
+  # Format of the datetime displayed.
+  # If you change the format, make sure to check if +DATETIME_PARSER+ can still parse this string.
+  Wice::Defaults::DATETIME_FORMAT = '%Y-%m-%d %H:%M'
+
+  # Format of the date displayed.
+  # If you change the format, make sure to check if +DATE_PARSER+ can still parse this string.
+  Wice::Defaults::DATE_FORMAT = '%Y-%m-%d'
+
+  # Format of the date displayed in jQuery's Datepicker
+  # If you change the format, make sure to check if +DATE_PARSER+ can still parse this string.
+  Wice::Defaults::DATE_FORMAT_JQUERY =  'yy-mm-dd'
+
+  # Format of the date displayed in Bootstrap's Datepicker
+  # If you change the format, make sure to check if +DATE_PARSER+ can still parse this string.
+  Wice::Defaults::DATE_FORMAT_BOOTSTRAP =  'yyyy-mm-dd'
+
+  # With Calendar helpers enabled the parameter sent is the string displayed. This lambda will be given a date string in the
+  # format defined by +DATETIME_FORMAT+ and must generate a DateTime object.
+  # In many cases <tt>Time.zone.parse</tt> is enough, for instance,  <tt>%Y-%m-%d</tt>. If you change the format, make sure to check this code
+  # and modify it if needed.
+  Wice::Defaults::DATETIME_PARSER = lambda do|datetime_string|
+    if datetime_string.blank?
+      nil
+    elsif Time.zone
+      Time.zone.parse(datetime_string)
+    else
+      Time.parse(datetime_string)
+    end
+  end
+
+  # The range of years to display in jQuery Datepicker.
+  # It can always be changed dynamically with the following javascript:
+  #  $( ".hasDatepicker" ).datepicker( "option", "yearRange", "2000:2042" );
+  Wice::Defaults::DATEPICKER_YEAR_RANGE = (from = Date.current.year - 10).to_s + ':' + (from + 15).to_s
+
+  # With Calendar helpers enabled the parameter sent is the string displayed. This lambda will be given a date string in the
+  # format defined by +DATETIME+ and must generate a Date object.
+  # In many cases <tt>Date.parse</tt> is enough, for instance,  <tt>%Y-%m-%d</tt>. If you change the format, make sure to check this code
+  # and modify it if needed.
+  Wice::Defaults::DATE_PARSER = lambda do|date_string|
+    if date_string.blank?
+      nil
+    else
+      begin
+        Date.parse(date_string)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+
+  # The name of the page method (should correspond to Kaminari.config.page_method_name)
+  Wice::Defaults::PAGE_METHOD_NAME = :page
+
+  # The name of the theme to use for the pagination with Kaminari
+  Wice::Defaults::PAGINATION_THEME = :wice_grid
+
+  # By default ActiveRecord calls are always executed inside Model.unscoped{}.
+  # Setting <tt>USE_DEFAULT_SCOPE</tt> to true will use the default scope for all queries.
+  Wice::Defaults::USE_DEFAULT_SCOPE = false
+
+end

data/lib/wice/active_record_column_wrapper.rb

@@ -0,0 +1,122 @@
+module Wice
+  # to be mixed in into ActiveRecord::ConnectionAdapters::Column
+  module WiceGridExtentionToActiveRecordColumn #:nodoc:
+    # reference to the ActiveRecord model class
+    attr_accessor :model
+  end
+
+  class ActiveRecordColumnWrapper #:nodoc:
+    def initialize(column, all_filter_params, main_table, table_alias, custom_filter_active, filter_type) #:nodoc:
+      @column = column
+
+      # nil | Symbol
+      @filter_type          = filter_type
+
+      # Hash { String => String | Array[String]}
+      @all_filter_params    = all_filter_params
+
+      # nil | Boolean
+      @main_table           = main_table
+
+      # nil | String
+      @table_alias          = table_alias
+
+      # nil | Array[String] | Array[Array[...]] | Array[Symbol]
+      @custom_filter_active = custom_filter_active
+    end
+
+    def wg_initialize_request_parameters  #:nodoc:
+      @request_params = nil
+      return if @all_filter_params.nil?
+
+      # if the parameter does not specify the table name we only allow columns in the default table to use these parameters
+      if @main_table && @request_params = @all_filter_params[@column.name]
+        current_parameter_name = @column.name
+      elsif @request_params = @all_filter_params[alias_or_table_name(@table_alias) + '.' + @column.name]
+        current_parameter_name = alias_or_table_name(@table_alias) + '.' + @column.name
+      end
+
+      # Preprocess incoming parameters for datetime, if what's coming in is
+      # a datetime (with custom_filter it can be anything else, and not
+      # the datetime hash {fr: ..., to: ...})
+      if @request_params
+
+        if (@column.type == :datetime || @column.type == :timestamp) && @request_params.is_a?(Hash)
+          [:fr, :to].each do |sym|
+            if @request_params[sym]
+              if @request_params[sym].is_a?(String)
+                @request_params[sym] = Wice::ConfigurationProvider.value_for(:DATETIME_PARSER).call(@request_params[sym])
+              elsif @request_params[sym].is_a?(Hash)
+                @request_params[sym] = Wice::GridTools.params_2_datetime(@request_params[sym])
+              end
+            end
+          end
+
+        end
+
+        # Preprocess incoming parameters for date, if what's coming in is
+        # a date (with custom_filter it can be anything else, and not
+        # the date hash {fr: ..., to: ...})
+        if @column.type == :date && @request_params.is_a?(Hash)
+
+          [:fr, :to].each do |sym|
+            if @request_params[sym]
+              if @request_params[sym].is_a?(String)
+                @request_params[sym] = Wice::ConfigurationProvider.value_for(:DATE_PARSER).call(@request_params[sym])
+              elsif @request_params[sym].is_a?(Hash)
+                @request_params[sym] = ::Wice::GridTools.params_2_date(@request_params[sym])
+              end
+            end
+          end
+
+        end
+      end
+
+      [wg_generate_conditions, current_parameter_name]
+    end
+
+    def wg_generate_conditions  #:nodoc:
+      return nil if @request_params.nil?
+
+      if @custom_filter_active
+        custom_processor_klass = ::Wice::Columns.get_conditions_generator_column_processor(:custom)
+        custom_processor = custom_processor_klass.new(self)
+        return custom_processor.generate_conditions(@table_alias, @request_params)
+      end
+
+      column_type = @filter_type || @column.type.to_s.intern
+
+      filter_type = case column_type
+      when :date
+        ConfigurationProvider.value_for(:DEFAULT_FILTER_FOR_DATE)
+      when :datetime
+        ConfigurationProvider.value_for(:DEFAULT_FILTER_FOR_DATETIME)
+      when :timestamp
+        ConfigurationProvider.value_for(:DEFAULT_FILTER_FOR_DATETIME)
+      else
+        column_type
+      end
+
+      processor_class = ::Wice::Columns.get_conditions_generator_column_processor(filter_type)
+
+      if processor_class
+        return processor_class.new(self, column_type).generate_conditions(@table_alias, @request_params)
+      else
+        Wice.log("No processor for database type #{column_type}!!!")
+        nil
+      end
+    end
+
+    def name #:nodoc:
+      @column.name
+    end
+
+    def model #:nodoc:
+      @column.model
+    end
+
+    def alias_or_table_name(table_alias) #:nodoc:
+      table_alias || @column.model.table_name
+    end
+  end
+end

data/lib/wice/columns.rb

@@ -0,0 +1,282 @@
+module Wice #:nodoc:
+  module Columns #:nodoc:
+    mattr_reader :handled_type_view, :handled_type_conditions_generator
+
+    class << self #:nodoc:
+      def load_column_processors #:nodoc:
+        require_columns
+
+        @@handled_type_view                 = build_table_of_processors 'view'
+        @@handled_type_conditions_generator = build_table_of_processors 'conditions_generator'
+
+        if Wice::Defaults.const_defined?(:ADDITIONAL_COLUMN_PROCESSORS)
+
+          common_error_prefix = 'Error loading Wice::Defaults::ADDITIONAL_COLUMN_PROCESSORS. '
+
+          Wice::Defaults::ADDITIONAL_COLUMN_PROCESSORS.each do |key, value|
+            unless key.is_a?(Symbol)
+              raise common_error_prefix + 'A key of Wice::Defaults::ADDITIONAL_COLUMN_PROCESSORS should be a Symbol!'
+            end
+
+            if @@handled_type_view.key?(key)
+              raise common_error_prefix +
+                "Column with key \"#{key}\" already exists in WiceGrid, overwriting existing columns is forbidden, please choose another key!"
+            end
+
+            if !value.is_a?(Array) || value.size != 2
+              ail common_error_prefix +
+                'A value of Wice::Defaults::ADDITIONAL_COLUMN_PROCESSORS should be a a 2-element array!'
+            end
+
+            view_processor, conditions_generator = value.map(&:to_s).map do |klass|
+              begin
+                eval(klass)
+              rescue NameError
+                raise common_error_prefix + "Class #{klass} is not defined!"
+              end
+            end
+
+            unless view_processor.ancestors.include?(::Wice::Columns::ViewColumn)
+              raise common_error_prefix +
+                "#{view_processor} should be inherited from Wice::Columns::ViewColumn!"
+            end
+
+            unless conditions_generator.ancestors.include?(::Wice::Columns::ConditionsGeneratorColumn)
+              raise common_error_prefix +
+                "#{conditions_generator} should be inherited from Wice::Columns::ConditionsGeneratorColumn!"
+            end
+
+            @@handled_type_view[key] = view_processor
+            @@handled_type_conditions_generator[key] = conditions_generator
+          end
+        end
+      end
+
+      def get_view_column_processor(column_type) #:nodoc:
+        @@handled_type_view[column_type] || ViewColumn
+      end
+
+      def get_conditions_generator_column_processor(column_type) #:nodoc:
+        column_type = column_type.intern if column_type.is_a? String
+        @@handled_type_conditions_generator[column_type] || raise("Could not find conditions generator processor for column_type #{column_type}")
+      end
+
+      private
+
+      def build_table_of_processors(prefix)
+        {}.tap do |processor_table|
+          loaded_processors = {}
+
+          Wice::Columns::COLUMN_PROCESSOR_INDEX.each do |column_type, column_source_file|
+            unless loaded_processors[column_source_file]
+              processor_class_name = "#{prefix}_#{column_source_file}".classify
+
+              unless Wice::Columns.const_defined?(processor_class_name.intern)
+                raise "#{column_source_file}.rb is expected to define #{processor_class_name}!"
+              end
+              processor_class = eval("Wice::Columns::#{processor_class_name}")
+
+              loaded_processors[column_source_file] = processor_class
+            end
+
+            processor_table[column_type] = loaded_processors[column_source_file]
+          end
+        end
+      end
+
+      def require_columns
+        Wice::Columns::COLUMN_PROCESSOR_INDEX.values.uniq do |column_source_file|
+          require "wice/columns/#{column_source_file}.rb"
+        end
+      end
+    end
+
+    class ViewColumn  #:nodoc:
+      include ActionView::Helpers::FormTagHelper
+      include ActionView::Helpers::TagHelper
+      include ActionView::Helpers::JavaScriptHelper
+      include ActionView::Helpers::AssetTagHelper
+
+      # fields defined from the options parameter
+      FIELDS = [:attribute, :name, :html, :filter, :model, :allow_multiple_selection,
+                :in_html, :in_csv, :table_alias, :custom_order, :detach_with_id, :ordering, :auto_reload,
+                :filter_control_options, :sort_by]
+
+      attr_accessor(*FIELDS)
+
+      # a Proc object which would return contents of one cell
+      attr_accessor :cell_rendering_block
+
+      # reference to the WiceGrid instance
+      attr_accessor :grid
+
+      # name of the table
+      attr_accessor :table_name
+
+      # name of the main table (first argument to initialize_grid)
+      attr_accessor :main_table
+
+      # attr_accessor :model
+
+      # specification for a custom filter: an array of option label + option value pairs for the select, or a Proc object which returns this array.
+      # Or nil if it is not a custom filter
+      attr_accessor :custom_filter
+
+      # A boolean flag: whether a column has a text input or not
+      attr_reader :contains_a_text_input
+
+      # options for rendering filter controls. Supported options are specific to the type.
+      attr_accessor :filter_control_options
+
+      def initialize(block, options, grid_obj, tname, mtable, cfilter, view)  #:nodoc:
+        self.cell_rendering_block = block
+        self.grid           = grid_obj
+        self.table_name     = tname
+        self.main_table     = mtable
+        self.custom_filter  = cfilter
+        @view = view
+
+        FIELDS.each do |field|
+          self.send(field.to_s + '=', options[field])
+        end
+      end
+
+      def add_css_class(klass_value) #:nodoc:
+        self.html ||= {}
+        if html[:class].nil?
+          html[:class] = klass_value
+        else
+          html[:class] << ' ' unless html[:class].empty?
+          html[:class] << klass_value
+        end
+      end
+
+      def css_class #:nodoc:
+        if html && html[:class]
+          html[:class]
+        else
+          ''
+        end
+      end
+
+      def yield_declaration_of_column_filter #:nodoc:
+        nil
+      end
+
+      def detachness #:nodoc:
+        (!detach_with_id.blank?).to_s
+      end
+
+      def yield_declaration #:nodoc:
+        declaration = yield_declaration_of_column_filter
+        if declaration
+          {
+            filterName:  self.name,
+            detached:    detachness,
+            declaration: declaration
+          }
+        end
+      end
+
+      def config  #:nodoc:
+        @view.config
+      end
+
+      def controller  #:nodoc:
+        @view.controller
+      end
+
+      def render_filter #:nodoc:
+        params = @grid.filter_params(self)
+        render_filter_internal(params)
+      end
+
+      def render_filter_internal(_params) #:nodoc:
+        '<!-- implement me! -->'
+      end
+
+      def form_parameter_name_id_and_query(v) #:nodoc:
+        query = form_parameter_template(v)
+        query_without_equals_sign = query.sub(/=$/, '')
+        parameter_name = CGI.unescape(query_without_equals_sign)
+        dom_id = id_out_of_name(parameter_name)
+        [query, query_without_equals_sign, parameter_name, dom_id.tr('.', '_')]
+      end
+
+      # Returns a reference to the column in the form: "table_name.column_name", unless it is a column in the main
+      # table, in which case it will return just "column_name",
+      def attribute_name_fully_qualified_for_all_but_main_table_columns
+        return attribute if main_table
+        return fully_qualified_attribute_name
+      end
+
+      # Returns a reference to the column in the form: "table_name.column_name".
+      def fully_qualified_attribute_name
+        table_alias_or_table_name ? (table_alias_or_table_name + '.' + attribute) : nil
+      end
+
+      def filter_shown? #:nodoc:
+        self.attribute && self.filter
+      end
+
+      def filter_shown_in_main_table? #:nodoc:
+        filter_shown? && !self.detach_with_id
+      end
+
+      def table_alias_or_table_name  #:nodoc:
+        table_alias || table_name
+      end
+
+      def capable_of_hosting_filter_related_icons?  #:nodoc:
+        self.attribute.blank? && self.name.blank? && !self.filter_shown?
+      end
+
+      def has_auto_reloading_input?  #:nodoc:
+        false
+      end
+
+      def auto_reloading_input_with_negation_checkbox?  #:nodoc:
+        false
+      end
+
+      def has_auto_reloading_select?  #:nodoc:
+        false
+      end
+
+      def has_auto_reloading_calendar?  #:nodoc:
+        false
+      end
+
+      protected
+
+      def form_parameter_template(v) #:nodoc:
+        { @grid.name => { f: { self.attribute_name_fully_qualified_for_all_but_main_table_columns => v } } }.to_query
+      end
+
+      def form_parameter_name(v) #:nodoc:
+        form_parameter_template_hash(v).to_query
+      end
+
+      def name_out_of_template(s) #:nodoc:
+        CGI.unescape(s).sub(/=$/, '')
+      end
+
+      def id_out_of_name(s) #:nodoc:
+        s.gsub(/[\[\]]+/, '_').sub(/_+$/, '')
+      end
+    end
+
+    class ConditionsGeneratorColumn   #:nodoc:
+      def initialize(column_wrapper, column_type = nil)   #:nodoc:
+        # Wice::ActiveRecordColumnWrapper
+        @column_wrapper = column_wrapper
+        @column_type = column_type
+      end
+
+      def generate_conditions(_table_alias, _opts) #:nodoc:
+        raise('implement me')
+      end
+
+    end
+  end
+end