compass-jquery-plugin 0.3.0.0 → 0.3.1.beta.2

data/lib/jquery/gridify/grid_column.rb

@@ -0,0 +1,134 @@
+module Gridify
+  class GridColumn
+    
+    attr_accessor :name,                    # attribute name (required)
+                  :label,
+                  :ar_column,               # active_record column
+                  :value_type,              # active_record data type :string, :text, :integer, :float, :boolean, + :currency
+                  :key,                     # true if this is the key (only :id)
+                  
+                  # column formatting
+                  :width,                   # initial width (150)
+                  :fixed_width,             # true = not resized when recalc fit to width
+                  :formatter,               # see jqGrid doc (based on value_type)
+                  :format_options,          # hash, see jqGrid doc (based on value_type)
+                  :align,                   # 'left', 'right', 'center' (left for strings, right for numerics)                  
+                  #:classes,                # optional classes to add to column 
+                  
+                  # column actions
+                  :resizable,               # t/f (true)
+                  :sortable,                # t/f (true) or jqGrid sorttype: :integer, :float, :currency, :date, :text (true)
+                  :searchable,              # true/false (true) or text or select
+                  #:search_options,
+                  :editable,                # true/false (false),
+                  :edit_type,               # text, textarea, select, checkbox, password, button, image and file (based on value_type)
+                  :edit_options,            # html input field options, depends on editable type (eg {"size" => 10, "maxlength" => 15}) see http://www.trirand.com/jqgridwiki/doku.php?id=wiki:common_rules
+                  :validations,             # jqGrid editrules (TODO derive from AR model validations) see http://www.trirand.com/jqgridwiki/doku.php?id=wiki:common_rules
+                                            # "required" "integer" "email" "url" etc
+                  :form_options,            # jqGrid formoptions for formatting input forms
+                  # select types
+                  #:select_url,             # url to dynamically get select options
+                  
+                  # visiblity
+                  #:always_hidden,          # (false)
+                  :sort_type,
+                  :summary_type,
+                  :summary_tpl,
+                  :hidden                   # initial hide state (false)
+     
+    def initialize(options)
+      update options
+    end
+    
+    def update(options)
+      options.each {|atr, val| send( "#{atr}=", val )}
+    end
+    
+    def to_json
+      properties.to_json #_with_js
+    end
+    
+    def properties
+      jqgrid_properties
+    end
+    
+    def resizable
+      if @resizable==false
+        false
+      else
+        # true or nil
+        true
+      end
+    end
+    
+    def fixed_width
+      if @fixed_width==false
+        false
+      elsif @fixed_width.nil?
+        !resizable
+      else
+        @fixed_width
+      end
+    end
+        
+    # ----------------
+    private
+    
+    def jqgrid_type
+      return sortable unless sortable==true
+      case value_type
+      when :string   : 'text'
+      when :text     : 'text'
+      when :integer  : 'integer'
+      when :float    : 'float'
+      when :boolean  : 'boolean'
+      when :datetime : 'date'
+      end
+    end
+    
+    # note, we dont vals[:foo] = foo because dont want to bother generating key if its same as jqGrid default
+    def jqgrid_properties
+      vals = {
+        :name           => name,
+        :index          => name
+      }
+      #xmlmap not required when same as :name
+      # vals[:xmlmap]     = name          if data_type == :xml
+      # vals[:jsonmap]    = name          if data_type == :json
+      
+      vals[:label]      = label || name.titleize
+      vals[:resizable]  = false         if resizable==false
+      vals[:fixed]      = fixed_width   unless fixed_width==false
+      vals[:sortable]   = false         if sortable==false
+      vals[:sort_type]   = jqgrid_type   if sortable 
+      vals[:search]     = false         if searchable==false  
+      vals[:editable]   = true          if editable
+      vals[:align]      = align         if align
+      #vals[:align]      = 'right'       if [:integer, :float, :currency].include?(value_type)
+      case value_type
+      when :datetime
+        vals[:formatter] = 'date'
+        vals[:formatoptions] = { :srcformat => 'UniversalSortableDateTime', :newformat => 'FullDateTime' }
+      end
+      vals[:hidden]         = true         if hidden
+      vals[:width]          = width        if width
+      vals[:formatter]      = formatter    if formatter
+      vals[:formatoptions]  = format_options  if format_options
+      vals[:edittype]       = edit_type    if editable && edit_type
+      vals[:formoptions]    = form_options if editable && form_options
+      vals[:editoptions]    = edit_options if editable && edit_options
+      vals[:editrules]      = validations  if editable && validations
+      
+      vals[:sort_type]      = sort_type if sort_type
+      vals[:summaryType]    = summary_type if summary_type
+      vals[:summaryTpl]     = summary_tpl if summary_tpl
+      # and more...
+        
+      vals
+    end
+    
+  end
+end
+
+#<ActiveRecord::ConnectionAdapters::SQLiteColumn:0x2515a98 @sql_type="varchar(255)", @name="title", @precision=nil, @primary=false, @default=nil, @limit=255, @null=true, @type=:string, @scale=nil>
+

