netzke-core 0.3.1 → 0.4.2

data/.autotest

@@ -0,0 +1 @@
+require 'autotest/redgreen'

data/.gitignore

@@ -0,0 +1,4 @@
+*.log
+pkg
+doc
+.DS_Store

data/CHANGELOG

@@ -1,4 +1,25 @@
+v0.4.2
+2009-09-11
+Fix: the API call (at the JavaScript side) was ignoring the callback parameter.
+Impr: if the array of API points is empty, it's not added into js_config anymore.
+New: new testing widgets in netzke_controller.
+Fix: extra CSS includes now take effect.
+New: Support for masquerading as "World". In this mode all the "touched" persistent preferences will be overwritten for all roles and users.
+
+v0.4.1
+2009-09-06
+Version bumb to force github rebuild the gem (Manifest is now included)
+
+v0.4.0
+2009-09-05
+Major refactoring.
+
+v0.3.2
+2009-06-05
+Netzke doesn't overwrite session[:user] anymore to not cause authentication-related problems.
+
 v0.3.1
+2009-05-07
 Fix: persistent_config_manager can now be set to nil, and it will work fine
 
 v0.3.0

data/Manifest

@@ -1,28 +1,27 @@
-autotest/discover.rb
 CHANGELOG
+LICENSE
+Manifest
+README.rdoc
+Rakefile
+TODO
+autotest/discover.rb
+generators/netzke_core/USAGE
 generators/netzke_core/netzke_core_generator.rb
 generators/netzke_core/templates/create_netzke_preferences.rb
-generators/netzke_core/USAGE
 init.rb
 install.rb
 javascripts/core.js
 lib/app/controllers/netzke_controller.rb
 lib/app/models/netzke_preference.rb
+lib/netzke-core.rb
 lib/netzke/action_view_ext.rb
 lib/netzke/base.rb
-lib/netzke/base_extras/interface.rb
-lib/netzke/base_extras/js_builder.rb
+lib/netzke/base_js.rb
 lib/netzke/controller_extensions.rb
 lib/netzke/core_ext.rb
 lib/netzke/feedback_ghost.rb
 lib/netzke/routing.rb
-lib/netzke-core.rb
-lib/vendor/facets/hash/recursive_merge.rb
-LICENSE
-Manifest
 netzke-core.gemspec
-Rakefile
-README.mdown
 stylesheets/core.css
 tasks/netzke_core_tasks.rake
 test/app_root/app/controllers/application_controller.rb
@@ -48,5 +47,4 @@ test/test_helper.rb
 test/unit/core_ext_test.rb
 test/unit/netzke_core_test.rb
 test/unit/netzke_preference_test.rb
-TODO
 uninstall.rb

data/README.rdoc

@@ -0,0 +1,12 @@
+= netzke-core
+Create Ext JS + Rails reusable components (widgets) with minimum effort.
+
+Introduction to Netzke framework: http://github.com/skozlov/netzke/tree/master
+
+Tutorials: http://blog.writelesscode.com
+
+Live-demo: http://netzke-demo.writelesscode.com
+
+Also see netzke-basepack (pre-programmed widgets) project: http://github.com/skozlov/netzke-basepack/tree/master
+
+Copyright (c) 2009 Sergei Kozlov, released under the MIT license

data/Rakefile

@@ -1,14 +1,18 @@
-require 'echoe'
-
-Echoe.new("netzke-core") do |p|
-  p.author = "Sergei Kozlov"
-  p.email = "sergei@writelesscode.com"
-  p.summary = "Build ExtJS/Rails widgets with minimum effort"
-  p.url = "http://writelesscode.com"
-  p.development_dependencies = []
-  p.test_pattern = 'test/**/*_test.rb'
-  p.retain_gemspec = true
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "netzke-core"
+    gemspec.summary = "Build ExtJS/Rails widgets with minimum effort"
+    gemspec.description = "Build ExtJS/Rails widgets with minimum effort"
+    gemspec.email = "sergei@playcode.nl"
+    gemspec.homepage = "http://github.com/skozlov/netzke-core"
+    gemspec.rubyforge_project = "netzke-core"
+    gemspec.authors = ["Sergei Kozlov"]
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
   
