wice_grid_mongoid 0.5.7 → 6.0.3

data/lib/wice_grid.rb

@@ -1,9 +1,7 @@
 # encoding: UTF-8
-require 'will_paginate.rb'
 require 'wice_grid_misc.rb'
 require 'wice_grid_core_ext.rb'
 require 'grid_renderer.rb'
-require 'table_column_matrix.rb'
 require 'helpers/wice_grid_view_helpers.rb'
 require 'helpers/wice_grid_misc_view_helpers.rb'
 require 'helpers/wice_grid_serialized_queries_view_helpers.rb'
@@ -11,6 +9,7 @@ require 'helpers/wice_grid_view_helpers.rb'
 require 'helpers/js_calendar_helpers.rb'
 require 'grid_output_buffer.rb'
 require 'wice_grid_controller.rb'
+require 'mongoid_field'
 require 'wice_grid_spreadsheet.rb'
 require 'wice_grid_serialized_queries_controller.rb'
 require 'js_adaptors/js_adaptor.rb'
@@ -18,15 +17,34 @@ require 'js_adaptors/jquery_adaptor.rb'
 require 'js_adaptors/prototype_adaptor.rb'
 require 'view_columns.rb'
 
-ActionView::Base.class_eval { include Wice::GridViewHelper }
-ActionController::Base.send(:include, Wice::Controller)
+
 ActionController::Base.send(:helper_method, :wice_grid_custom_filter_params)
 
 module Wice
 
+  class WiceGridRailtie < Rails::Railtie
+
+    initializer "wice_grid_railtie.configure_rails_initialization" do |app|
+      ActionController::Base.send(:include, Wice::Controller)
+      Mongoid::Field.send(:include, ::Wice::MongoidField)
+      ::ActionView::Base.class_eval { include Wice::GridViewHelper }
+
+      [ActionView::Helpers::AssetTagHelper,
+       ActionView::Helpers::TagHelper,
+       ActionView::Helpers::JavaScriptHelper,
+       ActionView::Helpers::FormTagHelper].each do |m|
+        JsCalendarHelpers.send(:include, m)
+      end
+    end
+
+    rake_tasks do
+      load 'tasks/wice_grid_tasks.rake'
+    end
+  end
+
   class WiceGrid
 
-    attr_reader :klass, :name, :resultset, :custom_order, :query_store_model
+    attr_reader :klass, :name, :resultset, :custom_order, :query_store_model, :options, :controller
     attr_reader :ar_options, :status, :export_to_csv_enabled, :csv_file_name, :saved_query
     attr_writer :renderer
     attr_accessor :output_buffer, :view_helper_finished, :csv_tempfile
@@ -36,20 +54,9 @@ module Wice
     def initialize(klass, controller, opts = {})  #:nodoc:
       @controller = controller
 
-      # check for will_paginate
-      # raise WiceGridException.new("Plugin will_paginate not found! wice_grid requires will_paginate.")
-      unless klass.respond_to?(:paginate)
-        raise Wice::WiceGridException.new('will_paginate not found, WiceGrid cannot proceed. Please install gem mislav-will_paginate. ' +
-                                          'You might need to add github.com as the gem source before you install the gem: ' +
-                                          'gem sources -a http://gems.github.com')
+      unless klass.kind_of?(Class) && klass.ancestors.index(Mongoid::Document)
+        raise WiceGridArgumentError.new("The model class (second argument) must be a Class derived from Mongoid::Document")
       end
-
-      unless klass.kind_of?(Class) && klass.ancestors.index(ActiveRecord::Base)
-        raise WiceGridArgumentError.new("ActiveRecord model class (second argument) must be a Class derived from ActiveRecord::Base")
-      end
-
-      Wice.deprecated_call(:after, :with_resultset, opts)
-
       # validate :with_resultset & :with_paginated_resultset
       [:with_resultset, :with_paginated_resultset].each do |callback_symbol|
         unless [NilClass, Symbol, Proc].index(opts[callback_symbol].class)
