netzke-basepack 0.12.9 → 1.0.0.0.pre

data/lib/netzke/basepack/dynamic_tab_panel.rb

@@ -3,19 +3,17 @@ module Netzke
     # A tab panel that can load components dynamically by their class name. Components can be loaded in the current or new tab.
     # For example:
     #
-    #     this.netzkeLoadComponentByClass('BookGrid', {newTab: true, clientConfig: {read_only: true}});
+    #     this.netzkeLoadComponentByClass('BookGrid', {newTab: true, serverConfig: {read_only: true}});
     #
     class DynamicTabPanel < Netzke::Base
-      js_configure do |c|
+      client_class do |c|
         c.extend = "Ext.tab.Panel"
-        c.mixin
       end
 
       # Override this method if you need more control on what components can/cannot be loaded, or in order to access
       # `client_config`
       component :child do |c|
-        # c.client_config <== is accessible here
-        c.klass = (c.client_config[:klass] || "Netzke::Core::Panel").constantize
+        c.class_name = c.client_config[:class_name] || "Netzke::Core::Panel"
       end
     end
   end

data/lib/netzke/basepack/dynamic_tab_panel/{javascripts → client}/dynamic_tab_panel.js

@@ -1,9 +1,11 @@
 {
+  tabCounter: 0,
+
   netzkeTabComponentDelivered: function(c, config) {
     var tab,
         i,
         activeTab = this.getActiveTab(),
-        cmp = Ext.ComponentManager.create(Ext.apply(c, {closable: true}));
+        cmp = Ext.create(Ext.apply(c, {closable: true}));
 
     if (config.newTab || activeTab == null) {
       tab = this.add(cmp);
@@ -20,10 +22,9 @@
   netzkeLoadComponentByClass: function(klass, options) {
     this.netzkeLoadComponent('child', Ext.apply(options, {
       configOnly: true,
-      clone: true,
-      clientConfig: Ext.apply(options.clientConfig || {}, {klass: klass}),
-      callback: this.netzkeTabComponentDelivered,
-      scope: this,
+      itemId: "tab_" + this.tabCounter++,
+      serverConfig: Ext.apply(options.serverConfig || {}, { class_name: klass }),
+      callback: this.netzkeTabComponentDelivered
     }));
   }
 }

data/lib/netzke/basepack/field_config.rb

@@ -1,48 +1,60 @@
 module Netzke
   module Basepack
-    # Takes care of automatic field configuration in {Basepack::Form}
+    # Takes care of automatic field configuration in {Form::Base}
     class FieldConfig < AttrConfig
-      def set_defaults!
+      def merge_attribute(attr)
+        self.merge!(attr)
+
+        self.field_label = self.delete(:label) if self.has_key?(:label)
+
+        self.merge!(delete(:field_config)) if self.has_key?(:field_config)
+
+        self.merge!(editor_config) if self.has_key?(:editor_config)
+
+        self.delete(:column_config) if self.has_key?(:column_config)
+      end
+
+      def set_defaults
         super
 
-        self.attr_type ||= @data_adapter.attr_type(name)
+        self.type ||= @model_adapter.attr_type(name)
 
-        set_xtype! if xtype.nil?
+        set_xtype if xtype.nil?
 
-        self.field_label ||= @data_adapter.human_attribute_name(name).gsub(/\s+/, " ")
+        self.field_label ||= default_label
 
         self.hidden = true if hidden.nil? && primary?
         self.hide_label = hidden if hide_label.nil?
 
-        case attr_type
+        case type
         when :boolean
-          configure_checkbox!
+          configure_checkbox
         when :date
-          configure_date_field!
+          configure_date_field
         end
       end
 
     private
 
-      def set_xtype!
+      def set_xtype
         if association?
-          set_xtype_for_association!
+          set_xtype_for_association
         else
-          self.xtype = xtype_for_attr_type(attr_type)
+          self.xtype = xtype_for_type(type)
         end
       end
 
-      def set_xtype_for_association!
+      def set_xtype_for_association
         assoc_name, method = name.split('__').map(&:to_sym)
-        assoc_method_type = @data_adapter.get_assoc_property_type(assoc_name, method)
+        assoc_method_type = @model_adapter.get_assoc_property_type(assoc_name, method)
         if nested_attribute
-          self.xtype = xtype_for_attr_type(assoc_method_type)
+          self.xtype = xtype_for_type(assoc_method_type)
         else
-          self.xtype = assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : :netzkeremotecombo
+          self.xtype = assoc_method_type == :boolean ? xtype_for_type(assoc_method_type) : :netzkeremotecombo
         end
       end
 
-      def xtype_for_attr_type(type)
+      def xtype_for_type(type)
         { integer:    :numberfield,
           boolean:    :checkboxfield,
           date:       :datefield,
@@ -53,15 +65,14 @@ module Netzke
         }[type] || :textfield
       end
 
-      def configure_checkbox!
+      def configure_checkbox
         self.checked = value
         self.unchecked_value = false
         self.input_value = true
       end
 
-      def configure_date_field!
+      def configure_date_field
         self.submit_format = "Y-m-d"
-        # DEBT: why is self.format not working?? ('too few arguments')
         self[:format] ||= I18n.t("date", scope: 'netzke.formats', default: "Y-m-d")
       end
     end

data/lib/netzke/basepack/fields.rb

@@ -6,25 +6,27 @@ module Netzke
 
       # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.Form to render a field)
       def items
-        prepend_primary_key(config.items) || data_adapter.model_attributes
+        prepend_primary_key(config.items) || model_adapter.model_attributes
       end
 
       # Hash of fully configured fields, that are referenced in the items. E.g.:
-      #   { :role__name => {:xtype => 'netzkeremotecombo', :disabled => true, :value => "admin"},
-      #     :created_at => {:xtype => 'datetime', :disabled => true, :value => "2010-10-10 10:10"}
+      #   {
+      #     role__name: {xtype: 'netzkeremotecombo', disabled: true, value: "admin"},
+      #     created_at: {xtype: 'datetime', disabled: true, value: "2010-10-10 10:10"}
       #   }
       def fields
         @_fields ||= fields_from_items.tap do |flds|
           # add primary key field if not present
-          primary_key = data_adapter.primary_key
+          primary_key = model_adapter.primary_key
           flds[primary_key.to_sym] ||= {name: primary_key}
         end
       end
 
       # Hash of normalized field configs extracted from :items, e.g.:
       #
-      #     { :role__name => {:xtype => "netzkeremotecombo"},
-      #       :password => {:xtype => "passwordfield"}
+      #     {
+      #       role__name: {xtype: "netzkeremotecombo"},
+      #       password: {xtype: "passwordfield"}
       #     }
       def fields_from_items
         @fields_from_items || (normalize_config || true) && @fields_from_items
@@ -39,14 +41,22 @@ module Netzke
       end
 
       def extend_field(field)
-        Netzke::Basepack::FieldConfig.new(field, data_adapter).tap do |c|
-
+        Netzke::Basepack::FieldConfig.new(field, model_adapter).tap do |c|
           # not binding to a model attribute
-          return c if c.no_binding
+          return c if c.bind == false
+
+          # merge in attribute
+          c.merge_attribute(attribute_overrides[c.name.to_sym] || {})
+
+          return nil if c.excluded
 
           @fields_from_items[c.name.to_sym] = c
 
-          c.set_defaults!
+          c.set_defaults
+
+          if c.type == :boolean && multiedit?
+            c.xtype = 'netzketristate' if c.type == :boolean
+          end
         end
       end
 
@@ -54,13 +64,13 @@ module Netzke
 
       def prepend_primary_key(items)
         items && items.tap do |items|
-          items.insert(0, data_adapter.primary_key.to_sym) if !includes_primary_key?(items)
+          items.insert(0, model_adapter.primary_key.to_sym) if !includes_primary_key?(items)
         end
       end
 
       def includes_primary_key?(items)
         !!items.detect do |item|
-          (item.is_a?(Hash) ? item[:name] : item.to_s) == data_adapter.primary_key
+          (item.is_a?(Hash) ? item[:name] : item.to_s) == model_adapter.primary_key
         end
       end
 

data/lib/netzke/basepack/grid_live_search.rb

@@ -4,7 +4,7 @@ module Netzke
     # attribute, and assign the search operator. The grid will be updated on changing those fields, to reflect the
     # query.
     #
-    # See Grid::LiveSearch in spec/rails_app for a usage example.
+    # See `Grid::LiveSearch` in spec/rails_app for a usage example.
     #
     # == Configuration:
     #
@@ -23,9 +23,6 @@ module Netzke
     # Trying to search on a *virtual* column that is *not shown* in the grid will break. A fix would require refactoring
     # of +Grid::Columns+.
     class GridLiveSearch < Netzke::Plugin
-      js_configure do |c|
-        c.mixin
-      end
     end
   end
 end

data/lib/netzke/basepack/grid_live_search/{javascripts → client}/grid_live_search.js

@@ -1,15 +1,17 @@
 {
-  init: function(){
-    this.callParent(arguments);
-
-    this.searchControls = this.cmp.query('field[attr]');
+  init: function(cmp){
+    this.searchControls = cmp.query('field[attr]');
 
     Ext.each(this.searchControls, function(control){
+      var delay = 0;
+
+      if (control.xtype == 'textfield' || control.xtype == 'numberfield') delay = this.delay || 500;
+
       control.on('change', Ext.Function.createBuffered(function(self){
         var query = this.buildQuery();
-        this.cmp.getStore().getProxy().extraParams.query = [query];
-        this.cmp.getStore().reload();
-      }, this.delay || 500, this));
+        cmp.getStore().getProxy().extraParams.query = [query];
+        cmp.netzkeReloadStore();
+      }, delay, this));
     }, this);
   },
 

data/lib/netzke/basepack/item_persistence.rb

@@ -11,16 +11,16 @@ module Netzke
         end
 
         # Added endpoints
-        endpoint :region_resized do |params, this|
+        endpoint :region_resized do |params|
           state[:"#{params[:item]}_width"] = params[:width].to_i if params[:width]
           state[:"#{params[:item]}_height"] = params[:height].to_i if params[:height]
         end
 
-        endpoint :region_collapsed do |params, this|
+        endpoint :region_collapsed do |params|
           state[:"#{params[:item]}_collapsed"] = true
         end
 
-        endpoint :region_expanded do |params, this|
+        endpoint :region_expanded do |params|
           state[:"#{params[:item]}_collapsed"] = false
         end
       end

data/lib/netzke/basepack/item_persistence/events_plugin.rb

@@ -2,12 +2,10 @@ module Netzke
   module Basepack
     module ItemPersistence
       class EventsPlugin < Netzke::Plugin
-        js_configure do |c|
+        client_class do |c|
           c.init = <<-JS
-            function(){
-              this.callParent(arguments);
-
-              this.cmp.on('afterlayout', function(){
+            function(cmp){
+              cmp.on('afterlayout', function(){
 
                 // scope of the parent panel
                 this.items.each(function(item, index, length){
@@ -18,26 +16,26 @@ module Netzke
 
                     if ((panel.region == 'west' || panel.region == 'east') && panel.oldSize.width != w) {
                       params.width = w;
-                      this.regionResized(params);
+                      this.server.regionResized(params);
                     } else if (panel.region == 'north' || panel.region == 'south' && panel.oldSize.height != h){
                       params.height = h;
-                      this.regionResized(params);
+                      this.server.regionResized(params);
                     }
 
                     panel.oldSize = panel.getSize();
                   }, this);
 
                   item.on('collapse', function(panel){
-                    this.regionCollapsed({item: panel.itemId});
+                    this.server.regionCollapsed({item: panel.itemId});
                   }, this);
 
                   item.on('expand', function(panel){
-                    this.regionExpanded({item: panel.itemId});
+                    this.server.regionExpanded({item: panel.itemId});
                   }, this);
 
                 }, this);
 
-              }, this.cmp, {single: true});
+              }, cmp, {single: true});
             }
           JS
         end

