gridify 0.1.0

data/lib/gridify/grid.rb

@@ -0,0 +1,149 @@
+require 'gridify/assertions'
+require 'gridify/grid_options'
+require 'gridify/grid_view'
+require 'gridify/grid_column'
+require 'gridify/grid_finder'
+
+# NOTE: for readablity/clarity, native jqGrid options should be string; Ruby ones as syms
+
+module Gridify
+  class Grid
+    include Assertions
+
+    # todo: change this so klass is optional, decouple from active record
+    def initialize( klass, *args, &block )
+      #debugger
+      options = args.extract_options! # => args.last.is_a?(Hash) ? args.pop : {}
+      assert_exclusive_keys( options, :only, :except)
+      
+      @resource = klass.to_s.tableize.pluralize
+      @name = args.first || :grid
+      
+      # non-persistent options
+      # generate model unless explicitly say no
+      build_model = options.delete(:build_model) == false ? false : true
+      only = options.delete(:only)
+      except = options.delete(:except)
+      col_presets = options.delete(:columns)
+      
+      # assign options
+      update options
+      
+      # build columns from ActiveRecord model (klass)
+      if klass.present? && build_model
+        @model = build_columns klass, only, except, col_presets
+      end
+      
+      instance_eval(&block) if block
+      #(note instance_eval cannot access things outside its scope; otherwise do this:
+      #yield self if block_given?
+    end
+    
+    def update( options )
+      options.each {|atr, val| send( "#{atr}=", val )}
+      # exception "invalid option..."
+    end
+
+    def column( name, options={} )
+      name = name.to_s
+      klass = resource.classify.constantize
+      # TODO: set edit options based on ar_column 
+      # TODO: edit
+      # TODO: handle file input types
+      # TODO: custom input types 
+      if col = columns_hash[name]
+        # update an existing column
+        col.update options
+        
+      elsif ar = klass.columns.detect {|c| c.name==name}
+        #debugger
+        # create column from database schema
+        edit = editable && 
+          # only edit accessible attributes
+          (klass.accessible_attributes.nil? || klass.accessible_attributes.include?(ar.name))
+        args = {
+          :ar_column => ar,
+          :name => ar.name,
+          :value_type => ar.type,
+          :searchable => searchable,
+          :sortable => sortable,
+          :editable => edit
+        }.merge(options)
+        columns << GridColumn.new( args)
+        
+      else
+        # create column from scratch
+        args = {
+          :name => name,
+          :value_type => :string,
+          :searchable => searchable,
+          :sortable => sortable,
+          :editable => edit
+        }.merge(options)
+        columns << GridColumn.new( args)
+      end
+    end
+  
+    def column_names
+      columns.collect {|col| col.name.titleize }
+    end
+    
+    def column_model
+      columns.collect {|col| col.properties }
+    end
+    
+    # normally we need to keep columns an ordered array, sometimes its convenient to have a hash
+    def columns_hash
+      columns.inject({}) {|h, col| h[col.name] = col; h }
+    end
+    
+    protected
+    
+    # # isnt there something in rails to do this already?
+    # def parse_options( keys, options )
+    #   ops = keys.inject({}) do |h, k| 
+    #     val = options.delete(k) 
+    #     h[k] = val unless val.nil?
+    #     h
+    #   end
+    #   ops || {}
+    # end
+
+    # generate list of columns based on AR model
+    # option:  :only or :except
+    #          :col_options  hash of hash of preset values for columns (eg from cookie) { :title => {:width => 98}}
+    def build_columns( klass, only, except, presets )
+      #debugger
+      # stringify
+      only = Array(only).map {|s| s.to_s }
+      except = Array(except).map {|s| s.to_s }
+      presets ||= {}
+      presets.stringify_keys!
+      
+      self.columns = klass.columns.collect do |ar|
+        #debugger
+        next if only.present? && !only.include?(ar.name)
+        next if except.present? && except.include?(ar.name)
+        is_key = (ar.name=='id')
+        edit = editable && !is_key && 
+          # only edit accessible attributes
+          (klass.accessible_attributes.nil? || klass.accessible_attributes.include?(ar.name))
+        args = {
+          :ar_column => ar,
+          :name => ar.name,
+          :value_type => ar.type,
+          :key => is_key,
+          :hidden => is_key,
+          :searchable => searchable,
+          :sortable => sortable,
+          :editable => edit
+        }
+
+        # create column with default args merged with options given for this column
+        GridColumn.new args.merge( presets[ar.name]||{} )
+      end.compact      
+    end
+    
+    
+  end
+end

data/lib/gridify/grid_column.rb

@@ -0,0 +1,121 @@
+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) or 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)
+                  :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[:sorttype]   = jqgrid_type   if sortable 
+      vals[:search]     = false         if searchable==false  
+      vals[:editable]   = true          if editable
+      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[:editoptions] = edit_options if editable && edit_options
+      vals[:editrules]  = validations   if editable && validations
+        # 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/gridify/grid_finder.rb

@@ -0,0 +1,197 @@
+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.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]
+    end
+
+    # return find args (scope) for current settings
+    def current_scope
+      #debugger
+      find_args = {}
+      if sort_by.present? && col = columns_hash[sort_by]
+        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 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
+      find_args = current_scope
+      klass = resource.classify.constantize
+      records = klass.send( finder, :all, find_args )
+    end
+    
+    def encode_records( records, 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
+        xml = records.to_xml( :skip_types => true, :dasherize => false ) do |xml|
+          if rows_per_page > 0
+            xml.page          current_page
+            xml.total_pages   total_pages
+            xml.total_records total_count
+          end
+        end
+        
+      when :json
+        #debugger
+        data = { resource => records }
+        if rows_per_page > 0       
+          data.merge!( 
+            :page => current_page, 
+            :total_pages => total_pages, 
+            :total_records => total_count 
+          )
+        end
+        
+        save = ActiveRecord::Base.include_root_in_json
+        ActiveRecord::Base.include_root_in_json = false
+        json = data.to_json
+        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
+          columns.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|
+        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" }