wice_grid_mongoid 0.5.6

data/lib/wice_grid_controller.rb

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

data/lib/wice_grid_core_ext.rb

@@ -0,0 +1,179 @@
+# encoding: UTF-8
+module WGHashExtensions  #:nodoc:
+
+  def self.included(base)  #:nodoc:
+    base.extend(ClassMethods)
+  end
+
+
+  # if there's a hash of hashes, the original structure and the
+  # returned structure should not contain any shared deep hashes
+  def deep_clone_yl  #:nodoc:
+    cloned = self.clone
+    cloned.keys.each do |k|
+      if cloned[k].kind_of?(Hash)
+        cloned[k] = cloned[k].deep_clone_yl
+      end
+    end
+    cloned
+  end
+
+  # Used to modify options submitted to view helpers. If there is no :klass option,
+  # it will be added, if there is, the css class name will be appended to the existing
+  # class name(s)
+  def add_or_append_class_value!(klass_value, prepend = false) #:nodoc:
+    if self.has_key?('class')
+      self[:class] = self['class']
+      self.delete('class')
+    end
+
+    self[:class] = if self.has_key?(:class)
+      if prepend
+        "#{klass_value} #{self[:class]}"
+      else
+        "#{self[:class]} #{klass_value}"
+      end
+    else
+      klass_value
+    end
+
+    return self
+  end
+
+
+  # Used to transform a traditional params hash
+  # into an array of two element arrays where element zero is a parameter name as it appears in HTTP requests,
+  # and the first element is the value:
+  # { :a => { :b => 3, :c => 4, :d => { :e => 5 }} }.parameter_names_and_values #=>  [["a[d][e]", 5], ["a[b]", 3], ["a[c]", 4]]
+  # The parameter is an optional array of parameter names to prepend:
+  # { :a => { :b => 3, :c => 4, :d => { :e => 5 }} }.parameter_names_and_values(['foo', 'baz']) #=>
+  #                         [["foo[baz][a][d][e]", 5], ["foo[baz][a][b]", 3], ["foo[baz][a][c]", 4]]
+  def parameter_names_and_values(initial = []) #:nodoc:
+    res = []
+    recursively_gather_finite_non_hash_values_with_key_path(res, [])
+    res.collect do |parameter_struct|
+      parameter_struct[0] = initial + parameter_struct[0]
+      [parameter_struct[0].to_parameter_name, parameter_struct[1]]
+    end
+  end
+
+
+  # A deep merge of two hashes.
+  # That is, if both hashes have the same key and the values are hashes, these two hashes should also be merged.
+  # Used for merging two sets of params.
+  def rec_merge(other)  #:nodoc:
+    res = self.clone
+    other.each do |key, other_value|
+      value = res[key]
+      if value.is_a?(Hash) && other_value.is_a?(Hash)
+        res[key] = value.rec_merge other_value
+      else
+        res[key] = other_value
+      end
+    end
+    res
+  end
+
+
+  module ClassMethods  #:nodoc:
+
+    # Used mostly for submitting options to view helpers, that is, like this:
+    #   content_tag(:th, col_link, Hash.make_hash(:class, css_class))
+    # In some it is important that if the value is empty, no option
+    # is submitted at all. Thus, there's a check for an empty value
+    def make_hash(key, value) #:nodoc:
+      value.blank? ? {} : {key => value}
+    end
+
+
+  end
+
+  protected
+
+  def recursively_gather_finite_non_hash_values_with_key_path(res, stack = []) #:nodoc:
+    self.each do |key, value|
+      if value.kind_of?(Hash)
+        value.recursively_gather_finite_non_hash_values_with_key_path(res, stack + [key])
+      else
+        res << [stack + [key], value]
+      end
+    end
+  end
+
+end
+
+
+class Hash #:nodoc:
+  include WGHashExtensions
+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
+    end
+  end
+end
+
+
+
+module Enumerable #:nodoc:
+
+  # Used to check the validity of :custom_filter parameter of column
+  def all_items_are_of_class(klass)  #:nodoc:
+    return false if self.empty?
+    self.inject(true){|memo, o| (o.is_a? klass) && memo}
+  end
+
+end
+
+module WGObjectExtensions #:nodoc:
+
+  # takes a list of messages, sends message 1 to self, then message 2 is sent to the result of the first message, ans so on
+  # returns nil as soon as the current receiver does not respond to such a message
+  def deep_send(*messages)  #:nodoc:
+    obj = self
+    messages.each do |message|
+      if obj.respond_to? message
+        obj = obj.send(message)
+      else
+        return nil
+      end
+      # return obj if obj.nil?
+    end
+    return obj
+  end
+end
+
+class Object #:nodoc:
+  include WGObjectExtensions
+end
+
+module WGArrayExtensions  #:nodoc:
+  # Only used by Hash#parameter_names_and_values
+  # Transforms ['foo', 'bar', 'baz'] to 'foo[bar][baz]'
+  def to_parameter_name #:nodoc:
+    self[0].to_s + (self[1..-1] || []).collect{|k| '[' + k.to_s + ']'}.join('')
+  end
+end
+
+class Array  #:nodoc:
+  include WGArrayExtensions
+end
+
+module StringExt #:nodoc:
+  def html_safe_if_necessary #:nodoc:
+    if respond_to?(:html_safe)
+      html_safe
+    else
+      self
+    end
+  end
+end
+
+class String #:nodoc:
+  include StringExt
+end

data/lib/wice_grid_misc.rb

