netzke-core 0.6.2 → 0.6.3

data/javascripts/core.js

@@ -94,7 +94,7 @@ Netzke.componentMixin = function(receiver){
     border: false,
     isNetzke: true, // to distinguish Netzke components from regular Ext components
     latestResult: {}, // latest result returned from the server via an API call
-    
+
     /*
     Overriding the constructor to only apply an "alias method chain" to initComponent
     */
@@ -102,22 +102,22 @@ Netzke.componentMixin = function(receiver){
       Netzke.aliasMethodChain(this, "initComponent", "netzke");
       receiver.superclass.constructor.call(this, config);
     },
-    
+
     /* initComponent common for all Netzke components */
     initComponentWithNetzke : function(){
       this.normalizeActions();
-      
+
       this.detectActions(this);
-      
+
       this.detectComponents(this.items);
-      
+
       this.normalizeTools();
-      
+
       this.processEndpoints();
-      
+
       // This is where the references to different callback functions will be stored
       this.callbackHash = {};
-      
+
       // This is where we store the information about components that are currently being loaded with this.loadComponent()
       this.componentsBeingLoaded = {};
 
@@ -141,8 +141,8 @@ Netzke.componentMixin = function(receiver){
       this.initComponentWithoutNetzke();
     },
 
-    /* 
-    Dynamically creates methods for api points, so that we could later call them like: this.myEndpointMethod() 
+    /*
+    Dynamically creates methods for api points, so that we could later call them like: this.myEndpointMethod()
     */
     processEndpoints : function(){
       var endpoints = this.endpoints || [];
@@ -158,7 +158,7 @@ Netzke.componentMixin = function(receiver){
         Ext.each(this.tools, function(tool){
           // Create an event for each action (so that higher-level components could interfere)
           this.addEvents(tool.id+'click');
-      
+
           var handler = this.toolActionHandler.createDelegate(this, [tool]);
           normTools.push({id : tool, handler : handler, scope : this});
         }, this);
@@ -166,8 +166,8 @@ Netzke.componentMixin = function(receiver){
       }
     },
 
-    /* 
-    Replaces actions configs with Ext.Action instances, assigning default handler to them 
+    /*
+    Replaces actions configs with Ext.Action instances, assigning default handler to them
     */
     normalizeActions : function(){
       var normActions = {};
@@ -222,7 +222,7 @@ Netzke.componentMixin = function(receiver){
     },
 
     /*
-    Detects component placeholders in the passed object (typically, "items"), 
+    Detects component placeholders in the passed object (typically, "items"),
     and merges them with the corresponding config from this.components.
     This way it becomes ready to be instantiated properly by Ext.
     */
@@ -252,20 +252,20 @@ Netzke.componentMixin = function(receiver){
         params.name = params.id;
         Netzke.deprecationWarning("Using 'id' in loadComponent is deprecated. Use 'name' instead.");
       }
-      
+
       params.name = params.name.underscore();
 
       // params that will be provided for the server API call (deliver_component); all what's passed in params.params is merged in. This way we exclude from sending along such things as :scope, :callback, etc.
       var serverParams = params.params || {};
       serverParams.name = params.name;
-      
+
       // Build the list of already loaded ("cached") classes
       serverParams.cache = [];
-      
+
       for (var klass in Netzke.classes) {
         serverParams.cache.push(klass);
       }
-      
+
       serverParams.cache = serverParams.cache.join();
 
       var storedConfig = this.componentsBeingLoaded[params.name] = {};
@@ -296,9 +296,9 @@ Netzke.componentMixin = function(receiver){
       if (this.fireEvent('componentload'), config) {
         var storedConfig = this.componentsBeingLoaded[config.name] || {};
         delete this.componentsBeingLoaded[config.name];
-      
+
         var componentInstance;
-      
+
         if (storedConfig.container) {
           var container = Ext.getCmp(storedConfig.container);
           componentInstance = container.instantiateChild(config);
@@ -352,9 +352,9 @@ Netzke.componentMixin = function(receiver){
     },
 
     /*
-    Gets id in the context of provided parent. 
-    For example, the components "properties", being a child of "books" has global id "books__properties", 
-    which *is* its widegt's real id. This methods, with the instance of "books" passed as parameter, 
+    Gets id in the context of provided parent.
+    For example, the components "properties", being a child of "books" has global id "books__properties",
+    which *is* its widegt's real id. This methods, with the instance of "books" passed as parameter,
     returns "properties".
     */
     localId : function(parent){
@@ -386,18 +386,18 @@ Netzke.componentMixin = function(receiver){
     },
 
     /*
-    Executes a bunch of methods. This method is called almost every time a communication to the server takes place. 
+    Executes a bunch of methods. This method is called almost every time a communication to the server takes place.
     Thus the server side of a component can provide any set of commands to its client side.
     Args:
-      - instructions: array of methods, in the order of execution. 
+      - instructions: array of methods, in the order of execution.
         Each item is an object in one of the following 2 formats:
           1) {method1:args1, method2:args2}, where methodN is a name of a public method of this component; these methods are called in no particular order
           2) {component:component_id, methods:arrayOfMethods}, used for recursive call to bulkExecute on some child component
 
-    Example: 
+    Example:
       - [
           // the same as this.feedback("Your order is accepted")
-          {feedback: "You order is accepted"}, 
+          {feedback: "You order is accepted"},
 
           // the same as this.getChildComponent('users').bulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}])
           {component:'users', methods:[{setTitle:'Suprise!'}, {setDisabled:true}] },
@@ -451,12 +451,12 @@ Netzke.componentMixin = function(receiver){
     //     var customHandler = action.initialConfig.customHandler;
     //     var methodName = (customHandler && customHandler.camelize(true)) || "on" + actionName.camelize();
     //     if (!this[methodName]) {throw "Netzke: action handler '" + methodName + "' is undefined"}
-    // 
+    //
     //     // call the handler passing it the triggering component
     //     this[methodName](comp);
     //   }
     // },
-    // 
+    //
     // // Common handler for tools
     // toolActionHandler : function(tool){
     //   // If firing corresponding event doesn't return false, call the handler
@@ -472,7 +472,7 @@ Netzke.componentMixin = function(receiver){
       Netzke.deprecationWarning("buildApiUrl() is deprecated. Use endpointUrl() first");
       return this.endpointUrl(endpoint);
     },
-    
+
     endpointUrl: function(endpoint){
       return Netzke.RelativeUrlRoot + "/netzke/" + this.id + "__" + endpoint;
     },
@@ -489,7 +489,7 @@ Netzke.componentMixin = function(receiver){
             this.bulkExecute(Ext.decode(response.responseText));
 
             // provide callback if needed
-            if (typeof callback == 'function') { 
+            if (typeof callback == 'function') {
               if (!scope) scope = this;
               callback.apply(scope, [this.latestResult]);
             }
@@ -551,23 +551,23 @@ Netzke.componentMixin = function(receiver){
     //   if (!owner) {
     //     owner = this;
     //   }
-    //   
-    //   if (!!this.hostMenu) { 
-    //     this.hostMenu(menu, owner); 
+    //
+    //   if (!!this.hostMenu) {
+    //     this.hostMenu(menu, owner);
     //   } else {
     //     if (this.ownerComponent) {
     //       this.ownerComponent.addMenu(menu, owner);
     //     }
     //   }
     // },
-    // 
+    //
     // cleanUpMenu : function(owner){
     //   if (!owner) {
     //     owner = this;
     //   }
-    //   
-    //   if (!!this.unhostMenu) { 
-    //     this.unhostMenu(owner); 
+    //
+    //   if (!!this.unhostMenu) {
+    //     this.unhostMenu(owner);
     //   } else {
     //     if (this.ownerComponent) {
     //       this.ownerComponent.cleanUpMenu(owner);
@@ -599,7 +599,7 @@ Netzke.componentMixin = function(receiver){
         this[methodName]();
       }
     },
-    
+
     onComponentLoad:Ext.emptyFn // gets overridden
   }
 }
@@ -614,14 +614,14 @@ Ext.override(Ext.Container, {
     if (instance.isXType("window")) {
       instance.show();
     } else {
-      this.remove(this.getNetzkeComponent()); // first delete previous component 
+      this.remove(this.getNetzkeComponent()); // first delete previous component
       this.add(instance);
       this.doLayout();
     }
     return instance;
   },
 
-  /** 
+  /**
     Get Netzke component that this Ext.Container is part of (*not* the parent component, for which call getParent)
     It searches up the Ext.Container hierarchy until it finds a Container that has isNetzke property set to true
     (or until it reaches the top).
@@ -637,12 +637,12 @@ Ext.override(Ext.Container, {
       }
     }
   },
-  
+
   // Get the component that we are hosting
   getNetzkeComponent: function(){
     return this.items ? this.items.first() : null; // need this check in case when the container is not yet rendered, like an inactive tab in the TabPanel
   },
-  
+
   // Remove the child
   removeChild : function(){
     this.remove(this.getNetzkeComponent());

data/lib/generators/migration_helper.rb

@@ -1,7 +1,7 @@
 module MigrationHelper
-  include Rails::Generators::Migration  
-  
-  module ClassMethods    
+  include Rails::Generators::Migration
+
+  module ClassMethods
     def migration_lookup_at(dirname) #:nodoc:
       Dir.glob("#{dirname}/[0-9]*_*.rb")
     end
@@ -23,10 +23,10 @@ module MigrationHelper
     rescue
       raise NotImplementedError
     end
-  end         
+  end
 
-  def self.included(base) #:nodoc: 
+  def self.included(base) #:nodoc:
     puts "MigrationHelper included by #{base}"
-    base.extend ClassMethods      
+    base.extend ClassMethods
   end
 end

data/lib/generators/netzke/USAGE

@@ -1,9 +1,8 @@
 Description:
-    Generates a netzke preferences migration 
+    Generates a netzke preferences migration
 
 Example:
     rails g netzke:core
 
     This will create:
-        A netzke preferences migration 
-        
+        A netzke preferences migration

data/lib/generators/netzke/core_generator.rb

@@ -3,22 +3,22 @@ require 'rails/generators/migration'
 require 'generators/migration_helper'
 
 module Netzke
-  module Generators  
+  module Generators
     class CoreGenerator < Rails::Generators::Base
       include ::MigrationHelper
-      
+
       def execute
         migration_template 'create_netzke_preferences.rb', 'db/migrate/create_netzke_preferences.rb'
       end
-      
+
       def self.source_root
         File.join(gem_root, 'templates', 'core')
-      end        
-      
+      end
+
       def self.gem_root
         File.expand_path("../../../../", __FILE__)
-      end 
-                 
+      end
+
     end
   end
 end

data/lib/netzke/actions.rb

@@ -1,19 +1,19 @@
 module Netzke
   # Netzke component allows specifying Ext actions.
-  # An action can be defined in 2 different ways, both of which result in a method definition like this 
+  # An action can be defined in 2 different ways, both of which result in a method definition like this
   #     def _<some_action>_action
   #       ...
   #     end
-  # 
+  #
   # The 2 ways to define an action are:
   # * as a hash:
-  #     action :bug_server, :text => "Call server", :icon => "/images/icons/phone.png"  
-  # 
+  #     action :bug_server, :text => "Call server", :icon => "/images/icons/phone.png"
+  #
   # * as a block:
   #     action :bug_server do
   #       {:text => config[:text], :disabled => true}
   #     end
-  # 
+  #
   # The block can optionally receive the configuration of an action being overridden:
   #     action :bug_server do |orig|
   #       {:text => config[:text] + orig[:text], :disabled => orig[:disabled]}
@@ -23,16 +23,16 @@ module Netzke
 
     ACTION_METHOD_NAME = "%s_action"
     ACTION_METHOD_REGEXP = /^(.+)_action$/
-    
+
     included do
       alias_method_chain :js_config, :actions
     end
-    
+
     module ClassMethods
       def action(name, config = {}, &block)
         config[:name] = name.to_s
         method_name = ACTION_METHOD_NAME % name
-        
+
         if block_given?
           define_method(method_name, &block)
         else
@@ -48,7 +48,7 @@ module Netzke
         end
       end
     end
-    
+
     # Actions to be used in the config
     def actions
       # Call all the action related methods to collect the actions
@@ -61,29 +61,29 @@ module Netzke
     def js_config_with_actions #:nodoc
       actions.empty? ? js_config_without_actions : js_config_without_actions.merge(:actions => actions)
     end
-    
+
     private
       def normalize_action_config(config)
         if config[:icon].is_a?(Symbol)
           config[:icon] = Netzke::Core.with_icons ? Netzke::Core.icons_uri + "/" + config[:icon].to_s + ".png" : nil
         end
-        
+
         config[:text] ||= config[:name].humanize
-        
+
         config
       end
-      
+
       def auto_collect_actions_from_config_and_js_properties
         # res = extract_actions(js_properties)
         # puts %Q(!!! res: #{res.inspect}\n)
       end
-      
+
       # def extract_actions(hsh)
-      #   hsh.each_pair.inject({}) do |r,(k,v)| 
+      #   hsh.each_pair.inject({}) do |r,(k,v)|
       #     v.is_a?(Array) ? r.merge(extract_actions_from_array(v)) : r
       #   end
       # end
-      # 
+      #
       # def extract_actions_from_array(arry)
       #   arry.inject({}) do |r, el|
       #     if el.is_a?(Hash)
@@ -93,10 +93,10 @@ module Netzke
       #     end
       #   end
       # end
-      # 
+      #
       # def default_action_config(action_name)
       #   {:text => action_name.to_s.humanize}
       # end
-      
+
   end
 end

data/lib/netzke/base.rb

@@ -11,43 +11,22 @@ require 'netzke/actions'
 require 'netzke/session'
 
 module Netzke
-  # = Base
-  # Base class for every Netzke component
+  # The base for every Netzke component
   #
-  # To instantiate a component in the controller:
+  # == Class-level configuration
+  # You can configure any component's class as follows:
+  #     # e.g. in the initializers/netzke.rb
+  #     MyComponent.setup do |config|
+  #       config.default_instance_config = { :some_option => true }
+  #     end
   #
-  #     netzke :component_name, configuration_hash
-  # 
-  # == Configuration
-  # * <tt>:class_name</tt> - name of the component class in the scope of the Netzke module, e.g. "FormPanel".
-  # When a component is defined in the controller and this option is omitted, component class is deferred from the component's
-  # name. E.g.:
-  # 
-  #   netzke :grid_panel, :model => "User"
-  # 
-  # In this case <tt>:class_name</tt> is assumed to be "GridPanel"
-  # 
-  # * <tt>:persistent_config</tt> - if set to <tt>true</tt>, the component will use persistent storage to store its state;
-  # for instance, Netzke::GridPanel stores there its columns state (width, visibility, order, headers, etc).
-  # A component may or may not provide interface to its persistent settings. GridPanel and FormPanel from netzke-basepack
-  # are examples of components that by default do.
-  # 
-  # Examples of configuration:
-  #
-  #     netzke :books, 
-  #       :class_name => "GridPanel", 
-  #       :model => "Book", # GridPanel specific option
-  #       :persistent_config => false, # don't use persistent config for this instance
-  #       :icon_cls => 'icon-grid', 
-  #       :title => "My books"
-  # 
-  #     netzke :form_panel, 
-  #       :model => "User" # FormPanel specific option
+  # Netzke::Base provides the following class-level configuration options:
+  # * default_instance_config - a hash that will be used as default configuration for this component's instances
   class Base
-    
+
     class_attribute :default_instance_config
     self.default_instance_config = {}
-    
+
     include Session
     include Persistence
     include Configuration
@@ -58,12 +37,50 @@ module Netzke
     include Embedding
     include Actions
 
-    attr_accessor :parent, :name, :global_id #, :permissions, :session
+    # Parent component
+    attr_reader :parent
+
+    # Name that the parent can reference us by. The last part of +global_id+
+    attr_reader :name
+
+    # Global id in the components tree, following the double-underscore notation, e.g. +books__config_panel__form+
+    attr_reader :global_id
+
+    class << self
+      # Component's short class name, e.g.:
+      # "Netzke::Module::SomeComponent" => "Module::SomeComponent"
+      def short_component_class_name
+        self.name.sub(/^Netzke::/, "")
+      end
+
+      # Component's class, given its name
+      def constantize_class_name(class_name)
+        "#{class_name}".constantize rescue "Netzke::#{class_name}".constantize
+      end
+
+      # Instance of component by config
+      def instance_by_config(config)
+        constantize_class_name(config[:class_name]).new(config)
+      end
 
-    # Component initialization process
-    # * the config hash is available to the component after the "super" call in the initializer
-    # * override/add new default configuration options into the "default_config" method 
-    # (the config hash is not yet available)
+      # All ancestor classes in the Netzke class hierarchy (i.e. up to Netzke::Base)
+      def class_ancestors
+        if self == Netzke::Base
+          []
+        else
+          superclass.class_ancestors + [self]
+        end
+      end
+
+      # Same as +read_inheritable_attribute+ returning a hash, but returns empty hash when it's equal to superclass's
+      def read_clean_inheritable_hash(attr_name)
+        res = read_inheritable_attribute(attr_name) || {}
+        # We don't want here any values from the superclass (which is the consequence of using inheritable attributes).
+        res == self.superclass.read_inheritable_attribute(attr_name) ? {} : res
+      end
+    end
+
+    # Instantiates a component instance. A parent can optionally be provided.
     def initialize(conf = {}, parent = nil)
       @passed_config = conf # configuration passed at the moment of instantiation
       @passed_config.deep_freeze
@@ -71,72 +88,42 @@ module Netzke
       @name          = conf[:name].nil? ? short_component_class_name.underscore : conf[:name].to_s
       @global_id     = parent.nil? ? @name : "#{parent.global_id}__#{@name}"
       @flash         = []
-      
+
       # initialize @components and @items
       normalize_components_in_items
       # auto_collect_actions_from_config_and_js_properties
     end
-  
-    # Short component class name, e.g.: 
-    #   Netzke::Module::SomeComponent => Module::SomeComponent
-    def self.short_component_class_name
-      self.name.sub(/^Netzke::/, "")
-    end
 
-    # Component class, given its name
-    def self.constantize_class_name(class_name)
-      "#{class_name}".constantize rescue "Netzke::#{class_name}".constantize
-    end
-    
+    # Proxy to the equally named class method
     def constantize_class_name(class_name)
       self.class.constantize_class_name(class_name)
     end
 
-    # Instance of component by config
-    def self.instance_by_config(config)
-      constantize_class_name(config[:class_name]).new(config)
-    end
-  
-    def logger
-      if defined?(Rails)
-        Rails.logger
-      else 
-        require 'logger'
-        Logger.new(STDOUT)
-      end
-    end
-  
-    # 'Netzke::Grid' => 'Grid'
+    # Proxy to the equally named class method
     def short_component_class_name
       self.class.short_component_class_name
     end
-  
-    def flash(flash_hash)
-      level = flash_hash.keys.first
-      raise "Unknown message level for flash" unless %(notice warning error).include?(level.to_s)
-      @flash << {:level => level, :msg => flash_hash[level]}
-    end
 
-    def self.read_clean_inheritable_hash(attr_name)
-      res = read_inheritable_attribute(attr_name) || {}
-      # We don't want here any values from the superclass (which is the consequence of using inheritable attributes).
-      res == self.superclass.read_inheritable_attribute(attr_name) ? {} : res
-    end
-    
-    # override this method to do stuff at the moment of loading by some parent
+    # Override this method to do stuff at the moment of first-time loading
     def before_load
-      # component_session.clear - we don't do it anymore
     end
 
+    private
 
-    # Dependencies
-    def self.class_ancestors
-      if self == Netzke::Base
-        []
-      else
-        superclass.class_ancestors + [self]
+      def logger #:nodoc:
+        if defined?(Rails)
+          Rails.logger
+        else
+          require 'logger'
+          Logger.new(STDOUT)
+        end
+      end
+
+      def flash(flash_hash) #:nodoc:
+        level = flash_hash.keys.first
+        raise "Unknown message level for flash" unless %(notice warning error).include?(level.to_s)
+        @flash << {:level => level, :msg => flash_hash[level]}
       end
-    end
 
   end
 end