-  # fixing the problem with lib/*-* files being removed while doing manifest
-  p.clean_pattern = ["pkg", "doc", 'build/*', '**/coverage', '**/*.o', '**/*.so', '**/*.a', '**/*.log', "{ext,lib}/*.{bundle,so,obj,pdb,lib,def,exp}", "ext/Makefile", "{ext,lib}/**/*.{bundle,so,obj,pdb,lib,def,exp}", "ext/**/Makefile", "pkg", "*.gem", ".config"]
-end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/TODO

@@ -1 +1,2 @@
-* Re-factor JS-level inheritance mechanisms
+* Re-factor JS-level inheritance mechanisms (2009-07-5 why?)
+* Get rid of the default_config method, because the same functionality maybe achieved by overwriting the initialize method

data/VERSION

@@ -0,0 +1 @@
+0.4.2

data/generators/netzke_core/templates/create_netzke_preferences.rb

@@ -3,7 +3,7 @@ class CreateNetzkePreferences < ActiveRecord::Migration
     create_table :netzke_preferences do |t|
       t.string :name
       t.string :pref_type
-      t.string :value
+      t.string :value, :limit => 65535
       t.integer :user_id
       t.integer :role_id
       t.string :widget_name

data/javascripts/core.js

@@ -9,24 +9,17 @@ Ext.netzke.cache = {};
 
 Ext.QuickTips.init(); // seems obligatory in Ext v2.2.1, otherwise Ext.Component#destroy() stops working properly
 
-// to comply with Rails' forgery protection
+// To comply with Rails' forgery protection
 Ext.Ajax.extraParams = {
   authenticity_token : Ext.authenticityToken
 };
 
-// helper method to do multiple Ext.apply's
-Ext.netzke.chainApply = function(objectArray){
-  var res = {};
-  Ext.each(objectArray, function(obj){Ext.apply(res, obj)});
-  return res;
-};
-
 // Type detection functions
 Netzke.isObject = function(o) {
   return (o != null && typeof o == "object" && o.constructor.toString() == Object.toString());
 }
 
-// Some Rubyish String extensions
+// Some Ruby-ish String extensions
 // from http://code.google.com/p/inflection-js/
 String.prototype.camelize=function(lowFirstLetter)
 {
@@ -66,7 +59,6 @@ Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
     var sid = this.meta ? this.meta.id : null;
     var recordType = this.recordType, fields = recordType.prototype.fields;
     var records = [];
-    // console.info(this.meta);
     var root = o[this.meta.root] || o, totalRecords = o[this.meta.totalProperty], success = o[this.meta.successProperty];
     for(var i = 0; i < root.length; i++){
       var n = root[i];
@@ -91,8 +83,174 @@ Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
   }
 });
 
