netzke-core 0.6.7 → 0.7.0

data/javascripts/ext.js

@@ -1,83 +1,109 @@
+// Enable Ext 4 migration errors traceback display
+if (Ext.Compat) Ext.Compat.showErrors = true;
+
 // Because of Netzke's double-underscore notation, Ext.TabPanel should have a different id-delimiter (yes, this should be in netzke-core)
 Ext.TabPanel.prototype.idDelimiter = "___";
 
 Ext.QuickTips.init();
 
 // We don't want no state managment by default, thank you!
-Ext.state.Provider.prototype.set = function(){};
+Ext.state.Provider.prototype.set = Ext.emptyFn;
 
-// Check Ext JS version
+// Checking Ext JS version: both major and minor versions must be the same
 (function(){
-  var requiredExtVersion = "3.3.1";
-  var currentExtVersion = Ext.version;
-  if (requiredExtVersion !== currentExtVersion) {
-    Netzke.deprecationWarning("Need Ext " + requiredExtVersion + ". You have " + currentExtVersion + ".");
+  var requiredVersionMajor = 4,
+      requiredVersionMinor = 0,
+      extVersion = Ext.getVersion('extjs'),
+      currentVersionMajor = extVersion.getMajor(),
+      currentVersionMinor = extVersion.getMinor(),
+      requiredString = "" + requiredVersionMajor + "." + requiredVersionMinor + ".x",
+      currentString = "" + currentVersionMajor + "." + currentVersionMinor + ".x";
+
+  if (requiredVersionMajor != currentVersionMajor || requiredVersionMinor != currentVersionMinor) {
+    Netzke.warning("Ext " + requiredString + " required. You have " + currentString + ".");
   }
 })();
 
-Netzke.classes.NetzkeRemotingProvider = Ext.extend(Ext.direct.RemotingProvider, {
+// FeedbackGhost is a little class that displays unified feedback from Netzke components.
+Ext.define('Netzke.FeedbackGhost', {
+  showFeedback: function(msg){
+    if (!msg) Netzke.exception("Netzke.FeedbackGhost#showFeedback: wrong number of arguments (0 for 1)");
+    if (Ext.isObject(msg)) {
+      this.msg(msg.level.camelize(), msg.msg);
+    } else if (Ext.isArray(msg)) {
+      Ext.each(msg, function(m) { this.showFeedback(m); }, this);
+    } else {
+      this.msg(null, msg); // no header for now
+    }
+  },
+
+  msg: function(title, format){
+      if(!this.msgCt){
+          this.msgCt = Ext.core.DomHelper.insertFirst(document.body, {id:'msg-div'}, true);
+      }
+      var s = Ext.String.format.apply(String, Array.prototype.slice.call(arguments, 1));
+      var m = Ext.core.DomHelper.append(this.msgCt, this.createBox(title, s), true);
+      m.hide();
+      m.slideIn('t').ghost("t", { delay: 1000, remove: true});
+  },
+
+  createBox: function(t, s){
+    if (t) {
+      return '<div class="msg"><h3>' + t + '</h3><p>' + s + '</p></div>';
+    } else {
+      return '<div class="msg"><p>' + s + '</p></div>';
+    }
+  }
+});
+
+// Mix it into every Netzke component as feedbackGhost
+Netzke.componentMixin.feedbackGhost = Ext.create("Netzke.FeedbackGhost");
+
+Ext.define('Netzke.classes.NetzkeRemotingProvider', {
+  extend: 'Ext.direct.RemotingProvider',
+
   getCallData: function(t){
     return {
       act: t.action, // rails doesn't really support having a parameter named "action"
       method: t.method,
       data: t.data,
       type: 'rpc',
-      tid: t.tid
+      tid: t.id
     }
   },
 
   addAction: function(action, methods) {
     var cls = this.namespace[action] || (this.namespace[action] = {});
     for(var i = 0, len = methods.length; i < len; i++){
-        var m = methods[i];
-        cls[m.name] = this.createMethod(action, m);
-      }
+      method = Ext.create('Ext.direct.RemotingMethod', methods[i]);
+      cls[method.name] = this.createHandler(action, method);
+    }
   },
 
-  // process response regardess of status
-  // i.e. in a batch request,
-  // - we request tids 1,2,3.
-  // - server is able to process 1 but not 2
-  // - server will stop and *not* process 3, because it could be dependant on 2 (this best possible approach to this
-  //   situation, as we don't have transactions)
-  // - server will respond with status 500, indicating a fault
-  // - in the response, server will respond with the result from tid 1
-  // - client marks tid 1 as success (deletes the transaction from pending), and will retry 2 and 3 - this is the
-  //   change in Ext.direct.RemotingProvider's default behaviour
-  onData: function(opt, success, xhr){
-    var events=this.getEvents(xhr);
-
-    for(var i = 0, len = events.length; i < len; i++){
-      var e = events[i],
-      t = this.getTransaction(e);
-      this.fireEvent('data', this, e);
-      if(t){
-        this.doCallback(t, e, true);
-        Ext.Direct.removeTransaction(t);
-      }
+  // HACK: Ext JS 4.0.0 retry mechanism is broken
+  getTransaction: function(opt) {
+    if (opt.$className == "Ext.direct.Transaction") {
+      return opt;
+    } else {
+      return this.callParent([opt]);
     }
-
-    Netzke.classes.NetzkeRemotingProvider.superclass.onData.call(this, opt, success, xhr);
   }
-
 });
 
 Netzke.directProvider = new Netzke.classes.NetzkeRemotingProvider({
-  "type": "remoting",       // create a Ext.direct.RemotingProvider
-  "url": Netzke.RelativeUrlRoot + "/netzke/direct/", // url to connect to the Ext.Direct server-side router.
-  "namespace": "Netzke.providers", // namespace to create the Remoting Provider in
-  "actions": {},
-  "maxRetries": Netzke.core.directMaxRetries,
-  "enableBuffer": true, // buffer/batch requests within 10ms timeframe
-  "timeout": 30000 // 30s timeout per request
+  type: "remoting",       // create a Ext.direct.RemotingProvider
+  url: Netzke.RelativeUrlRoot + "/netzke/direct/", // url to connect to the Ext.Direct server-side router.
+  namespace: "Netzke.providers", // namespace to create the Remoting Provider in
+  actions: {},
+  maxRetries: Netzke.core.directMaxRetries,
+  enableBuffer: true, // buffer/batch requests within 10ms timeframe
+  timeout: 30000 // 30s timeout per request
 });
 
 Ext.Direct.addProvider(Netzke.directProvider);
 
+// Methods/properties that each and every Netzke component will have
 Ext.apply(Netzke.classes.Core.Mixin, {
-  height: 400,
-  border: false,
-
   /*
   Mask shown during loading of a component. Set to false to not mask. Pass config for Ext.LoadMask for configuring msg/cls, etc.
   Set msg to null if mask without any msg is desirable.
@@ -90,12 +116,17 @@ Ext.apply(Netzke.classes.Core.Mixin, {
 
     this.detectActions(this);
 
+    // Detects component placeholders in the passed object (typically, "items"),
+    // and merges them with the corresponding config from this.netzkeComponents.
+    // This way it becomes ready to be instantiated properly by Ext.
     this.detectComponents(this.items);
 
     this.normalizeTools();
 
     this.processEndpoints();
 
+    this.processPlugins();
+
     // This is where the references to different callback functions will be stored
     this.callbackHash = {};
 
@@ -120,20 +151,21 @@ Ext.apply(Netzke.classes.Core.Mixin, {
   },
 
   /*
-  Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod() (using Ext.Direct)
+  Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod()
   */
   processEndpoints: function(){
     var endpoints = this.endpoints || [];
     endpoints.push('deliver_component'); // all Netzke components get this endpoint
     var directActions = [];
-    var that=this;
+    var that = this;
 
     Ext.each(endpoints, function(intp){
       directActions.push({"name":intp.camelize(true), "len":1});
       this[intp.camelize(true)] = function(arg, callback, scope) {
         Netzke.runningRequests++;
-        scope=scope || that;
-        Netzke.providers[this.id][intp.camelize(true)].call(typeof scope != 'undefined' ? scope : that, arg, function(result, remotingEvent) {
+
+        scope = scope || that;
+        Netzke.providers[this.id][intp.camelize(true)].call(scope, arg, function(result, remotingEvent) {
           if(remotingEvent.message) {
             console.error("RPC event indicates an error: ", remotingEvent);
             throw new Error(remotingEvent.message);
@@ -157,8 +189,8 @@ Ext.apply(Netzke.classes.Core.Mixin, {
         // 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});
+        var handler = Ext.Function.bind(this.toolActionHandler, this, [tool]);
+        normTools.push({type : tool, handler : handler, scope : this});
       }, this);
       this.tools = normTools;
     }
@@ -176,7 +208,7 @@ Ext.apply(Netzke.classes.Core.Mixin, {
       // Configure the action
       var actionConfig = Ext.apply({}, this.actions[name]); // do not modify original this.actions
       actionConfig.customHandler = actionConfig.handler;
-      actionConfig.handler = this.actionHandler.createDelegate(this); // handler common for all actions
+      actionConfig.handler = Ext.Function.bind(this.actionHandler, this); // handler common for all actions
       actionConfig.name = name;
       normActions[name] = new Ext.Action(actionConfig);
     }
@@ -195,7 +227,7 @@ Ext.apply(Netzke.classes.Core.Mixin, {
         o.handler = this[o.handler.camelize(true)].createDelegate(this);
       }
       // TODO: this should be configurable!
-      Ext.each(["bbar", "tbar", "fbar", "menu", "items", "contextMenu", "buttons"], function(key){
+      Ext.each(["bbar", "tbar", "fbar", "menu", "items", "contextMenu", "buttons", "dockedItems"], function(key){
         if (o[key]) {
           var items = [].concat(o[key]); // we need to do it in order to esure that this instance has a separate bbar/tbar/etc, NOT shared via class' prototype
           delete(o[key]);
@@ -220,13 +252,14 @@ Ext.apply(Netzke.classes.Core.Mixin, {
   },
 
   /*
-  Loads a component. Config options:
+  Dynamically loads a Netzke component.
+  Config options:
   'name' (required) - the name of the child component to load
-  'container' - the id of a panel with the 'fit' layout where the loaded component will be instantiated
-  'callback' - function that gets called after the component is loaded. It receives the component's instance as parameter.
-  'scope' - scope for the callback.
+  'container' - if specified, the id (or instance) of a panel with the 'fit' layout where the loaded component will be added to; the previously existing component will be destroyed
+  'callback' - function that gets called after the component is loaded; it receives the component's instance as parameter
+  'scope' - scope for the callback
   */
-  loadComponent: function(params){
+  loadNetzkeComponent: function(params){
     if (params.id) {
       params.name = params.id;
       Netzke.deprecationWarning("Using 'id' in loadComponent is deprecated. Use 'name' instead.");
@@ -272,10 +305,17 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.deliverComponent(serverParams);
   },
 
+  // DEPRECATED in favor or loadNetzkeComponent
+  loadComponent: function(params) {
+    Netzke.deprecationWarning("loadComponent is deprecated in favor of loadNetzkeComponent");
+    params.container = params.container || this.getId(); // for backward compatibility
+    this.loadNetzkeComponent(params);
+  },
+
   /*
   Called by the server after we ask him to load a component
   */
-  componentDelivered : function(config){
+  componentDelivered: function(config){
     // retrieve the loading config for this component
     var storedConfig = this.componentsBeingLoaded[config.name] || {};
     delete this.componentsBeingLoaded[config.name];
@@ -285,8 +325,21 @@ Ext.apply(Netzke.classes.Core.Mixin, {
       storedConfig.loadMaskCmp.destroy();
     }
 
-    // instantiate and render it
-    var componentInstance = this.instantiateAndRenderComponent(config, storedConfig.container);
+    var componentInstance = Ext.createByAlias(config.alias, config);
+
+    if (storedConfig.container) {
+      var containerCmp = Ext.isString(storedConfig.container) ? Ext.getCmp(storedConfig.container) : storedConfig.container;
+      // containerCmp.insertNetzkeComponent(componentInstance);
+      containerCmp.removeAll();
+      containerCmp.add(componentInstance);
+
+      if (containerCmp.isVisible()) {
+        containerCmp.doLayout();
+      } else {
+        // if loaded into a hidden container, we need a little trick
+        containerCmp.on('show', function(cmp){ cmp.doLayout(); }, {single: true});
+      }
+    }
 
     if (storedConfig.callback) {
       storedConfig.callback.call(storedConfig.scope || this, componentInstance);
@@ -295,10 +348,22 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.fireEvent('componentload', componentInstance);
   },
 
+  componentDeliveryFailed: function(params) {
+    var storedConfig = this.componentsBeingLoaded[params.componentName] || {};
+    delete this.componentsBeingLoaded[params.componentName];
+
+    if (storedConfig.loadMaskCmp) {
+      storedConfig.loadMaskCmp.hide();
+      storedConfig.loadMaskCmp.destroy();
+    }
+
+    this.netzkeFeedback({msg: params.msg, level: "Error"});
+  },
+
   /*
-  Instantiates and renders a component with given config and container
+  DEPRECATED. Instantiates and renders a component with given config and container.
   */
-  instantiateAndRenderComponent : function(config, containerId){
+  instantiateAndRenderComponent: function(config, containerId){
     var componentInstance;
     if (containerId) {
       var container = Ext.getCmp(containerId);
@@ -310,24 +375,9 @@ Ext.apply(Netzke.classes.Core.Mixin, {
   },
 
   /*
-  Instantiates and inserts a component into a container with layout 'fit'.
-  Arg: an JS object with the following keys:
-    - id: id of the receiving container
-    - config: configuration of the component to be instantiated and inserted into the container
+  Returns parent Netzke component
   */
-  // renderComponentInContainer : function(params){
-  //   var cont = Ext.getCmp(params.container);
-  //   if (cont) {
-  //     cont.instantiateChild(params.config);
-  //   } else {
-  //     this.instantiateChild(params.config);
-  //   }
-  // },
-
-  /*
-  Returns the parent component
-  */
-  getParent: function(){
+  getParentNetzkeComponent: function(){
     // simply cutting the last part of the id: some_parent__a_kid__a_great_kid => some_parent__a_kid
     var idSplit = this.id.split("__");
     idSplit.pop();
@@ -336,61 +386,65 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     return parentId === "" ? null : Ext.getCmp(parentId);
   },
 
+  // DEPRECATED
+  getParent: function() {
+    Netzke.deprecationWarning("getParent is deprecated in favor of getParentNetzkeComponent");
+    return this.getParentNetzkeComponent();
+  },
+
   /*
-  Reloads current component (calls the parent to reload it as its component)
+  Reloads current component (calls the parent to reload us as its component)
   */
-  reload : function(){
-    var parent = this.getParent();
+  reload: function(){
+    var parent = this.getParentNetzkeComponent();
     if (parent) {
-      parent.loadComponent({id:this.localId(parent), container:this.ownerCt.id});
+      parent.loadNetzkeComponent({id:this.localId(parent), container:this.ownerCt.id});
     } else {
       window.location.reload();
     }
   },
 
   /*
-  Reconfigures the component
+  DEPRECATED: Reconfigures the component
   */
   reconfigure: function(config){
     this.ownerCt.instantiateChild(config)
   },
 
-  // Get the child component
-  getChildComponent : function(id){
+  /*
+  Instantiates and returns a Netzke component by its name.
+  */
+  instantiateChildNetzkeComponent: function(name) {
+    name = name.camelize(true);
+    return Ext.createByAlias(this.netzkeComponents[name].alias, this.netzkeComponents[name])
+  },
+
+  /*
+  Returns *instantiated* child component by its relative id, which may contain the 'parent' part to walk _up_ the hierarchy
+  */
+  getChildNetzkeComponent: function(id){
     if (id === "") {return this};
     id = id.underscore();
     var split = id.split("__");
     if (split[0] === 'parent') {
       split.shift();
       var childInParentScope = split.join("__");
-      return this.getParent().getChildComponent(childInParentScope);
+      return this.getParentNetzkeComponent().getChildNetzkeComponent(childInParentScope);
     } else {
       return Ext.getCmp(this.id+"__"+id);
     }
   },
 
-  // At this moment component is fully initializied
-  commonAfterConstructor : function(config){
-
-    // Add the menus
-    if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu, this);}
-
-    // generic events
-    this.addEvents(
-      'componentload' // fired when a child is dynamically loaded
-    );
-
-    // Cleaning up on destroy
-    this.on('beforedestroy', function(){
-      this.cleanUpMenu();
-    }, this);
-
-    this.callbackHash = {};
-
-    if (this.afterConstructor) this.afterConstructor(config);
+  // DEPRECATED
+  getChildComponent: function(id) {
+    Netzke.deprecationWarning("getChildComponent is deprecated in favor of getChildNetzkeComponent");
+    return this.getChildNetzkeComponent(id);
   },
 
-  feedback:function(msg){
+  /*
+  Provides a visual feedback. TODO: refactor
+  */
+  netzkeFeedback: function(msg){
     if (this.initialConfig && this.initialConfig.quiet) {
       return false;
     }
@@ -413,8 +467,16 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     }
   },
 
-  // Common handler for all component's actions. <tt>comp</tt> is the Component that triggered the action (e.g. button or menu item)
-  actionHandler : function(comp){
+  // DEPRECATED in favor of netzkeFeedback
+  feedback: function(msg) {
+    Netzke.deprecationWarning("feedback is deprecated in favor of netzkeFeedback");
+    this.netzkeFeedback(msg);
+  },
+
+  /*
+  Common handler for all netzke's actions. <tt>comp</tt> is the Component that triggered the action (e.g. button or menu item)
+  */
+  actionHandler: function(comp){
     var actionName = comp.name;
     // If firing corresponding event doesn't return false, call the handler
     if (this.fireEvent(actionName+'click', comp)) {
@@ -429,7 +491,7 @@ Ext.apply(Netzke.classes.Core.Mixin, {
   },
 
   // Common handler for tools
-  toolActionHandler : function(tool){
+  toolActionHandler: function(tool){
     // If firing corresponding event doesn't return false, call the handler
     if (this.fireEvent(tool.id+'click')) {
       var methodName = "on"+tool.camelize();
@@ -438,5 +500,14 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     }
   },
 
+  processPlugins: function() {
+    if (this.netzkePlugins) {
+      if (!this.plugins) this.plugins = [];
+      Ext.each(this.netzkePlugins, function(p){
+        this.plugins.push(this.instantiateChildNetzkeComponent(p));
+      }, this);
+    }
+  },
+
   onComponentLoad:Ext.emptyFn // gets overridden
 });

data/lib/netzke/actions.rb

@@ -103,7 +103,8 @@ module Netzke
       end
 
       def uri_to_icon(icon)
-        Netzke::Core.with_icons ? Netzke::Core.icons_uri + "/" + icon.to_s + ".png" : nil
+        Netzke::Core.with_icons ? [Netzke::Core.controller.config.relative_url_root, Netzke::Core.icons_uri, '/', icon.to_s, ".png"].join : nil
       end
+
   end
 end

data/lib/netzke/base.rb

@@ -6,6 +6,7 @@ require 'netzke/stylesheets'
 require 'netzke/inheritance'
 require 'netzke/services'
 require 'netzke/composition'
+require 'netzke/plugins'
 require 'netzke/configuration'
 require 'netzke/state'
 require 'netzke/embedding'
@@ -36,6 +37,7 @@ module Netzke
     include Inheritance
     include Services
     include Composition
+    include Plugins
     include Stylesheets
     include Embedding
     include Actions
@@ -74,7 +76,9 @@ module Netzke
 
       # Instance of component by config
       def instance_by_config(config)
-        (config[:klass] || constantize_class_name(config[:class_name])).new(config)
+        klass = config[:klass] || constantize_class_name(config[:class_name])
+        raise NameError, "Netzke: Unknown component #{config[:class_name]}" if klass.nil?
+        klass.new(config)
       end
 
       # The ID used to locate this component's block in locale files

data/lib/netzke/composition.rb

@@ -46,7 +46,7 @@ module Netzke
             :component_delivered => component.js_config
           }]
         else
-          {:feedback => "Couldn't load component '#{component_name}'"}
+          {:component_delivery_failed => {:component_name => component_name, :msg => "Couldn't load component '#{component_name}'"}}
         end
       end
 
@@ -113,7 +113,7 @@ module Netzke
 
       # All components for this instance, which includes components defined on class level, and components detected in :items
       def components
-        @components ||= self.class.registered_components.inject({}){ |res, name| res.merge(name.to_sym => send(COMPONENT_METHOD_NAME % name)) }
+        @components ||= self.class.registered_components.inject({}){ |res, name| res.merge(name.to_sym => send(COMPONENT_METHOD_NAME % name)) }.merge(config[:components] || {})
       end
 
       def eager_loaded_components

data/lib/netzke/configuration.rb

@@ -17,7 +17,7 @@ module Netzke
 
       # Config options that should not go to the client side
       def server_side_config_options
-        [:lazy_loading, :class_name]
+        [:lazy_loading, :class_name, :components]
       end
 
       def config(*args, &block)

data/lib/netzke/core/dynamic_assets.rb

@@ -30,8 +30,8 @@ module Netzke
           res
         end
 
-        def ext_js
-          res = initial_dynamic_javascript << "\n"
+        def ext_js(form_authenticity_token)
+          res = initial_dynamic_javascript(form_authenticity_token) << "\n"
 
           include_base_js(res)
 
@@ -61,16 +61,16 @@ module Netzke
 
         protected
 
-          # Generates initial javascript code that is dependent on Rails environement
-          def initial_dynamic_javascript
+          # Generates initial javascript code that is dependent on Rails settings
+          def initial_dynamic_javascript(form_authenticity_token)
             res = []
-            # res << %(Ext.Ajax.extraParams = {authenticity_token: '#{form_authenticity_token}'}; // Rails' forgery protection)
+            res << %(Ext.Ajax.extraParams = {authenticity_token: '#{form_authenticity_token}'}; // Rails' forgery protection)
             res << %{Ext.ns('Netzke');}
             res << %{Ext.ns('Netzke.core');}
             res << %{Netzke.RelativeUrlRoot = '#{ActionController::Base.config.relative_url_root}';}
-            res << %{Netzke.RelativeExtUrl = '#{ActionController::Base.config.relative_url_root}/extjs';}
+            res << %{Netzke.RelativeExtUrl = '#{ActionController::Base.config.relative_url_root}#{Netzke::Core.ext_uri}';}
 
-            res << %{Netzke.core.directMaxRetries = '#{Netzke::Core.js_direct_max_retries}';}
+            res << %{Netzke.core.directMaxRetries = #{Netzke::Core.js_direct_max_retries};}
 
             res.join("\n")
           end

data/lib/netzke/core/session.rb

@@ -11,6 +11,10 @@ module Netzke
         session[:_netzke_next_request_is_first_after_logout] = true
       end
 
+      def current_user
+        Netzke::Core.controller.respond_to?(Netzke::Core.current_user_method) && Netzke::Core.controller.send(Netzke::Core.current_user_method) || nil
+      end
+
       # Register the configuration for the component in the session, and also remember that the code for it has been rendered
       def reg_component(config)
         session[:netzke_components] ||= {}

data/lib/netzke/core/version.rb

@@ -2,8 +2,8 @@ module Netzke
   module Core
     module Version
       MAJOR = 0
-      MINOR = 6
-      PATCH = 7
+      MINOR = 7
+      PATCH = 0
 
       STRING = [MAJOR, MINOR, PATCH].compact.join('.')
     end