@@ -79,7 +86,6 @@ module Wice
         :name                 => Defaults::GRID_NAME,
         :order                => nil,
         :order_direction      => Defaults::ORDER_DIRECTION,
-        :page                 => 1,
         :per_page             => Defaults::PER_PAGE,
         :saved_query          => nil,
         :select               => nil,
@@ -105,11 +111,8 @@ module Wice
       raise WiceGridArgumentError.new("name of the grid can only contain alphanumeruc characters") unless @name =~ /^[a-zA-Z\d_]*$/
 
       @klass = klass
-
-      @table_column_matrix = TableColumnMatrix.new
-      @table_column_matrix.default_model_class = @klass
-
-      @ar_options = {}
+      @criteria = Mongoid::Criteria.new(@klass)
+      @has_any_filter_criteria = false
       @status = HashWithIndifferentAccess.new
 
       if @options[:order]
@@ -128,12 +131,16 @@ module Wice
 
       process_loading_query
       process_params
-
-      @ar_options_formed = false
-
-      @method_scoping = @klass.send(:scoped_methods)[-1]
+      @criteria_formed = false
     end
 
+    def has_any_filter_criteria?
+      @has_any_filter_criteria
+    end
+    
+    def has_more_to_show?
+      @status[:per_page].to_i < resultset.count
+    end
     # A block executed from within the plugin to process records of the current page.
     # The argument to the callback is the array of the records. See the README for more details.
     def with_paginated_resultset(&callback)
@@ -181,40 +188,21 @@ module Wice
       end
     end
 
-    def declare_column(column_name, model_class, custom_filter_active, table_alias)  #:nodoc:
-      if model_class # this is an included table
-        column = @table_column_matrix.get_column_by_model_class_and_column_name(model_class, column_name)
-        raise WiceGridArgumentError.new("Column '#{column_name}' is not found in table '#{model_class.table_name}'!") if column.nil?
-        main_table = false
-        table_name = model_class.table_name
-      else
-        column = @table_column_matrix.get_column_in_default_model_class_by_column_name(column_name)
-        if column.nil?
-          raise WiceGridArgumentError.new("Column '#{column_name}' is not found in table '#{@klass.table_name}'! " +
-            "If '#{column_name}' belongs to another table you should declare it in :include or :join when initialising " +
-            "the grid, and specify :model_class in column declaration.")
-        end
-        main_table = true
-        table_name = @table_column_matrix.default_model_class.table_name
-      end
+    def declare_column(field_name, custom_filter_active)  #:nodoc:
+      field = @klass.fields[field_name]
+      raise WiceGridArgumentError.new("Model #{@klass.name} does not have field '#{field_name}'.! ") unless field
 
-      if column
-        conditions, current_parameter_name = column.wg_initialize_request_parameters(@status[:f], main_table, table_alias, custom_filter_active)
-        if @status[:f] && conditions.blank?
-          @status[:f].delete(current_parameter_name)
-        end
+      criteria_added = field.wice_add_filter_criteria(@status[:f], @criteria, custom_filter_active)
+      @status[:f].delete(field_name) if @status[:f] && !criteria_added
 
-        @table_column_matrix.add_condition(column, conditions)
-        [column, table_name , main_table]
-      else
-        nil
-      end
+      @has_any_filter_criteria ||= criteria_added
+      [field, nil , true]
     end
 
-    def form_ar_options(opts = {})  #:nodoc:
+    def form_criteria(opts = {})  #:nodoc:
 
-      return if @ar_options_formed
-      @ar_options_formed = true unless opts[:forget_generated_options]
+      return if @criteria_formed
+      @criteria_formed = true unless opts[:forget_generated_options]
 
       # validate @status[:order_direction]
       @status[:order_direction] = case @status[:order_direction]
@@ -226,42 +214,38 @@ module Wice
         ''
       end
 
-      # conditions
-      if @table_column_matrix.generated_conditions.size == 0
-        @status.delete(:f)
-      end
-
-      @ar_options[:conditions] = klass.send(:merge_conditions, @status[:conditions], * @table_column_matrix.conditions )
-      # conditions processed
+      @status.delete(:f) if !@has_any_filter_criteria
 