data/lib/jquery/gridify/grid_finder.rb

@@ -0,0 +1,223 @@
+module Gridify
+  class Grid
+
+    attr_accessor :search_rules,        # current search/filter rules, as hash
+                  :search_rules_op      # :and, :or
+
+    # finds records based on request params
+    # e.g. params from jqGrid
+    #   :_search      do search (true/false)  ["false"]
+    #   :sidx         sort index (column to search on)  [""]
+    #   :sord         sort direction (desc/asc)  ["asc"]
+    #   :nd           ?
+    #   :rows         number of items to get   ["20"]
+    #   :page         page number (starts at 1) ["1"]
+
+    def update_from_params( params )
+      params.symbolize_keys!
+      params_to_rules params
+      self.data_type     = params[:datatype] if params[:datatype]
+      self.sort_by       = params[:sidx] if params[:sidx]
+      self.sort_order    = params[:sord] if params[:sord]
+      self.current_page  = params[:page].to_i if params[:page]
+      self.rows_per_page = params[:rows].to_i if params[:rows]
+      self.total_rows    = params[:total_rows].to_i if params[:total_rows]
+    end
+
+    # return find args (scope) for current settings
+    def current_scope
+      #debugger
+      find_args = {}
+      find_args[:include] = colInclude if colInclude
+      if sort_by.present? && col = columns_hash[sort_by]
+        if (sort_by.include? ".")
+          # Workaround for :include and nested attributes
+          field = sort_by.split('.', 2)
+          if field.length == 2
+            self.sort_by = field[0].pluralize + "." + field[1]
+          end
+        end
+        if case_sensitive || !([:string, :text].include?(col.value_type))
+          find_args[:order] = "#{sort_by} #{sort_order}"
+        else
+          find_args[:order] = "upper(#{sort_by}) #{sort_order}"
+        end
+      end
+      if total_rows.present? && total_rows > 0
+        find_args[:limit] = total_rows
+        offset = (current_page.to_i-1) * rows_per_page if current_page.present?
+        find_args[:offset] = offset if offset && offset > 0
+      elsif rows_per_page.present? && rows_per_page > 0
+        find_args[:limit] = rows_per_page
+        offset = (current_page.to_i-1) * rows_per_page if current_page.present?
+        find_args[:offset] = offset if offset && offset > 0
+      end
+      cond = rules_to_conditions
+      find_args[:conditions] = cond unless cond.blank?
+      find_args
+    end
+
+    def find( params )
+      #debugger
+      update_from_params params
+      klass = resource.classify.constantize
+      records = klass.send( finder, :all, current_scope )
+    end
+
+    def encode_records( records, userdata=nil, total_count=nil )
+      #debugger
+      klass = resource.classify.constantize
+      total_count ||= klass.count
+      total_pages = total_count / rows_per_page + 1
+      #TODO: :only => [attributes], :methods => [virtual attributes]
+      case data_type
+      when :xml
+        if colInclude
+          xml = records.to_xml( :include => colInclude, :skip_types => true, :dasherize => false ) do |xml|
+            if rows_per_page > 0
+              xml.page     current_page
+              xml.total    total_pages
+              xml.records  total_count
+            end
+          end
+        else
+          xml = records.to_xml( :skip_types => true, :dasherize => false ) do |xml|
+            if rows_per_page > 0
+              xml.page    current_page
+              xml.total   total_pages
+              xml.records total_count
+            end
+          end
+        end
+      when :json
+        #debugger
+        data = { resource => records }
+        if rows_per_page > 0
+          data.merge!(
+            :page    => current_page,
+            :total   => total_pages,
+            :records => total_count
+          )
+        end
+        data.merge!( :userdata => userdata ) if userdata
+        save = ActiveRecord::Base.include_root_in_json
+        ActiveRecord::Base.include_root_in_json = false
+        if colInclude
+          json = data.to_json(:include => colInclude)
+        else
+          json = data.to_json
+        end
+        ActiveRecord::Base.include_root_in_json = save
+        json
+      #others...
+      else #nop ?
+        records.to_s
+      end
+    end
+
+    def find_and_encode( params )
+      encode_records( find( params ) )
+    end
+
+    # grid doesnt nest attributes inside the resource
+    # could change this behavior in jqGrid, see grid.postext.js ?
+    #   http://www.trirand.com/jqgridwiki/doku.php?id=wiki:post_data_module
+    #
+    def member_params( params )
+      params.inject({}) {|h, (name, value)| h[name] = value if columns_hash[name]; h }
+    end
+
+    protected
+
+    OPS = { 'eq' => '=', 'lt' => '<', 'le' => '<=', 'gt' => '>', 'ge' => '>=', 'ne' => '!=' }
+    #['eq','ne','lt','le','gt','ge',
+    # 'bw','bn','in','ni','ew','en','cn','nc']
+    #['equal','not equal', 'less', 'less or equal','greater','greater or equal',
+    # 'begins with','does not begin with','is in','is not in','ends with','does not end with','contains','does not contain']
+
+    OPS_PATTERN = {
+      'bw' => '?%',
+      'bn' => '?%',
+      # 'in'
+      # 'ni'
+      'ew' => '%?',
+      'en' => '%?',
+      'cn' => '%?%',
+      'nc' => '%?%',
+    }
+
+    STRING_OPS = {
+      'bw' => 'LIKE',
+      'bn' => 'NOT LIKE',
+      'ew' => 'LIKE',
+      'en' => 'NOT LIKE',
+      'cn' => 'LIKE',
+      'nc' => 'NOT LIKE',
+    }
+
+    # params[:filters] => {"groupOp"=>"AND",
+    #              "rules"=>[{"data"=>"b", "op"=>"ge", "field"=>"title"}, {"data"=>"f", "op"=>"le", "field"=>"title"}] }
+    def params_to_rules( params )
+      #debugger
+      if params[:_search]=='true' || params[:_search]==true
+        if params[:filters]
+          # advanced search
+          filters = ActiveSupport::JSON.decode( params[:filters] )
+          self.search_rules = filters['rules']
+          self.search_rules_op = filters['groupOp']
+        elsif params[:searchField]
+          # simple search
+          self.search_rules = [{ "field" => params[:searchField], "op" => params[:searchOper], "data" => params[:searchString]}]
+        else
+          # toolbar search
+          self.search_rules = []
+          self.search_rules_op = :and
+          colModel.each do |col|
+            name = col.name
+            data = params[name.to_sym]
+            self.search_rules << { "field" => name, "op" => "cn", "data" => data } if data
+          end
+        end
+      end
+      search_rules
+    end
+
+    def rules_to_conditions
+      # note: ignoring case_sensitive as an option, ActiveRecord find is insensitive by default (have to model the db to let it be case sensitive?)
+      return nil if search_rules.blank?
+      cond = nil
+      expr = ''
+      vals = []
+      search_rules.each do |rule|
+
+        # Workaround for :include and nested attributes
+        field = rule['field'].split('.', 2)
+        if field.length == 2
+          rule['field'] = field[0].pluralize + "." + field[1]
+        end
+
+        expr << " #{search_rules_op} " unless expr.blank?
+        if op = OPS[rule['op']]
+          expr << "#{rule['field']} #{op} ?"
+          vals << rule['data']
+        elsif op = STRING_OPS[rule['op']]
+          expr << "#{rule['field']} #{op} ?"
+          vals << OPS_PATTERN[rule['op']].gsub('?', rule['data'])
+        end
+      end
+      cond = [ expr ] + vals
+    end
+  end
+end
+
+# # If you need to display error messages
+# err = ""
+# if user
+#   user.errors.entries.each do |error|
+#     err << "<strong>#{error[0]}</strong> : #{error[1]}<br/>"
+#   end
+# end
+#
+# render :text => "#{err}"
+
+# { :add => true, :edit => true, :inline_edit => false, :delete => true, :edit_url => "/users/post_data", :error_handler => "after_submit" }

