netzke-basepack 0.7.1 → 0.7.2

data/CHANGELOG.rdoc

@@ -1,6 +1,27 @@
+= 0.7.2 - 2011-10-20
+* bug fix
+  * Filter on a date column
+  * Using date column caused FormPanel to crash
+  * Virtual columns are no longer editable by default
+
+* improvements
+  * New DSL method (model) for declaring a model for grids
+  * New DSL method (column) for declaring columns for grids
+  * New :override_columns config option for grid allows overriding specified column config without influencing other columns' order/presence
+  * New DSL method (override_column) to override a specific column config without influencing other columns' order/presence.
+  * Grid's title is set to model's pluralized name by default.
+  * New :read_only option for FormPanel - makes all fields read-only and removes the "Apply" button.
+  * FormPanel implements DSL shortcuts for the following options in default config: :model, :items, :record_id.
+  * GridPanel implements DSL shortcuts for the following options in default config: :model, :add_form_config, :edit_form_config, :multi_edit_form_config.
+  * New FormPanel option :multi_edit - set when the form is used for editing multiple records at a time
+  * Introduce action columns (see BookGridWithColumnActions)
+
+* API changes
+  * Skip supporting ModelExtensions. The preferred way is using setters and getters on columns/fields.
+
 = 0.7.1 - 2011-09-04
 * bug fix
-  * fixing the netzke_load endpoint when association fields are present
+  * FormPanel: fix the netzke_load endpoint when association fields are present
   * dates were not displayed in date fields, and submitting a form with date fields might result in erasing those fields
 
 * Rails 3.1 compatibility

data/Rakefile

@@ -9,7 +9,7 @@ begin
     gemspec.email = "sergei@playcode.nl"
     gemspec.homepage = "http://netzke.org"
     gemspec.authors = ["Sergei Kozlov"]
-    gemspec.add_dependency("netzke-core",   "~>0.7.0")
+    gemspec.add_dependency("netzke-core",   "~>0.7.4")
     gemspec.add_dependency("will_paginate", "~>3.0.0")
     gemspec.add_dependency("acts_as_list",  "~>0.1.4")
     gemspec.post_install_message = <<-MESSAGE

data/lib/netzke/active_record/attributes.rb

@@ -184,7 +184,7 @@ module Netzke
         end
 
         # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
-        v = v.to_datetime.to_s(:db) if v.is_a?(ActiveSupport::TimeWithZone)
+        v = v.to_datetime.to_s(:db) if [ActiveSupport::TimeWithZone, Date].include?(v.class)
 
         v
       end

data/lib/netzke/basepack/action_column.rb

@@ -0,0 +1,70 @@
+module Netzke
+  module Basepack
+    module ActionColumn
+      extend ActiveSupport::Concern
+
+      included do |base|
+        js_include :action_column
+      end
+
+      module ClassMethods
+        # Register an action
+        def register_column_action(name)
+          current_column_actions = read_inheritable_attribute(:column_actions) || []
+          current_column_actions << name
+          write_inheritable_attribute(:column_actions, current_column_actions.uniq)
+        end
+
+        # Returns registered actions
+        def registered_column_actions
+          read_inheritable_attribute(:column_actions) || []
+        end
+
+        # Use this method to define column actions in your component, e.g.:
+        #
+        #     column_action :edit, :icon => "/images/icons/edit.png"
+        #
+        # TODO: List all options.
+        # TODO: think how it'll be possible to override individual column_actions (if need to bother at all)
+        def column_action(name, params = {})
+          params[:name] = name
+          params[:column] ||= "actions"
+          params[:icon] ||= "/extjs/examples/shared/icons/fam/cog.png"
+          params[:tooltip] = params[:tooltip].presence || name.to_s.humanize
+          params[:handler] ||= "on_#{name}"
+          register_column_action(name);
+          define_method "#{name}_column_action" do |record=nil| # TODO: this won't work in Ruby 1.8.7
+            params[:row_config] && record ? params.merge(params[:row_config].call(record, self)) : params
+          end
+        end
+      end
+
+      def initial_columns(with_excluded = false)
+        orig_columns = super
+
+        action_column_names = column_actions.map{ |action| action[:column] }.uniq
+        action_columns = orig_columns.select{ |c| action_column_names.include? c[:name] }
+
+        # Append the column if none found AND no explicit column configuration was provided
+        if action_columns.empty? && !config[:columns]
+          action_columns = [{:name => "actions"}.merge(config[:override_columns].try(:fetch, :actions, nil) || {})]
+          orig_columns += action_columns
+        end
+
+        action_columns.each do |c|
+          c[:xtype] = :netzkeactioncolumn
+          c[:getter] = lambda do |r|
+            self.class.registered_column_actions.select{ |action_name| self.send("#{action_name}_column_action")[:column] == c[:name] }.map{ |action_name| self.send("#{action_name}_column_action", r) }.to_nifty_json
+          end
+        end
+
+        orig_columns
+      end
+
+      def column_actions
+        self.class.registered_column_actions.map{ |action_name| self.send("#{action_name}_column_action")}
+      end
+
+    end
+  end
+end