-      if (! opts[:skip_ordering]) && @status[:order]
-        @ar_options[:order] = add_custom_order_sql(complete_column_name(@status[:order]))
-
-        @ar_options[:order] += ' ' + @status[:order_direction]
+      if !opts[:skip_ordering] && @status[:order]
+        order_by = @status[:order].to_sym.send( @status[:order_direction].to_sym )
+        @criteria.order_by(order_by)
       end
 
-      if self.output_html?
-        @ar_options[:per_page] = if all_record_mode?
-          # reset the :pp value in all records mode
-          @status[:pp] = count_resultset_without_paging_without_user_filters
-        else
-          @status[:per_page]
-        end
+      @criteria.limit(@status[:per_page].to_i)
+#       #fix-this, Criteria must respect options
+#       if self.output_html?
+#         @criteria[:per_page] = if all_record_mode?
+#           # reset the :pp value in all records mode
+#           @status[:pp] = count_resultset_without_paging_without_user_filters
+#         else
+#           @status[:per_page]
+#         end
 
-        @ar_options[:page] = @status[:page]
-        @ar_options[:total_entries] = @status[:total_entries] if @status[:total_entries]
-      end
+#         @criteria[:page] = @status[:page]
+#         @criteria[:total_entries] = @status[:total_entries] if @status[:total_entries]
+#       end
 
-      @ar_options[:joins]   = @options[:joins]
-      @ar_options[:include] = @options[:include]
-      @ar_options[:group] = @options[:group]
-      @ar_options[:select]  = @options[:select]
+#       @criteria[:joins]   = @options[:joins]
+#       @criteria[:include] = @options[:include]
+#       @criteria[:group] = @options[:group]
+#       @criteria[:select]  = @options[:select]
     end
 
     def read  #:nodoc:
-      form_ar_options
+      form_criteria
       with_exclusive_scope do
-        @resultset = self.output_csv? ?  @klass.find(:all, @ar_options) : @klass.paginate(@ar_options)
+        @criteria.options[:limit] = nil if @resultset = self.output_csv?
+        @resultset = @criteria
       end
       invoke_resultset_callbacks
     end
@@ -272,12 +256,8 @@ module Wice
     # Getters
 
     def filter_params(view_column)  #:nodoc:
-      column_name = view_column.attribute_name_fully_qualified_for_all_but_main_table_columns
-      if @status[:f] && @status[:f][column_name]
-        @status[:f][column_name]
-      else
-        {}
-      end
+      return (@status[:f][view_column.attribute_name] || {}) if @status[:f]
+      {}
     end
 
     def resultset  #:nodoc:
@@ -294,11 +274,7 @@ module Wice
 
     def ordered_by?(column)  #:nodoc:
       return nil if @status[:order].blank?
-      if column.main_table && ! offs = @status[:order].index('.')
-        @status[:order] == column.attribute_name
-      else
-        @status[:order] == column.table_alias_or_table_name + '.' + column.attribute_name
-      end
+      @status[:order] == column.attribute_name
     end
 
     def ordered_by  #:nodoc:
@@ -319,7 +295,7 @@ module Wice
     end
 
     def filtered_by?(view_column)  #:nodoc:
-      @status[:f].nil? ? false : @status[:f].has_key?(view_column.attribute_name_fully_qualified_for_all_but_main_table_columns)
+      @status[:f] && @status[:f].has_key?(view_column.attribute_name)
     end
 
     def get_state_as_parameter_value_pairs(including_saved_query_request = false) #:nodoc:
@@ -351,8 +327,8 @@ module Wice
     end
 
     def count  #:nodoc:
-      form_ar_options(:skip_ordering => true, :forget_generated_options => true)
-      @klass.count(:conditions => @ar_options[:conditions], :joins => @ar_options[:joins], :include => @ar_options[:include], :group => @ar_options[:group])
+      form_criteria(:skip_ordering => true, :forget_generated_options => true)
+      @klass.count(:conditions => @criteria[:conditions], :joins => @criteria[:joins], :include => @criteria[:include], :group => @criteria[:group])
     end
 
     alias_method :size, :count