data/lib/netzke/basepack/paging_form.rb

@@ -3,7 +3,7 @@ module Netzke
     # A Form with paging toolbar. Allows browsing and editing records one-by-one.
     #
     # == Configuration
-    # Besides +Netzke::Basepack::Form+ config options, accepts:
+    # Besides +Netzke::Form::Base+ config options, accepts:
     # * +scope+ - specifies how the data should be filtered.
     #   When it's a symbol, it's used as a scope name.
     #   When it's a string, it's a SQL statement (passed directly to +ActiveRecord::Relation#where+).
@@ -19,25 +19,21 @@ module Netzke
     # == ToDo
     # * Update the number of records after form submit
     class PagingForm < Form
-      js_configure do |c|
-        c.mixin
-      end
-
       # override
       def record
-        @record ||= data_adapter.first
+        @record ||= model_adapter.first
       end
 
-      def js_configure(c)
+      def configure_client(c)
         super
         # Pass total records amount and the first record to the JS constructor
         c.total_records = total_records
       end
 
-      endpoint :get_data do |params, this|
-        @record = data_adapter.get_records(params).first
+      endpoint :get_data do |params|
+        @record = model_adapter.get_records(params).first
         record_hash = @record && js_record_data
-        this.merge!(:records => record_hash && [record_hash] || [], :total => total_records(params))
+        client.merge!(:records => record_hash && [record_hash] || [], :total => total_records(params))
       end
 
       action :search do |a|