data/lib/netzke/basepack/action_column/javascripts/action_column.js

@@ -0,0 +1,61 @@
+Ext.define('Ext.grid.column.NetzkeAction', {
+    extend: 'Ext.grid.column.Action',
+    alias: ['widget.netzkeactioncolumn'],
+
+    constructor: function(config) {
+        var me = this,
+            cfg = Ext.apply({}, config),
+            i,
+            item;
+
+        me.callParent([cfg]);
+
+        me.renderer = function(actions, meta) {
+          // previous renderer
+          var v = Ext.isFunction(cfg.renderer) ? cfg.renderer.apply(this, arguments)||'' : '',
+              actions = Ext.decode(actions),
+              l = actions.length,
+              action;
+
+          meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
+
+          for (i = 0; i < l; i++) {
+            action = actions[i];
+            if (!action.hidden) {
+              v += '<img alt="' + (action.altText || me.altText) + '" src="' + (action.icon || Ext.BLANK_IMAGE_URL) +
+                  '" class="' + Ext.baseCSSPrefix + 'action-col-icon ' + Ext.baseCSSPrefix + 'action-col-' + String(i) + ' ' +  (action.iconCls || '') +
+                  ' ' + (Ext.isFunction(action.getClass) ? action.getClass.apply(action.scope||me.scope||me, arguments) : (me.iconCls || '')) + '"' +
+                  ((action.tooltip) ? ' data-qtip="' + action.tooltip + '"' : '') +
+                  ' data-name="' + action.name + '"' +
+                  ((action.handler) ? ' data-handler="' + action.handler + '"' : '') + ' />';
+            }
+          }
+
+          return v;
+        };
+    },
+
+    processEvent : function(type, view, cell, recordIndex, cellIndex, e){
+        var me = this,
+            target = e.getTarget(),
+            match = target.className.match("x-action-col-icon"),
+            fn, grid, record;
+        if (match) {
+            if (type == 'click') {
+                grid = me.ownerCt.ownerCt;
+                fn = (target.getAttribute("data-handler") || "").camelize(true);
+                fn = Ext.isFunction(grid[fn]) ? grid[fn] : undefined;
+                // if (fn) fn.call(grid, view, recordIndex, cellIndex, target, e);
+                if (fn) {
+                  record = grid.getStore().getAt(recordIndex);
+                  fn.call(grid, record, target, e);
+                } else {
+                  Netzke.warning("Undefined handler for column action '" + target.getAttribute("data-name") + "'");
+                }
+            } else if (type == 'mousedown') {
+                return false;
+            }
+        }
+        return me.callParent(arguments);
+    }
+});

data/lib/netzke/basepack/data_accessor.rb

@@ -76,18 +76,7 @@ module Netzke
 
       # Model class
       def data_class
-        @data_class ||= begin
-          klass = constantize_class_name("Netzke::ModelExtensions::#{config[:model]}For#{short_component_class_name}") || original_data_class
-        end
-      end
-
-      # Model class before model extensions are taken into account
-      def original_data_class
-        @original_data_class ||= begin
-          ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-          model_name = config[:model] || config[:data_class_name]
-          model_name && constantize_class_name(model_name)
-        end
+        @data_class ||= config[:model] && config[:model].constantize
       end
 
       # whether a column is bound to the primary_key
@@ -164,7 +153,9 @@ module Netzke
       #      relation.where(["id > ?", 10]).where(["food_name like ?", "%pizza%"])
       def apply_column_filters(relation, column_filter)
         res = relation
-        operator_map = {"lt" => "<", "gt" => ">"}
+        operator_map = {"lt" => "<", "gt" => ">", "eq" => "="}
+
+        table_name = data_class.table_name
 
         # these are still JSON-encoded due to the migration to Ext.direct
         column_filter=JSON.parse(column_filter)
@@ -183,11 +174,15 @@ module Netzke
 
           case v["type"]
           when "string"