@@ -402,7 +378,7 @@ module Wice
     def dump_status #:nodoc:
       "   params: #{params[name].inspect}\n"  +
       "   status: #{@status.inspect}\n" +
-      "   ar_options #{@ar_options.inspect}\n"
+      "   ar_options #{@criteria.inspect}\n"
     end
 
 
@@ -443,45 +419,14 @@ module Wice
     end
 
     def with_exclusive_scope #:nodoc:
-      if @method_scoping
-        @klass.send(:with_exclusive_scope, @method_scoping) do
-          yield
-        end
-      else
-        yield
-      end
-    end
-
-
-    def add_custom_order_sql(fully_qualified_column_name) #:nodoc:
-      custom_order = if @options[:custom_order].has_key?(fully_qualified_column_name)
-        @options[:custom_order][fully_qualified_column_name]
-      else
-        if view_column = @renderer[fully_qualified_column_name]
-          view_column.custom_order
-        else
-          nil
-        end
-      end
-
-      if custom_order.blank?
-        ActiveRecord::Base.connection.quote_table_name(fully_qualified_column_name.strip)
-      else
-        if custom_order.is_a? String
-          custom_order.gsub(/\?/, fully_qualified_column_name)
-        elsif custom_order.is_a? Proc
-          custom_order.call(fully_qualified_column_name)
-        else
-          raise WiceGridArgumentError.new("invalid custom order #{custom_order.inspect}")
-        end
-      end
+      yield
     end
 
     def complete_column_name(col_name)  #:nodoc:
       if col_name.index('.') # already has a table name
         col_name
       else # add the default table
-        "#{@klass.table_name}.#{col_name}"
+        "#{@klass.collection_name}.#{col_name}"
       end
     end
 
@@ -495,22 +440,22 @@ module Wice
 
 
     def resultset_without_paging_without_user_filters  #:nodoc:
-      form_ar_options
+      form_criteria
       with_exclusive_scope do