data/lib/jquery/gridify/grid_options.rb

@@ -0,0 +1,279 @@
+module Gridify
+  class Grid
+    # non persistent options:
+    #             :build_model
+    #             :only
+    #             :except     
+             
+    attr_accessor :name,                  # name of the table (required)
+                  :resource,              # based on AR model class (assume tableized, plural, string)
+                                          # used as basis for all RESTful requests and data format
+    # model
+                  :colModel,              # incoming: hash of presets (native jqGrid); internally: array of GridColumn objects
+                                          # { :body => { "title" => {"width" => 98} }} 
+                  :colNames,              # Column names
+                  :colInclude,            # included submodels
+                  #:widths,               # hash of column width (key = data type)
+                  :searchable,            # default: true (used in generating columns, changing has no effect on existing cols)
+                  :sortable,              # default: true (used in generating columns, changing has no effect on existing cols)
+                  :editable,              # default: false (used in generating columns, changing has no effect on existing cols)
+                  :inline_edit,
+                  :inline_edit_handler,
+    # grid
+                  :dom_id,                # defaults to #{resource}_#{name} eg "notes_grid"
+                  :grid_view,
+                  :jqgrid_options,        # hash of additional jqGrid options that override any other settings
+                  :ajax_grid_options,
+    #subgrid
+                  :sub_grid,
+                  :sub_grid_url,
+                  :sub_grid_model,
+    # grid layout options
+                  :width,                 # in pixels, or nil (nil means calculated based on overflow setting)
+                  :width_fit,             # :fluid, :scroll, or :visible
+                                          # :fluid will always fit container (presently ignores width option)
+                                          # :scroll uses horizontal scrollbars
+                                          # :fitted scales columns to fit in width, not fluid              
+                  :height,                # in pixels, '100%', or :auto (150) 
+                                          # :auto means makes it as tall as needed per number of rows
+                  :resizable,             # allow gride resize with mouse, (true) (or {}) for default options; 
+                                          # nil or false for disabled; or hash of jqUI options
+                                          # see http://jqueryui.com/demos/resizable/
+                                          # defaults (differ from jqUI ones) "minWidth" => 150, "minHeight" => 80
+                                          # when overflow is fluid, "handles" => 's', otherwise 'e, s, se'
+                  :arranger,              # :sortable, :hide_show, :chooser, or nil for none (nil) , 
+                                          # can combine with array of options
+                                          # or can be a hash with options
+                                          # see http://www.trirand.com/jqgridwiki/doku.php?id=wiki:show_hide_columns  
+    # rows    
+                  :alt_rows,              # true for odd/even row classes, or odd row style name string (nil)
+                  :row_numbers,           # true to display row numbers in left column; or numeric width in pixels (nil)
+                  :select_rows,           # true for rows are selectable (eg for pager buttons); or js function when row is selected, false disables hover (true if pager buttons else false)
+                  :multi_select,
+                  :sortable_rows,
+    # header layer
+                  :title,                 # title string (aka caption), or true for resource.titleize, nil for no title (nil)                 
+                  :collapsible,           # when true generates collapse icon (false) 
+                  :collapsed,             # when true initial state is collapsed (false)
+                  
+    # pager layer
+                  :pager,                 # id of the pager, or true => dom_id+"_pager", false or nil for no pager (nil)
+                  :paging_controls,       # false to disable all (true); or hash with native jqGrid options
+                  :paging_choices,        # array of rows_per_page choices ([10,25,50,100])
+    # nav buttons
+                  :view_button,           # true, or hash of native jqGrid parameters and events for the action
+                  :add_button,
+                  :edit_button,
+                  :delete_button,               
+                  :search_button,         # enable search button and dialog
+                  :search_advanced,       # instead of search_button
+                  :search_toolbar,        # toggleable search bar, true or :visible, :hidden (other options?)  (nil)                 
+                  :refresh_button,
+                  :jqgrid_nav_options,    # native jqGrid button options (added to 2nd arg in navGrid method)          
+    # data
+                  :restful,               # use restful url and mtype (true) for all actions
+                  :finder,                # default: :find
+                  :url,                   # request url (required unless table_to_grid or derived from resource)
+                                          # if nil, uses "/#{resource}" eg "/notes"
+                                          # note, to force "editurl" use jqgrid_options
+                
+                  :data_type,             # :xml, :json, and other defined in jqGrid options doc (xml)
+                  :data_format,           # (defaults to rails conventin based on resource) <chickens><chicken><title><body> format
+                                          # set false for jqGrid default <rows><records><row><cell> format
+                  :sort_by,               # name of sort column of next request
+                  :sort_order,            # sort direction of next request, 'asc' or 'desc' ('asc')
+                  :case_sensitive,        # sort and search are case sensitive (false)                  
+                  :current_page,          # current page requested
+                  :rows_per_page,         # number of items to be requested in the next request (paging_choices.first or -1 if pager false)
+                  :total_rows,            # number of rows to read
+                  :table_to_grid,         # when true generates tableToGrid (false) from html table, then use as local data
+                                          # note, we assume table rows are not selectable. 
+                                          # (tableToGrid sets multiselect when first col has checkboxes or radio buttons, 
+                                          # we dont know to preserve this so you also need to set in options)                                        
+                  :load_once,             # true to use local data after first load (false)
+                  :error_handler,         # javacript: method for crud error handling (default to "after_submit")
+                  :error_container,       # selector for posting error/flash messages (.errorExplanation)
+     # events
+                  #:on_dbl_click_row,
+                  #:on_sort_col,
+                  #:serialize_grid_data, 
+                                                     
+                  :z        
+
+    # ----------------------  
+    # attribute defaults and special value handling
+    # (sure it'd be easier to initialize defaults using a hash but we want nil to mean the jqGrid default - might be true - and not pass a value at all)
+    
+    def inline_edit
+      @inline_edit==true ? true : false  
+    end
+    
+    def inline_edit_handler
+      @inline_edit_handler || 'null'  
+    end 
+    
+    def finder
+      @finder || :find
+    end
+    
+    def searchable
+      @searchable==false ? false : true
+    end
+    
+    def sortable
+      @sortable==false ? false : true
+    end 
+    
+    def sortable_rows
+      @sortable_rows==true ? true : false 
+    end    
+            
+    def dom_id
+      @dom_id || "#{resource}_#{name}"
+    end   
+            
+    def grid_view
+      @grid_view==false ? false : true 
+    end
+    
+    def jqgrid_options
+      @jqgrid_options || {}
+    end
+    
+    def ajax_grid_options
+      @ajax_grid_options || {}
+    end
+    
+    def width_fit
+      @width_fit || :fluid
+    end
+    
+    def resizable
+      return false if @resizable == false
+      rs = { "minWidth" => 150, "minHeight" => 80 }
+      rs.merge!({ "handles" => 's' }) if width_fit == :fluid
+      rs.merge!( @resizable ) if @resizable.is_a?(Hash)
+      rs
+    end
+    
+    def arranger_type #read-only
+      if arranger.is_a?(Hash)
+        arranger.keys
+      else
+        Array(arranger)
+      end
+    end
+    
+    def arranger_options(type) #read-only       
+      (arranger[type] if arranger.is_a?(Hash)) || {}
+    end
+    
+    def select_rows
+      if @select_rows
+        @select_rows
+      else
+        pager && (view_button || edit_button || delete_button)
+      end
+    end
+    
+    # header layer
+    def title
+      case @title
+      when String:  @title
+      when true:    resource.titleize
+      else          
+        ('&nbsp;' if collapsible || collapsed) #show header with blank title
+      end
+    end
+
+    def collapsible
+      @collapsible || @collapsed
+    end
+    
+    # pager layer
+    def pager
+      case @pager
+      when String:  @pager
+      when true:    dom_id+'_pager'
+      end
+    end  
+    
+    def paging_controls
+      @paging_controls.nil? ? true : @paging_controls
+    end
+    
+    def paging_choices
+      @paging_choices || [10,25,50,100]
+    end
+    
+    def restful
+      @restful==false ? false : true
+    end
+    
+    # data
+    def url
+      @url || "/#{resource}"
+    end
+    
+    def rows_per_page
+      #debugger
+      # all rows when pager controls or rows per page are off
+      if !pager || paging_controls==false || @rows_per_page==false || @rows_per_page==-1
+        -1
+      elsif @rows_per_page.nil?
+        paging_choices.first
+      else
+        @rows_per_page
+      end
+    end
+    
+    def data_type
+      @data_type || :json
+    end
+
+    def data_format
+      if @data_format || @data_format==false #explicit false for no param
+        @data_format
+      elsif resource && data_type == :xml
+        {
+          :root        => resource,
+          :page        => resource+'>page',
+          :total       => resource+'>total',
+          :records     => resource+'>records',
+          :row         => resource.singularize,
+          :repeatitems => false,
+          :id          => :id
+        }
+      elsif resource && data_type == :json
+        {
+          :root        => resource,
+          :page        => 'page',
+          :total       => 'total',
+          :records     => 'records',
+          :row         => resource.singularize,
+          :repeatitems => false,
+          :id          => :id
+        }
+      end
+    end
+    
+    # events
+    
+#    def serialize_grid_data
+#      @serialize_grid_data || {}
+#    end
+    
+    def error_handler
+      @error_handler || 'gridify_action_error_handler'
+    end
+    
+    def error_handler_return_value
+      error_handler ? error_handler : 'true;'
+    end
+    
+    def error_container
+      @error_container || '.errorExplanation'
+    end
+
+  end
+end