-            res = res.where(["#{field} like ?", "%#{value}%"])
-          when "numeric", "date"
-            res = res.where(["#{field} #{op} ?", value])
+            res = res.where(["#{table_name}.#{field} like ?", "%#{value}%"])
+          when "date"
+            # convert value to the DB date
+            value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
+            res = res.where("#{table_name}.#{field} #{op} ?", "#{$3}-#{$1}-#{$2}")
+          when "numeric"
+            res = res.where(["#{table_name}.#{field} #{op} ?", value])
           else
-            res = res.where(["#{field} = ?", value])
+            res = res.where(["#{table_name}.#{field} = ?", value])
           end
         end
 

data/lib/netzke/basepack/form_panel.rb

@@ -37,13 +37,12 @@ module Netzke
       class_attribute :config_tool_available
       self.config_tool_available = true
 
-      class_attribute :default_config
-      self.default_config = {} # To be filled in
-
       include self::Services
       include self::Fields
       include Netzke::Basepack::DataAccessor
 
+      delegates_to_dsl :model, :record_id
+
       action :apply do
         {
           :text => I18n.t('netzke.basepack.form_panel.actions.apply'),
@@ -72,6 +71,8 @@ module Netzke
         super.tap do |sup|
           configure_locked(sup)
           configure_bbar(sup)
+
+          sup[:record_id] = sup[:record] = nil if sup[:multi_edit] # never set record_id in multi-edit mode
         end
       end
 
@@ -80,7 +81,7 @@ module Netzke
       end
 
       def configure_bbar(c)
-        c[:bbar] = [:apply.action] if c[:bbar].nil?
+        c[:bbar] = [:apply.action] if c[:bbar].nil? && !c[:read_only]
       end
 
       # Extra JavaScripts and stylesheets

data/lib/netzke/basepack/form_panel/fields.rb

@@ -185,7 +185,7 @@ module Netzke
           def attr_type_to_xtype_map
             {
               :integer => :numberfield,
-              :boolean => :checkboxfield,
+              :boolean => config[:multi_edit] ? :tricheckbox : :checkboxfield,
               :date => :datefield,
               # WIP: waiting for datetime.js implementation for ExtJS 4
               # :datetime => :datetimefield,

data/lib/netzke/basepack/form_panel/javascripts/form_panel.js

@@ -24,7 +24,7 @@
       trackResetOnLoad: true,
     }
 
-    if (!this.bbar) this.bbar = {xtype: 'toolbar'}; // an empty bbar by default, so that we can dynamically add buttons
+    if (!this.bbar && !this.readOnly) this.bbar = {xtype: 'toolbar'}; // an empty bbar by default, so that we can dynamically add buttons
 
     // Custom error reader. We don't use it to process form values, but rather to normalize the response from the server in case of "real" (iframe) form submit.
     ErrorReader = function(){};
@@ -55,7 +55,7 @@
     if (this.record) { this.setFormValues(this.record); }
 
     // render in display mode?
-    if (this.locked) this.setReadonlyMode(true);
+    if (this.locked || this.readOnly) this.setReadonlyMode(true);
   },
 
   onEdit: function(){
@@ -201,7 +201,7 @@
     // this.getForm().cleanDestroyed(); // because fields inside of composite fields are not auto-cleaned!
     this.doLayout();
     this.inReadonlyMode = onOff;
-    this.updateToolbar();
+    if (this.mode == "lockable") this.updateToolbar();
   },
 
   // recursively extract field names

data/lib/netzke/basepack/grid_panel.rb

@@ -183,8 +183,45 @@ module Netzke
         js_include(ex.join("#{File.dirname(__FILE__)}/grid_panel/javascripts/rows-dd.js"))
       end
 
+      # Allows children classes to simply do
+      #
+      #     model "User"
+      delegates_to_dsl :model, :add_form_config, :add_form_window_config, :edit_form_config, :edit_form_window_config, :multi_edit_form_config, :multi_edit_form_window_config
+
+      # Inject some handy DSL methods into the child classes.
+      def self.inherited(base)
+        super
+
+        base.class_eval do
+          class << self
+            def column(name, config = {})
+              columns = self.read_inheritable_attribute(:columns) || []
+              columns << config.merge(:name => name.to_s)
+              self.write_inheritable_attribute(:columns, columns)
+            end
+
+            def override_column(name, config)
+              columns = self.read_inheritable_attribute(:overridden_columns) || {}
+              columns.merge!(name.to_sym => config)
+              self.write_inheritable_attribute(:overridden_columns, columns)
+            end
+          end
+        end
+      end
+
+      def configuration
+        super.tap do |c|
+          c[:columns] ||= self.class.read_inheritable_attribute(:columns)
+
+          # user-passed :override_columns option should get deep_merged with the defaults
+          c[:override_columns] = (self.class.read_inheritable_attribute(:overridden_columns) || {}).deep_merge(c[:override_columns] || {})
+        end
+      end
+
       def js_config #:nodoc:
-        super.merge({
+        res = super
+        res.merge({
+          :title => res[:title] || self.class.js_properties[:title] || data_class.name.pluralize,
           :bbar => config.has_key?(:bbar) ? config[:bbar] : default_bbar,
           :context_menu => config.has_key?(:context_menu) ? config[:context_menu] : default_context_menu,
           :columns => columns(:with_meta => true), # columns
@@ -307,60 +344,74 @@ module Netzke
       end
 
       component :add_form do
+        form_config = {
+          :class_name => "Netzke::Basepack::FormPanel",
+          :model => config[:model],
+          :persistent_config => config[:persistent_config],
+          :strong_default_attrs => config[:strong_default_attrs],
+          :border => true,
+          :bbar => false,
+          :prevent_header => true,
+          :mode => config[:mode],
+          :record => data_class.new(columns_default_values)
+        }
+
+        # Only provide default form fields when no custom class_name is specified for the form
+        form_config[:items] = default_fields_for_forms unless config[:add_form_config] && config[:add_form_config][:class_name]
+
         {
           :lazy_loading => true,
           :class_name => "Netzke::Basepack::GridPanel::RecordFormWindow",
           :title => "Add #{data_class.model_name.human}",
           :button_align => "right",
-          :items => [{
-            :class_name => "Netzke::Basepack::FormPanel",
-            :model => config[:model],
-            :items => default_fields_for_forms,
-            :persistent_config => config[:persistent_config],
-            :strong_default_attrs => config[:strong_default_attrs],
-            :border => true,
-            :bbar => false,
-            :prevent_header => true,
-            :mode => config[:mode],
-            :record => data_class.new(columns_default_values)
-          }.deep_merge(config[:add_form_config] || {})]
+          :items => [form_config.deep_merge(config[:add_form_config] || {})]
         }.deep_merge(config[:add_form_window_config] || {})
       end
 
       component :edit_form do
-        {
-          :lazy_loading => true,
-          :class_name => "Netzke::Basepack::GridPanel::RecordFormWindow",
-          :title => "Edit #{data_class.model_name.human}",
-          :button_align => "right",
-          :items => [{
+          form_config = {
             :class_name => "Netzke::Basepack::FormPanel",
             :model => config[:model],
-            :items => default_fields_for_forms,
             :persistent_config => config[:persistent_config],
             :bbar => false,
             :prevent_header => true,
             :mode => config[:mode]
             # :record_id gets assigned by deliver_component dynamically, at the moment of loading
-          }.deep_merge(config[:edit_form_config] || {})]
+          }
+
+          # Only provide default form fields when no custom class_name is specified for the form
+          form_config[:items] = default_fields_for_forms unless config[:edit_form_config] && config[:edit_form_config][:class_name]
+
+        {
+          :lazy_loading => true,
+          :class_name => "Netzke::Basepack::GridPanel::RecordFormWindow",
+          :title => "Edit #{data_class.model_name.human}",
+          :button_align => "right",
+          :items => [form_config.deep_merge(config[:edit_form_config] || {})]
         }.deep_merge(config[:edit_form_window_config] || {})
       end
 
       component :multi_edit_form do
+        form_config = {
+          :class_name => "Netzke::Basepack::FormPanel",
+          :multi_edit => true,
+          :model => config[:model],
+          :persistent_config => config[:persistent_config],
+          :bbar => false,
+          :prevent_header => true,
+          :name => "multi_edit_form0", # we detect multi-edit form submission by its name
+          :mode => config[:mode]
+        }
+
+        # Only provide default form fields when no custom class_name is specified for the form
+        form_config[:items] = default_fields_for_forms unless config[:multi_edit_form_config] && config[:multi_edit_form_config][:class_name]
+
         {
           :lazy_loading => true,
           :class_name => "Netzke::Basepack::GridPanel::RecordFormWindow",
           :title => "Edit #{data_class.model_name.human.pluralize}",
           :button_align => "right",
-          :items => [{
-            :class_name => "Netzke::Basepack::GridPanel::MultiEditForm",
-            :model => config[:model],
-            :items => default_fields_for_forms,
-            :persistent_config => config[:persistent_config],
-            :bbar => false,
-            :prevent_header => true,
-            :mode => config[:mode]
-          }.deep_merge(config[:multi_edit_form_config] || {})]
+          :items => [form_config.deep_merge(config[:multi_edit_form_config] || {})]
         }.deep_merge(config[:multi_edit_form_window_config] || {})
       end