-// Methods common to all widget classes
+// Properties/methods common to all widget classes
 Ext.widgetMixIn = {
+  height: 400,
+  width: 800,
+  border: false,
+  is_netzke: true, // to distinguish Netzke components from regular Ext components
+  
+  /*
+  Loads aggregatee into a container. Sends the widgets cache info to the server.
+  */
+  loadAggregatee: function(params){
+    // build the cached widget list
+    var cachedWidgetNames = [];
+    for (name in Ext.netzke.cache) {
+      cachedWidgetNames.push(name);
+    }
+    
+    params.cache = Ext.encode(cachedWidgetNames);
+    
+    // remember the passed callback
+    if (params.callback) {
+      this.callbackHash[params.id] = params.callback;
+      delete params.callback;
+      delete params.scope;
+    }
+    
+    // visually disable the container while the widget is being loaded
+    // Ext.getCmp(params.container).disable();
+    Ext.getCmp(params.container).removeChild(); // simply cleanup the area, which speaks for itself
+    
+    // remote api call
+    this.loadAggregateeWithCache(params);
+  },
+  
+  /*
+  Called by the server as callback about loaded widget
+  */
+  widgetLoaded : function(params){
+    if (this.fireEvent('widgetload')) {
+      // Enable the container after the widget is succesfully loaded
+      // this.getChildWidget(params.id).ownerCt.enable();
+      
+      // provide the callback to that widget that was loading the child, passing the child itself
+      var callbackFn = this.callbackHash[params.id.camelize(true)];
+      if (callbackFn) {
+        callbackFn.call(params.scope || this, this.getChildWidget(params.id));
+        delete this.callbackHash[params.id.camelize(true)];
+      }
+    }
+  },
+  
+  /*
+  Returns the parent widget
+  */
+  getParent: 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();
+    var parentId = idSplit.join("__");
+    
+    return parentId === "" ? null : Ext.getCmp(parentId);
+  },
+  
+  /*
+  Reloads current widget (calls the parent to reload it as its aggregatee)
+  */
+  reload : function(){
+    var parent = this.getParent();
+    if (parent) {
+      parent.loadAggregatee({id:this.localId(parent), container:this.ownerCt.id});
+    } else {
+      window.location.reload();
+    }
+  },
+  
+  /*
+  Gets id in the context of provided parent. 
+  For example, the widgets "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){
+    return this.id.replace(parent.id + "__", "");
+  },
+  
+  /*
+  Instantiates and inserts a widget into a container with layout 'fit'.
+  Arg: an JS object with the following keys:
+    - id: id of the receiving container
+    - config: configuration of the widget to be instantiated and inserted into the container
+  */
+  renderWidgetInContainer : function(params){
+    var cont = Ext.getCmp(params.container);
+    cont.instantiateChild(params.config);
+  },
+  
+  /*
+  Reconfigures the widget
+  */
+  reconfigure: function(config){
+    this.ownerCt.instantiateChild(config)
+  },
+  
+  /*
+  Evaluates CSS
+  */
+  css : function(code){
+    var linkTag = document.createElement('style');
+    linkTag.type = 'text/css';
+    linkTag.innerHTML = code;
+    document.body.appendChild(linkTag);
+  },
+  
+  /*
+  Evaluates JS
+  */
+  js : function(code){
+    eval(code);
+  },
+  
+  /*
+  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 widget can provide any set of commands to its client side.
+  Args:
+    - 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 widget; these methods are called in no particular order
+        2) {widget:widget_id, methods:arrayOfMethods}, used for recursive call to bulkExecute on some child widget
+
+  Example: 
+    - [
+        // the same as this.feedback("Your order is accepted")
+        {feedback: "You order is accepted"}, 
+
+        // the same as this.getChildWidget('users').bulkExecute([{setTitle:'Suprise!'}, {setDisabled:true}])
+        {widget:'users', methods:[{setTitle:'Suprise!'}, {setDisabled:true}] },
+
+        // ... etc:
+        {updateStore:{records:[[1, 'Name1'],[2, 'Name2']], total:10}},
+        {setColums:[{},{}]},
+        {setMenus:[{},{}]},
+        ...
+      ]
+  */
+  bulkExecute : function(instructions){
+    if (Ext.isArray(instructions)) {
+      Ext.each(instructions, function(instruction){ this.bulkExecute(instruction)}, this);
+    } else {
+      for (var instr in instructions) {
+        if (this[instr]) {
+          this[instr].apply(this, [instructions[instr]]);
+        } else {
+          var childWidget = this.getChildWidget(instr);
+          if (childWidget) {
+            childWidget.bulkExecute(instructions[instr]);
+          } else {
+            throw "Unknown method or child widget '" + instr +"' in widget '" + this.id + "'"
+          }
+        }
+      }
+    }
+  },
+  
+  // Get the child widget
+  getChildWidget : function(id){
+    return id === 'parent' ? this.getParent() : Ext.getCmp(this.id+"__"+id);
+  },
+  
   // Common handler for actions
   actionHandler : function(action){
     // If firing corresponding event doesn't return false, call the handler
@@ -109,11 +267,72 @@ Ext.widgetMixIn = {
     }
   },
 