@@ -0,0 +1,99 @@
+# encoding: UTF-8
+module Wice
+
+  class << self
+
+    @@model_validated = false
+
+    # checks whether the class is a valid storage for saved queries
+    def validate_query_model(query_store_model)  #:nodoc:
+      unless query_store_model.respond_to?(:list)
+        raise ::Wice::WiceGridArgumentError.new("Model for saving queries #{query_store_model.class.name} is invalid - there is no class method #list defined")
+      end
+      arit = query_store_model.method(:list).arity
+      unless arit == 2
+        raise ::Wice::WiceGridArgumentError.new("Method list in the model for saving queries #{query_store_model.class.name} has wrong arity - it should be 2 instead of #{arit}")
+      end
+      @@model_validated = true
+    end
+
+    # Retrieves and constantizes (if needed ) the Query Store model
+    def get_query_store_model #:nodoc:
+
+      query_store_model = ::Wice::Defaults::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
+      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::Defaults::STRING_MATCHING_OPERATORS.is_a?(Hash) &&
+          str_matching_operator = Wice::Defaults::STRING_MATCHING_OPERATORS[model.connection.class.to_s]
+        str_matching_operator
+      else
+        Wice::Defaults::STRING_MATCHING_OPERATOR
+      end
+    end
+
+    def deprecated_call(old_name, new_name, opts) #:nodoc:
+      if opts[old_name] && ! opts[new_name]
+        opts[new_name] = opts[old_name]
+        opts.delete(old_name)
+        STDERR.puts "WiceGrid: Parameter :#{old_name} is deprecated, use :#{new_name} instead!"
+      end
+    end
+
+    def log(message) #:nodoc:
+      ActiveRecord::Base.logger.info('WiceGrid: ' + message)
+    end
+  end
+
+
+  # The point of this module is to provide a thin layer between 
+  # Rails Internationalization API and WiceGrid, enabling a fallback
+  # to the old hardcoded messages if no translations are available
+  # or I18n is not present (Rails 2.1.0 and older).
+  module WiceGridNlMessageProvider #:nodoc:
+    class << self
+
+      def get_from_hardcoded_constants(key) #:nodoc:
+        if Wice::Defaults.const_defined?(key)
+          Wice::Defaults.const_get(key)
+        else
+          return "message for key #{key} not found!"
+        end
+      end
+      
+      if Object.const_defined?(:I18n) # Rails with :I18n
+
+        def get_message(key) #:nodoc:
+          translated = I18n.t(key.to_s.downcase, :scope => 'wice_grid', :default => '_')
+          if translated == '_'
+            get_from_hardcoded_constants(key)
+          else
+            translated
+          end
+        end
+        
+      else # Rails without :I18n
+        alias_method :get_message, :get_from_hardcoded_constants
+      end
+    end
+  end
+
+  module Defaults  #:nodoc:
+  end
+
+  module ExceptionsMixin  #:nodoc:
+    def initialize(str)  #:nodoc:
+      super("WiceGrid: " + str)
+    end
+  end
+  class WiceGridArgumentError < ArgumentError #:nodoc:
+    include ExceptionsMixin
+  end
+  class WiceGridException < Exception #:nodoc:
+    include ExceptionsMixin
+  end
+end

data/lib/wice_grid_serialized_queries_controller.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+module Wice
+  class <<self
+    # Used in routes.rb to define routes to the query processing controller.
+    # Parameters:
+    # * map - the mapper object used in routes.rb to defined routes (instance of <tt>ActionController::Routing::RouteSet::Mapper</tt>)
+    # * controller - name of the query processing controller, i.e.  <tt>'queries'</tt> if the controller is +QueriesController+ .
+    # Read section "Saving Queries How-To" in README for more details.
+    def define_routes(map, controller)
+      controller = controller.to_s
+      map.create_serialized_query '/wice_grid_serialized_queries/:grid_name',
+        :controller => controller,
+        :action => 'create',
+        :conditions => {:method => :post}
+      map.delete_serialized_query '/wice_grid_serialized_query/:grid_name/:id',
+        :controller => controller,
+        :action => 'delete',
+        :conditions => {:method => :post}
+    end
+  end
+
+  module SerializedQueriesControllerMixin   #:nodoc:
+
+    def delete  #:nodoc:
+      init
+      if sq = @query_store_model.find_by_id_and_grid_name(params[:id], @grid_name)
+        if sq.destroy
+          if params[:current]
+            @current = @query_store_model.find_by_id_and_grid_name(params[:current], @grid_name)
+          end
+          @notification_messages = WiceGridNlMessageProvider.get_message(:QUERY_DELETED_MESSAGE)
+        else
+          @error_messages = sq.errors.full_raw_messages.join(' ')
+        end
+      end
+      render :file => "#{RAILS_ROOT}/vendor/plugins/wice_grid/lib/views/delete.rjs"
+    end
+
+    def create  #:nodoc:
+      init
+      query_params = if params[@grid_name]
+        params[@grid_name]
+      else
+        {}
+      end
+      query_params.delete(:page)
+
+      @saved_query = @query_store_model.new(:grid_name => @grid_name, :name => params[:query_name], :query => query_params)
+
+      @saved_query.attributes = params[:extra] unless params[:extra].blank?
+
+      if @saved_query.save
+        @grid_title_id = "#{@grid_name}_title"
+        @notification_messages = WiceGridNlMessageProvider.get_message(:QUERY_SAVED_MESSAGE)
+      else
+        @error_messages = @saved_query.errors.map{ |_, msg| msg }.join(' ')
+      end
+
+      render :file => "#{RAILS_ROOT}/vendor/plugins/wice_grid/lib/views/create.rjs"
+    end
+
+    def extra
+      params[:extra]
+    end
+
+    protected
+
+    def init  #:nodoc:
+      @query_store_model = ::Wice::get_query_store_model
+
+      @grid_name = params[:grid_name]
+      @notification_messages_dom_id = "#{@grid_name}_notification_messages"
+      @query_list_dom_id = "#{@grid_name}_query_list"
+
+    end
+  end
+end