-        @klass.find(:all, :joins => @ar_options[:joins],
-                          :include => @ar_options[:include],
-                          :group => @ar_options[:group],
+        @klass.find(:all, :joins => @criteria[:joins],
+                          :include => @criteria[:include],
+                          :group => @criteria[:group],
                           :conditions => @options[:conditions])
       end
     end
 
     def count_resultset_without_paging_without_user_filters  #:nodoc:
-      form_ar_options
+      form_criteria
       with_exclusive_scope do
         @klass.count(
-          :joins => @ar_options[:joins],
-          :include => @ar_options[:include],
-          :group => @ar_options[:group],
+          :joins => @criteria[:joins],
+          :include => @criteria[:include],
+          :group => @criteria[:group],
           :conditions => @options[:conditions]
         )
       end
@@ -518,13 +463,13 @@ module Wice
 
 
     def resultset_without_paging_with_user_filters  #:nodoc:
-      form_ar_options
+      form_criteria
       with_exclusive_scope do
-        @klass.find(:all, :joins      => @ar_options[:joins],
-                          :include    => @ar_options[:include],
-                          :group      => @ar_options[:group],
-                          :conditions => @ar_options[:conditions],
-                          :order      => @ar_options[:order])
+        @klass.find(:all, :joins      => @criteria[:joins],
+                          :include    => @criteria[:include],
+                          :group      => @criteria[:group],
+                          :conditions => @criteria[:conditions],
+                          :order      => @criteria[:order])
       end
     end
 
@@ -571,239 +516,6 @@ module Wice
     end
   end
 
-  # to be mixed in into ActiveRecord::ConnectionAdapters::Column
-  module WiceGridExtentionToActiveRecordColumn #:nodoc:
-
-    attr_accessor :model_klass
-
-    def alias_or_table_name(table_alias)
-      table_alias || self.model_klass.table_name
-    end
-
-    def wg_initialize_request_parameters(all_filter_params, main_table, table_alias, custom_filter_active)  #: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[self.name]
-        current_parameter_name = self.name
-      elsif @request_params = all_filter_params[alias_or_table_name(table_alias) + '.' + self.name]
-        current_parameter_name = alias_or_table_name(table_alias) + '.' + self.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 (self.type == :datetime || self.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::Defaults::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 self.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::Defaults::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
-
-      return wg_generate_conditions(table_alias, custom_filter_active), current_parameter_name
-    end
-
-    def wg_generate_conditions(table_alias, custom_filter_active)  #:nodoc:
-      return nil if @request_params.nil?
-
-      if custom_filter_active
-        return ::Wice::FilterConditionsGeneratorCustomFilter.new(self).generate_conditions(table_alias, @request_params)
-      end
-
-      column_type = self.type.to_s
-
-      processor_class = ::Wice::FilterConditionsGenerator.handled_type[column_type]
-
-      if processor_class
-        return processor_class.new(self).generate_conditions(table_alias, @request_params)
-      else
-        Wice.log("No processor for database type #{column_type}!!!")
-        nil
-      end
-    end
-
-  end
-
-  class FilterConditionsGenerator   #:nodoc:
-
-    cattr_accessor :handled_type
-    @@handled_type = HashWithIndifferentAccess.new
-
-    def initialize(column)   #:nodoc:
-      @column = column
-    end
-  end
-
-  class FilterConditionsGeneratorCustomFilter < FilterConditionsGenerator #:nodoc:
-
-    def generate_conditions(table_alias, opts)   #:nodoc:
-      if opts.empty?
-        Wice.log "empty parameters for the grid custom filter"
-        return false
-      end
-      opts = (opts.kind_of?(Array) && opts.size == 1) ? opts[0] : opts
-
-      if opts.kind_of?(Array)
-        opts_with_special_values, normal_opts = opts.partition{|v| ::Wice::GridTools.special_value(v)}
 
-        conditions_ar = if normal_opts.size > 0
-          [" #{@column.alias_or_table_name(table_alias)}.#{@column.name} IN ( " + (['?'] * normal_opts.size).join(', ') + ' )'] + normal_opts
-        else
-          []
-        end
-
-        if opts_with_special_values.size > 0
-          special_conditions = opts_with_special_values.collect{|v| " #{@column.alias_or_table_name(table_alias)}.#{@column.name} is " + v}.join(' or ')
-          if conditions_ar.size > 0
-            conditions_ar[0] = " (#{conditions_ar[0]} or #{special_conditions} ) "
-          else
-            conditions_ar = " ( #{special_conditions} ) "
-          end
-        end
-        conditions_ar
-      else
-        if ::Wice::GridTools.special_value(opts)
-          " #{@column.alias_or_table_name(table_alias)}.#{@column.name} is " + opts
-        else
-          [" #{@column.alias_or_table_name(table_alias)}.#{@column.name} = ?", opts]
-        end
-      end
-    end
-
-  end
-
-  class FilterConditionsGeneratorBoolean < FilterConditionsGenerator  #:nodoc:
-    @@handled_type[:boolean] = self
-
-    def  generate_conditions(table_alias, opts)   #:nodoc:
-      unless (opts.kind_of?(Array) && opts.size == 1)
-        Wice.log "invalid parameters for the grid boolean filter - must be an one item array: #{opts.inspect}"
-        return false
-      end
-      opts = opts[0]
-      if opts == 'f'
-        [" (#{@column.alias_or_table_name(table_alias)}.#{@column.name} = ? or #{@column.alias_or_table_name(table_alias)}.#{@column.name} is null) ", false]
-      elsif opts == 't'
-        [" #{@column.alias_or_table_name(table_alias)}.#{@column.name} = ?", true]
-      else
-        nil
-      end
-    end
-  end
-
-  class FilterConditionsGeneratorString < FilterConditionsGenerator  #:nodoc:
-    @@handled_type[:string] = self
-    @@handled_type[:text]   = self
-
-    def generate_conditions(table_alias, opts)   #:nodoc:
-      if opts.kind_of? String
-        string_fragment = opts
-        negation = ''
-      elsif (opts.kind_of? Hash) && opts.has_key?(:v)
-        string_fragment = opts[:v]
-        negation = opts[:n] == '1' ? 'NOT' : ''
-      else
-        Wice.log "invalid parameters for the grid string filter - must be a string: #{opts.inspect} or a Hash with keys :v and :n"
-        return false
-      end
-      if string_fragment.empty?
-        Wice.log "invalid parameters for the grid string filter - empty string"
-        return false
-      end
-      [" #{negation}  #{@column.alias_or_table_name(table_alias)}.#{@column.name} #{::Wice.get_string_matching_operators(@column.model_klass)} ?",
-          '%' + string_fragment + '%']
-    end
-
-  end
-
-  class FilterConditionsGeneratorInteger < FilterConditionsGenerator  #:nodoc:
-    @@handled_type[:integer] = self
-    @@handled_type[:float]   = self
-    @@handled_type[:decimal] = self
-
-    def  generate_conditions(table_alias, opts)   #:nodoc:
-      unless opts.kind_of? Hash
-        Wice.log "invalid parameters for the grid integer filter - must be a hash"
-        return false
-      end
-      conditions = [[]]
-      if opts[:fr]
-        if opts[:fr] =~ /\d/
-          conditions[0] << " #{@column.alias_or_table_name(table_alias)}.#{@column.name} >= ? "
-          conditions << opts[:fr]
-        else
-          opts.delete(:fr)
-        end
-      end
-
-      if opts[:to]
-        if opts[:to] =~ /\d/
-          conditions[0] << " #{@column.alias_or_table_name(table_alias)}.#{@column.name} <= ? "
-          conditions << opts[:to]
-        else
-          opts.delete(:to)
-        end
-      end
-
-      if conditions.size == 1
-        Wice.log "invalid parameters for the grid integer filter - either range limits are not supplied or they are not numeric"
-        return false
-      end
-
-      conditions[0] = conditions[0].join(' and ')
-
-      return conditions
-    end
-  end
-
-  class FilterConditionsGeneratorDate < FilterConditionsGenerator  #:nodoc:
-    @@handled_type[:date]      = self
-    @@handled_type[:datetime]  = self
-    @@handled_type[:timestamp] = self
-
-    def generate_conditions(table_alias, opts)   #:nodoc:
-      conditions = [[]]
-      if opts[:fr]
-        conditions[0] << " #{@column.alias_or_table_name(table_alias)}.#{@column.name} >= ? "
-        conditions << opts[:fr]
-      end
-
-      if opts[:to]
-        conditions[0] << " #{@column.alias_or_table_name(table_alias)}.#{@column.name} <= ? "
-        conditions << opts[:to]
-      end
-
-      return false if conditions.size == 1
-
-      conditions[0] = conditions[0].join(' and ')
-      return conditions
-    end
-  end
 
 end
-
-ActiveRecord::ConnectionAdapters::Column.send(:include, ::Wice::WiceGridExtentionToActiveRecordColumn)

data/lib/wice_grid_misc.rb

@@ -29,7 +29,7 @@ module Wice
 
     def get_string_matching_operators(model)   #:nodoc:
       if defined?(Wice::Defaults::STRING_MATCHING_OPERATORS) && Wice::Defaults::STRING_MATCHING_OPERATORS.is_a?(Hash) &&
-          str_matching_operator = Wice::Defaults::STRING_MATCHING_OPERATORS[model.connection.class.to_s]
+          str_matching_operator =(Wice::Defaults::STRING_MATCHING_OPERATORS[model.connection.class.to_s] rescue nil)
         str_matching_operator
       else
         Wice::Defaults::STRING_MATCHING_OPERATOR
@@ -45,7 +45,7 @@ module Wice
     end
 
     def log(message) #:nodoc:
-      ActiveRecord::Base.logger.info('WiceGrid: ' + message)
+      ActionController::Base.logger.info('WiceGrid: ' + message)
     end
   end
 
@@ -96,4 +96,4 @@ module Wice
   class WiceGridException < Exception #:nodoc:
     include ExceptionsMixin
   end
-end
+end