-  beforeConstructor : function(config){
+  // Does the call to the server and processes the response
+  callServer : function(intp, params, callback, scope){
+    if (!params) params = {};
+    Ext.Ajax.request({
+      params : params,
+      url : this.id + "__" + intp,
+      callback : function(options, success, response){
+        if (success) {
+          // execute commands from server
+          this.bulkExecute(Ext.decode(response.responseText));
+          
+          // provade callback if needed
+          if (typeof callback == 'function') { 
+            if (!scope) scope = this;
+            callback.apply(scope);
+          }
+        }
+      },
+      scope : this
+    });
+  },
+
+  /* Parse the bbar and tbar (both Arrays), replacing the strings with the corresponding methods. For example:
+    replaceStringsWithActions( ['add', {text:'Menu', menu:['edit', 'delete']}] )
+    => [scope.actions['add'], {text:'Menu', menu:[scope.actions['edit'], scope.actions['delete']]}]
+  */
+  normalizeMenuItems: function(arry, scope){
+    var res = []; // new array
+    Ext.each(arry, function(o){
+      if (typeof o === "string") {
+        var camelized = o.camelize(true);
+        if (scope.actions[camelized]){
+          res.push(scope.actions[camelized]);
+        } else {
+          // if there's no action with this name, maybe it's a separator or something
+          res.push(o);
+        }
+      } else if (Netzke.isObject(o)) {
+        // look inside the objects...
+        for (var key in o) {
+          if (Ext.isArray(o[key])) {
+            // ... and recursively process inner arrays found
+            o[key] = this.normalizeMenuItems(o[key], scope);
+          }
+        }
+        res.push(o);
+      }
+    }, this);
+    return res;
+  },
+  
+
+  // Every Netzke widget 
+  commonBeforeConstructor : function(config){
     this.actions = {};
 
+    // Generate methods for api points
+    if (!config.api) { config.api = []; }
+    config.api.push('load_aggregatee_with_cache'); // all netzke widgets get this API
+    Ext.each(config.api, function(intp){
+      this[intp.camelize(true)] = function(args, callback, scope){ this.callServer(intp, args, callback, scope); }
+    }, this);
+
     // Create Ext.Actions based on config.actions
     if (config.actions) {
+      this.testActions = {};
       for (var name in config.actions) {
         // Create an event for each action (so that higher-level widgets could interfere)
         this.addEvents(name+'click');
@@ -125,37 +344,13 @@ Ext.widgetMixIn = {
         this.actions[name] = new Ext.Action(actionConfig);
       }
 
-      /* Parse the bbar and tbar (both Arrays), replacing the strings with the corresponding methods. For example:
-        replaceStringsWithActions( ['add', {text:'Menu', menu:['edit', 'delete']}] )
-        => [scope.actions['add'], {text:'Menu', menu:[scope.actions['edit'], scope.actions['delete']]}]
-      */
-      var replaceStringsWithActions = function(arry, scope){
-        var res = []; // new array
-        Ext.each(arry, function(o){
-          if (typeof o === "string") {
-            var camelized = o.camelize(true);
-            if (scope.actions[camelized]){
-              res.push(scope.actions[camelized]);
-            } else {
-              // if there's no action with this name, maybe it's a separator or something
-              res.push(o);
-            }
-          } else if (Netzke.isObject(o)) {
-            // look inside the objects...
-            for (var key in o) {
-              if (Ext.isArray(o[key])) {
-                // ... and recursively process inner arrays found
-                o[key] = replaceStringsWithActions(o[key], scope);
-              }
-            }
-            res.push(o);
-          }
-        });
-        return res;
-      }
-      config.bbar = config.bbar && replaceStringsWithActions(config.bbar, this);
-      config.tbar = config.tbar && replaceStringsWithActions(config.tbar, this);
-      config.menu = config.menu && replaceStringsWithActions(config.menu, this);
+      config.bbar = config.bbar && this.normalizeMenuItems(config.bbar, this);
+      config.tbar = config.tbar && this.normalizeMenuItems(config.tbar, this);
+      config.menu = config.menu && this.normalizeMenuItems(config.menu, this);
+      config.contextMenu = config.contextMenu && this.normalizeMenuItems(config.contextMenu, this);
+      
+      // TODO: need to rethink this action related stuff
+      config.actions = this.actions;
       
     }
 
@@ -172,22 +367,31 @@ Ext.widgetMixIn = {
       config.tools = normTools;
     }
     
+    // Set title
+    if (!config.title) config.title = config.id.humanize();
   },
 
-  afterConstructor : function(config){
+  // At this moment component is fully initializied
+  commonAfterConstructor : function(config){
+    // From everywhere accessible FeedbackGhost
     this.feedbackGhost = Ext.getCmp('feedback_ghost');
 
-    // cleaning up
+    // Add the menus
+    if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu, this);}
+
+    // generic events
+    this.addEvents(
+      'widgetload' // fired when a child is dynamically loaded
+    );
+
+    // Cleaning up on destroy
     this.on('beforedestroy', function(){
-      this.cleanUpMenu(this);
+      this.cleanUpMenu();
     }, this);
     
-    // After render, add the menus
-    this.on('render', function(){
-      if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu);}
-    }, this);
+    this.callbackHash = {};
 