@@ -59,7 +55,7 @@ module Netzke
     protected
 
       def total_records(params = {})
-        @total_records ||= data_adapter.count_records(params, [])
+        @total_records ||= model_adapter.count_records(params, [])
       end
     end
   end

data/lib/netzke/basepack/paging_form/{javascripts → client}/paging_form.js

@@ -1,5 +1,5 @@
 {
-  onSearch: function(el) {
+  netzkeOnSearch: function(el) {
     if (this.searchWindow) {
       this.searchWindow.show();
     } else {
@@ -44,10 +44,10 @@
     // because we need to build the store for PagingToolbar that cannot be created after superclass.initComponent
     // Otherwise, the things would be simpler, because this.getForm().items would already have all the fields in one place for us
     this.fieldNames = [];
-    this.extractFields(this.items);
+    this.netzkeExtractFields(this.items);
 
     var store = new Ext.data.DirectStore({
-      directFn: Netzke.providers[this.id].getData,
+      directFn: this.netzkeDirect.getData,
       root: 'records',
       fields: this.fieldNames.concat('meta'),
       pageSize: 1
@@ -57,7 +57,7 @@
       if (r.length == 0) {
         this.getForm().reset();
       } else {
-        this.setFormValues(r[0].data);
+        this.netzkeSetFormValues(r[0].data);
       }
     }, this);
 

data/lib/netzke/basepack/query_builder.rb

@@ -3,20 +3,18 @@ module Netzke
     # Search query builder used in Grid's advanced search.
     # Based on Ext.tab.Panel. A new tab is created for each OR condition. Each tab contains an instance of SearchPanel which is used to build AND conditions.
     class QueryBuilder < Netzke::Base
-      js_configure do |c|
+      client_class do |c|
         c.extend = "Ext.tab.Panel"
         c.active_tab = 0
         c.translate :overwrite_confirm, :overwrite_confirm_title, :delete_confirm, :delete_confirm_title
-        c.mixin
       end
 
-      component :search_panel do |c|
+      component :search_panel, eager_load: true do |c|
         c.klass = SearchPanel
         c.model = config[:model]
         c.fields = config[:fields]
         c.preset_query = config[:query]
         c.auto_scroll = config[:auto_scroll]
-        c.eager_loading = true
       end
 
       action :clear_all do |a|
@@ -39,13 +37,17 @@ module Netzke
         a.icon = :accept
       end
 
-      def js_configure(c)
+      def configure(c)
+        super
+        c.bbar = (c.bbar || []) + [:clear_all, :reset, "->", I18n.t('netzke.basepack.query_builder.presets'), :preset_selector, :save_preset, :delete_preset ]
+      end
+
+      def configure_client(c)
         super
         c.preset_store = state[:presets].blank? ? [[[], ""]] : state[:presets].map{ |s| [s["query"], s["name"]] }
-        c.bbar = (config[:bbar] || []) + [:clear_all, :reset, "->", I18n.t('netzke.basepack.query_builder.presets'), :preset_selector, :save_preset, :delete_preset ]
       end
 
-      endpoint :save_preset do |params, this|
+      endpoint :save_preset do |params|
         saved_searches = state[:presets] || []
         existing = saved_searches.detect{ |s| s["name"] == params[:name] }
         query = ActiveSupport::JSON.decode(params[:query])
@@ -55,14 +57,14 @@ module Netzke
           saved_searches << {"name" => params[:name], "query" => query}
         end
         state[:presets] = saved_searches
-        this.netzke_feedback(I18n.t('netzke.basepack.query_builder.preset_saved'))
+        client.netzke_notify(I18n.t('netzke.basepack.query_builder.preset_saved'))
       end
 
-      endpoint :delete_preset do |params, this|
+      endpoint :delete_preset do |params|
         saved_searches = state[:presets]
         saved_searches.delete_if{ |s| s["name"] == params[:name] }
         state[:presets] = saved_searches
-        this.netzke_feedback(I18n.t('netzke.basepack.query_builder.preset_deleted'))
+        client.netzke_notify(I18n.t('netzke.basepack.query_builder.preset_deleted'))
       end
     end
   end