-    this.on('render', this.onWidgetLoad, this);
+    if (this.afterConstructor) this.afterConstructor(config);
   },
 
   feedback:function(msg){
@@ -247,7 +451,7 @@ Ext.widgetMixIn = {
 // Netzke extensions for Ext.Container
 Ext.override(Ext.Container, {
   /** 
-    Get Netzke widget that this Ext.Container is part of. 
+    Get Netzke widget that this Ext.Container is part of (*not* the parent widget, 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).
   */
@@ -261,70 +465,24 @@ Ext.override(Ext.Container, {
         return null
       }
     }
-  }
-});
-
-// Make Panel with layout 'fit' capable of dynamic widgets loading
-Ext.override(Ext.Panel, {
+  },
+  
+  // Get the widget that we are hosting
   getWidget: function(){
-    return this.items.get(0);
+    return this.items ? this.items.get(0) : null; // need this check in case when the container is not yet rendered, like an inactive tab in the TabPanel
   },
   
-  loadWidget: function(url, params){
-    if (!params) {
-      params = {};
-    }
-    
+  removeChild : function(){
+    this.remove(this.getWidget());
+  },
+
+  instantiateChild : function(config){
     this.remove(this.getWidget()); // first delete previous widget 
-    
-    if (!url) return false; // don't load any widget if the url is null
 
-    // we will let the server know which components we have cached
-    var cachedComponentNames = [];
-    for (name in Ext.netzke.cache) {
-      cachedComponentNames.push(name);
-    }
-    
-    this.disable(); // to visually emphasize loading
-    
-    Ext.Ajax.request({
-        url:url, 
-        params:Ext.apply(params, {components_cache:Ext.encode(cachedComponentNames)}), 
-        script:false,
-        callback:function(panel, success, response){
-          var responseObj = Ext.decode(response.responseText);
-          if (responseObj.config) {
-            // we got a normal response
-
-            // evaluate widget's stylesheets
-            if (responseObj.css){
-              var linkTag = document.createElement('style');
-              linkTag.type = 'text/css';
-              linkTag.innerHTML = responseObj.css;
-              document.body.appendChild(linkTag);
-            }
-            
-            // evaluate widget's javascript
-            if (responseObj.js) {
-              eval(responseObj.js);
-            }
-          
-            responseObj.config.ownerWidget = this.getOwnerWidget();
-            var instance = new Ext.netzke.cache[responseObj.config.widgetClassName](responseObj.config)
-        
-            this.add(instance);
-            this.doLayout();
-            
-          } else {
-            // we didn't get normal response - desplay the flash with eventual errors
-            this.getOwnerWidget().feedback(responseObj.flash);
-          }
-          
-          // reenable the panel
-          this.enable();
-        },
-        scope:this
-    })
-  }
-});
+    if (!config) return false; // simply remove current widget if null is passed
 
+    var instance = new Ext.netzke.cache[config.widgetClassName](config);
+    this.add(instance);
+    this.doLayout();
+  }
+});