netzke-core 0.4.5.2 → 0.5.0

data/CHANGELOG.rdoc

@@ -1,3 +1,15 @@
+= v0.5.0
+* Compatibility with Ext 3.1.0
+* API change: Netzke widget's now should be declared directly in the views instead of controllers.
+* API change: all ExtJS and Netzke JavaScript and styles are now loaded with the help of <tt>netzke_init</tt> helper.
+* API change: <tt>persistence_key</tt> option replaces <tt>persistent_config_id</tt> option.
+* Impr: headers in panels in the "config" mode now show the widget's global ID.
+* New: required ExtJS version check introduced at initial Netzke load.
+* Depr: :widget_class_name option is deprecated, use :class_name.
+* DRY: now there's no need to always define "actions" method, use it to override the defaults, which are automatically calculated based on configuration for toolbars/menu.
+* Impr: each generated JS class now has its unique xtype, e.g. "netzkegridpanel".
+* Fix: FeedbackGhost moved over from netzke-basepack.
+
 = v0.4.5.2 - 2009-11-09
 * Fix: Hash#convert_keys and Array#convert_keys in core extensions are now renamed into deep_convert_keys, and now always plainly do what they're expected to do: recursively convert keys according to given block.
 

data/README.rdoc

@@ -1,12 +1,16 @@
 = netzke-core
 Create Ext JS + Rails reusable components (widgets) with minimum effort.
 
-This is the bare bones of the Netzke framework. Use it to build your own widgets from scratch. For pre-built widgets (like panels, grids, forms, trees, applications), see the netzke-basepack project.
+This is the bare bones of the Netzke framework. Use it to build your own widgets from scratch. For pre-built widgets (like panels, grids, forms, trees, applications), see the netzke-basepack (http://github.com/skozlov/netzke-basepack) project.
 
 The idea behind the Netzke framework is that it allows you write reusable client/server code. Create a widget, and then embed it (or load it dynamically) into your Ext-based applications or HTML pages. For more info, see the links below.
 
 == Instalation
-The gem is hosted on gemcutter. If you haven't yet enabled gemcutter, run the following:
+For the latest ("edge") stuff, install as plugin (recommended!):
+
+    ./script/plugin install git://github.com/skozlov/netzke-core.git
+
+Otherwise, install as gem. The gem is hosted on gemcutter. If you haven't yet enabled gemcutter, run the following:
 
     sudo gem install gemcutter && gem tumble
 
@@ -14,17 +18,38 @@ Install the gem
 
     sudo gem install netzke-core
     
-If you want to experiment with the most recent changes, install this as a plugin:
+Generate the migrations for Netzke persistent storage:
 
-    script/plugin install git://github.com/skozlov/netzke-core.git
+    ./script/generate netzke_core
     
+Run the migrations.
+
+Netzke assumes that your ExtJS library is in public/extjs (which may be a symbolic link).
+
 == Usage
-Introduction to Netzke framework: http://github.com/skozlov/netzke/tree/master
+Here's how to embed a Netzke widget into your Rails view.
+
+1. In your layout, within the "head" tag, use the <tt>netzke_init</tt> helper to include all the necessary JavaScript and styles. 
+
+  <%= netzke_init %>
+  
+2. In your view use the <tt>netzke</tt> helper wherever you want to insert a widget.
+
+  <%= netzke :grid_panel, :data_class_name => "User", :columns => [:id, :name, :created_at] %>
+  
+(here we use the GridPanel widget from the netzke-basepack project)
+
+== More info
+Introduction to Netzke framework and wiki: http://github.com/skozlov/netzke
+
+Twitter: <http://twitter.com/skozlov>
+
+Tutorials: <http://blog.writelesscode.com>
 
-Tutorials: http://blog.writelesscode.com
+Live-demo: <http://netzke-demo.writelesscode.com>
 
-Live-demo: http://netzke-demo.writelesscode.com
+The netzke-basepack project (pre-built full-featured widgets): <http://github.com/skozlov/netzke-basepack>
 
-The netzke-basepack project (pre-built full-featured widgets): http://github.com/skozlov/netzke-basepack/tree/master
+---
 
 Copyright (c) 2009 Sergei Kozlov, released under the MIT license

data/Rakefile

@@ -1,7 +1,7 @@
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.version = "0.4.5.2"
+    gemspec.version = "0.5.0"
     gemspec.name = "netzke-core"
     gemspec.summary = "Build ExtJS/Rails widgets with minimum effort"
     gemspec.description = "Allows building ExtJS/Rails reusable code in a DRY way"

data/javascripts/core.js

@@ -2,18 +2,20 @@
 This file gets loaded along with the rest of Ext library at the initial load
 */
 
+// Check Ext JS version
+var requiredExtVersion = "3.1.0";
+var currentExtVersion = Ext.version;
+if (requiredExtVersion !== currentExtVersion) {
+  alert("Netzke needs Ext " + requiredExtVersion + ". You have " + currentExtVersion + ".");
+}
+
+// Initial stuff
 Ext.BLANK_IMAGE_URL = "/extjs/resources/images/default/s.gif";
 Ext.ns('Ext.netzke'); // namespace for extensions that depend on Ext
 Ext.ns('Netzke'); // Netzke namespace
-Netzke.cache = {}; // empty Netzke cache at the moment of loading
 
 Ext.QuickTips.init();
 
-// To comply with Rails' forgery protection
-Ext.Ajax.extraParams = {
-  authenticity_token : Ext.authenticityToken
-};
-
 // Type detection functions
 Netzke.isObject = function(o) {
   return (o != null && typeof o == "object" && o.constructor.toString() == Object.toString());
@@ -100,10 +102,33 @@ Ext.widgetMixIn = {
     
     // build the cached widgets list to send it to the server
     var cachedWidgetNames = "";
-    for (name in Netzke.cache) {
-      cachedWidgetNames += name + ",";
-    }
-    apiParams.cache = cachedWidgetNames;
+
+    // recursive function that checks the properties of the caller ("this") and returns the list of those that look like constructor, i.e. have an "xtype" property themselves
+    var classesList = function(pref){
+      var res = [];
+      for (name in this) {
+        if (this[name].xtype) {
+          res.push(pref + name);
+          this[name].classesList = classesList; // define the same function on each property on the fly
+          res = res.concat(this[name].classesList(pref + name + ".")); // ... and call it, providing our name along with the scope
+        }
+      }
+      return res;
+    };
+    
+    // assign this function to Netzke.classes and call it
+    Netzke.classes.classesList = classesList;
+    var cl = Netzke.classes.classesList("");
+
+    // join the classes into a coma-separated list
+    var cache = "";
+    Ext.each(cl, function(c){cache += c + ",";});
+    
+    // for (name in Netzke.classes) {
+    //   cachedWidgetNames += name + ",";
+    // }
+    // apiParams.cache = cachedWidgetNames;
+    apiParams.cache = cache;
     
     // remember the passed callback for the future
     if (params.callback) {
@@ -291,13 +316,18 @@ Ext.widgetMixIn = {
     }
   },
 
+  // Returns API url based on provided API point
+  buildApiUrl: function(apip){
+    return "/netzke/" + this.id + "__" + apip;
+  },
+
   // 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){
+      Ext.Ajax.request({
+      params: params,
+      url: this.buildApiUrl(intp),
+      callback: function(options, success, response){
         if (success) {
           // execute commands from server
           this.bulkExecute(Ext.decode(response.responseText));
@@ -404,11 +434,15 @@ Ext.widgetMixIn = {
     }
     
     // Set title
-    if (!config.title) {
-      config.title = config.id.humanize();
+    if (config.mode === "config"){
+      if (!config.title) {
+        config.title = '[' + config.id + ']';
+      } else {
+        config.title = config.title + ' [' + config.id + ']';
+      }
     } else {
-      if (config.mode === "config") {
-        config.title = config.title + ' (' + config.id + ')';
+      if (!config.title) {
+        config.title = config.id.humanize();
       }
     }
   },
@@ -525,8 +559,6 @@ Ext.override(Ext.Container, {
     Ext.each(n.split("."), function(s){
       klass = klass[s];
     });
-    // Caching the class
-    Netzke.cache[n] = true;
     return klass;
   },
 
@@ -542,4 +574,36 @@ Ext.override(Ext.Container, {
       this.doLayout();
     }
   }
-});
+});
+
+
+// Feedback Ghost
+Netzke.FeedbackGhost = function(){};
+Ext.apply(Netzke.FeedbackGhost.prototype, {
+  showFeedback: function(msg){
+    var createBox = function(s, l){
+        return ['<div class="msg">',
+                '<div class="x-box-tl"><div class="x-box-tr"><div class="x-box-tc"></div></div></div>',
+                '<div class="x-box-ml"><div class="x-box-mr"><div class="x-box-mc">', s, '</div></div></div>',
+                '<div class="x-box-bl"><div class="x-box-br"><div class="x-box-bc"></div></div></div>',
+                '</div>'].join('');
+    }
+
+    var showBox = function(msg, lvl){
+      if (!lvl) {lvl = 'notice'};
+      var msgCt = Ext.DomHelper.insertFirst(document.body, {'class':'netzke-feedback'}, true);
+      var m = Ext.DomHelper.append(msgCt, {html:createBox(msg,lvl)}, true);
+      m.slideIn('t').pause(2).ghost("b", {remove:true});
+    }
+
+    if (typeof msg != 'string') {
+      var compoundMsg = "";
+      Ext.each(msg, function(m){
+        compoundMsg += m.msg + '<br>';
+      });
+      if (compoundMsg != "") showBox(compoundMsg, null); // the second parameter will be level
+    } else {
+      showBox(msg);
+    }
+	}
+});

data/lib/app/controllers/netzke_controller.rb

@@ -1,5 +1,4 @@
-class NetzkeController < ActionController::Base
-
+class NetzkeController < ApplicationController
   def index
     redirect_to :action => :test_widgets
   end
@@ -27,68 +26,19 @@ class NetzkeController < ActionController::Base
     end
   end
   
-  #
-  # Primitive tests to quickly test the widgets (TODO: move to the basepack)
-  #
-  
-  # FormPanel
-  netzke :form_panel, :persistent_config => false, :label_align => "top", :columns => [
-    {:name => 'field_one', :xtype => 'textarea'},
-    {:name => 'field_two', :xtype => 'textarea'}
-  ]
-  
-  # BorderLayoutPanel
-  netzke :border_layout_panel, :regions => {
-    :west => {
-      :widget_class_name => "Panel",
-      :region_config => {:width => 300, :split => true}
-    },
-    :center => {
-      :widget_class_name => "Panel"
-    }
-  }
-  
-  # TabPanel
-  netzke :tab_panel, :items => [{
-    :widget_class_name => "Panel",
-    :ext_config => {
-      :html => "Panel 1",  
-    },
-    # :active => true
-  },{
-    :widget_class_name => "Panel",
-    :ext_config => {
-      :html => "Panel 2",  
-    }
-  }]
-  
-  # AccordionPanel
-  netzke :accordion_panel, :items => [{
-    :widget_class_name => "Panel",
-    :ext_config => {
-      :html => "Panel 1",
-    },
-    :active => true
-  },{
-    :widget_class_name => "Panel",
-    :ext_config => {
-      :html => "Panel 2",  
-    }
-  }]
+  def method_missing(method_name)
+    widget_name, *action = method_name.to_s.split('__')
+    widget_name = widget_name.to_sym
+    action = !action.empty? && action.join("__").to_sym
   
-  # BasicApp
-  netzke :basic_app
-
-  netzke :panel, :ext_config => {:html => "Panel", :title => "Test panel", :border => true}
-
-  def test_widgets
-    html = "<h3>Quick primitive widgets tests</h3>"
-    
-    self.class.widget_config_storage.each_key.map(&:to_s).sort.each do |w|
-      html << "<a href='#{w}_test'>#{w.to_s.humanize}</a><br/>\n"
+    if action
+      w_instance = Netzke::Base.instance_by_config(Netzke::Base.session[:netzke_widgets][widget_name])
+      # only widget's actions starting with "api_" are accessible from outside (security)
+      api_action = action.to_s.index('__') ? action : "api_#{action}"
+      render :text => w_instance.send(api_action, params), :layout => false
+    else
+      super
     end
-    
-    render :text => html
   end
-
+  
 end

data/lib/netzke/action_view_ext.rb

@@ -1,26 +1,63 @@
 module Netzke
   module ActionViewExt
-
+    # Include JavaScript
     def netzke_js_include
-      res = ""
-
-      if ENV['RAILS_ENV'] == 'development'
-        res << javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all-debug.js")
-      else
-        res << javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all.js")
-      end
-      res << javascript_tag( "Ext.authenticityToken = '#{form_authenticity_token}'") # forgery protection
+      # ExtJS
+      res = ENV['RAILS_ENV'] == 'development' ? javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all-debug.js") : javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all.js")
+      # Netzke (dynamically generated)
       res << javascript_include_tag("/netzke/netzke.js")
-      
-      res
     end
 
+    # Include CSS
     def netzke_css_include(theme_name = :default)
+      # ExtJS base
       res = stylesheet_link_tag("/extjs/resources/css/ext-all.css")
+      # ExtJS theming
       res << stylesheet_link_tag("/extjs/resources/css/xtheme-#{theme_name}.css") unless theme_name == :default
-      res << stylesheet_link_tag("/netzke/netzke.css") # CSS from Netzke
+      # Netzke (dynamically generated)
+      res << stylesheet_link_tag("/netzke/netzke.css")
       res
     end
+    
+    # JavaScript for all Netzke classes in this view, and Ext.onReady which renders all Netzke widgets in this view
+    def netzke_js
+      javascript_tag <<-END_OF_JAVASCRIPT
+        Ext.Ajax.extraParams = {authenticity_token: '#{form_authenticity_token}'}; // Rails' forgery protection... effective?
+        #{@content_for_netzke_js_classes}
+        Ext.onReady(function(){
+          #{@content_for_netzke_on_ready}
+        });
+      END_OF_JAVASCRIPT
+    end
+    
+    # Wrapper for all the above. Use it in your layout.
+    # Params: <tt>:ext_theme</tt> - the name of ExtJS theme to apply (optional)
+    # E.g.:
+    #   <%= netzke_init :ext_theme => "grey" %>
+    def netzke_init(params = {})
+      theme = params[:ext_theme] || :default
+      [netzke_css_include(theme), netzke_js_include, netzke_js].join("\n")
+    end
+    
+    # Use this helper in your views to embed Netzke widgets. E.g.:
+    #   netzke :my_grid, :widget_class_name => "GridPanel", :columns => [:id, :name, :created_at]
+    # On how to configure a widget, see documentation for Netzke::Base or/and specific widget
+    def netzke(name, config = {})
+      ::ActiveSupport::Deprecation.warn("widget_class_name option is deprecated. Use class_name instead", caller) if config[:widget_class_name]
+      class_name = config[:class_name] ||= config[:widget_class_name] || name.to_s.camelcase
+      config[:name] = name
+      Netzke::Base.reg_widget(config)
+      w = Netzke::Base.instance_by_config(config)
+      content_for :netzke_js_classes, w.js_missing_code(@rendered_classes ||= [])
+      content_for :netzke_on_ready, w.js_widget_instance
+      content_for :netzke_on_ready, w.js_widget_render
+      
+      # Now mark this widget's class as rendered, so that we only generate it once per view
+      @rendered_classes << class_name unless @rendered_classes.include?(class_name)
+
+      # Return the html for this widget
+      w.js_widget_html
+    end
   end
 end
 

data/lib/netzke/base.rb

@@ -42,7 +42,7 @@ module Netzke
     
     include Netzke::BaseJs # javascript (client-side)
 
-    attr_accessor :parent, :name, :global_id, :permissions, :session
+    attr_accessor :parent, :name, :global_id #, :permissions, :session
 
     # Class-level Netzke::Base configuration. The defaults also get specified here.
     def self.config
@@ -152,7 +152,8 @@ module Netzke
     
     # Instance of widget by config
     def self.instance_by_config(config)
-      widget_class = "Netzke::#{config[:widget_class_name]}".constantize
+      ::ActiveSupport::Deprecation.warn("widget_class_name option is deprecated. Use class_name instead", caller) if config[:widget_class_name]
+      widget_class = "Netzke::#{config[:class_name] || config[:widget_class_name]}".constantize
       widget_class.new(config)
     end
     
@@ -163,24 +164,22 @@ module Netzke
       nil
     end
 
-    # Return persistent config class
-    # def self.persistent_config
-    #   # if the class is not present, fake it (it will not store anything, and always return nil)
-    #   persistent_config_manager_class || {}
-    # end
-    
     # Widget initialization process
     # * the config hash is available to the widget 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)
     def initialize(config = {}, parent = nil)
-      @session       = Netzke::Base.session
+      # @session       = Netzke::Base.session
       @passed_config = config # configuration passed at the moment of instantiation
       @parent        = parent
       @name          = config[:name].nil? ? short_widget_class_name.underscore : config[:name].to_s
       @global_id     = parent.nil? ? @name : "#{parent.global_id}__#{@name}"
       @flash         = []
     end
+    
+    def session
+      Netzke::Base.session
+    end
 
     #
     # Configuration
@@ -215,7 +214,7 @@ module Netzke
     def persistent_config(global = false)
       if persistent_config_enabled? || global
         config_class = self.class.persistent_config_manager_class
-        config_class.widget_name = global ? nil : persistent_config_id # pass to the config class our unique name
+        config_class.widget_name = global ? nil : persistence_key.to_s # pass to the config class our unique name
         config_class
       else
         # if we can't use presistent config, all the calls to it will always return nil, 
@@ -225,9 +224,11 @@ module Netzke
       end
     end
     
-    # A string which will identify the persistent config records for this widget
-    def persistent_config_id #:nodoc:
-      initial_config[:persistent_config_id] || global_id
+    # A string which will identify NetzkePreference records for this widget. 
+    # If <tt>persistence_key</tt> is passed, use it. Otherwise use global widget's id.
+    def persistence_key #:nodoc:
+      # initial_config[:persistence_key] ? parent.try(:persistence_key) ? "#{parent.persistence_key}__#{initial_config[:persistence_key]}".to_sym : initial_config[:persistence_key] : global_id.to_sym
+      initial_config[:persistence_key] ? initial_config[:persistence_key] : global_id.to_sym
     end
     
     def update_persistent_ext_config(hsh)
@@ -281,9 +282,9 @@ module Netzke
     # this method will return the following hash:
     #     {:enabled => true, :layout => {:width => 100, :header => {:height => 20}}}
     def persistent_config_hash
-      return {} if !initial_config[:persistent_config]
+      return {} if !initial_config[:persistent_config] || Netzke::Base.persistent_config_manager_class.nil?
       
-      prefs = NetzkePreference.find_all_for_widget(persistent_config_id)
+      prefs = NetzkePreference.find_all_for_widget(persistence_key.to_s)
       res = {}
       prefs.each do |p|
         hsh_levels = p.name.split("__").map(&:to_sym)
@@ -412,7 +413,8 @@ module Netzke
         aggr = aggr.to_sym
         aggregatee_config = aggregator.aggregatees[aggr]
         raise ArgumentError, "No aggregatee '#{aggr}' defined for widget '#{aggregator.global_id}'" if aggregatee_config.nil?
-        short_class_name = aggregatee_config[:widget_class_name]
+        ::ActiveSupport::Deprecation.warn("widget_class_name option is deprecated. Use class_name instead", caller) if aggregatee_config[:widget_class_name]
+        short_class_name = aggregatee_config[:class_name] || aggregatee_config[:widget_class_name]
         raise ArgumentError, "No widget_class_name specified for aggregatee #{aggr} of #{aggregator.global_id}" if short_class_name.nil?
         widget_class = "Netzke::#{short_class_name}".constantize
 
@@ -539,6 +541,12 @@ module Netzke
         super
       end
     end
+
+    # Register the configuration for the widget in the session, and also remember that the code for it has been rendered
+    def self.reg_widget(config)
+      session[:netzke_widgets] ||= {}
+      session[:netzke_widgets][config[:name]] = config
+    end
     
   end
 end

data/lib/netzke/base_js.rb

@@ -45,7 +45,6 @@ module Netzke
       res.merge!(:netzke_api => api_points) unless api_points.empty?
   
       # Widget class name. Needed for dynamic instantiation in javascript.
-      # res.merge!(:widget_class_name => short_widget_class_name)
       res.merge!(:scoped_class_name => self.class.js_scoped_class_name)
       
       # Actions, toolbars and menus
@@ -94,17 +93,42 @@ module Netzke
 
     # container for rendering
     def js_widget_html
-      %Q{<div id="#{name.to_s.split('_').join('-')}-div" style="width:800px;"></div>}
+      %Q{<div id="#{name.to_s.split('_').join('-')}-div"></div>}
     end
 
     #
-    #
-    #
- 
     # Widget's actions, tools and menus that are loaded at the moment of instantiation
-    def actions; nil; end
+ 
+    private
+      # Extract action names from menus and toolbars.
+      # E.g.: 
+      # collect_actions(["->", {:text => "Menu", :menu => [{:text => "Submenu", :menu => [:another_button]}, "-", :a_button]}])
+      #  => {:a_button => {:text => "A button"}, :another_button => {:text => "Another button"}}
+      def collect_actions(arry)
+        res = {}
+        arry.each do |item|
+          if item.is_a?(Hash) && menu = item[:menu]
+            res.merge!(collect_actions(item[:menu]))
+          elsif item.is_a?(Symbol)
+            # it's an action
+            res.merge!(item => {:text => item.to_s.humanize})
+          elsif item.is_a?(String)
+            # it's a string item (or maybe JS code)
+          else
+          end
+        end
+        res
+      end
+
+    public
+    # Create default actions from bbar, tbar, and fbar, which are passed in the configuration
+    def actions
+      bar_items = (ext_config[:bbar] || []) + (ext_config[:tbar] || []) + (ext_config[:fbar] || [])
+      bar_items.uniq!
+      collect_actions(bar_items)
+    end
+    
     def menu; nil; end
-    # def tools; nil; end
 
     # Little helpers
     def this; "this".l; end
@@ -179,11 +203,11 @@ module Netzke
       # Declaration of widget's class (stored in the cache storage (Ext.netzke.cache) at the client side 
       # to be reused at the moment of widget instantiation)
       def js_class(cached = [])
-        # Setting the scope.
-        # TODO: invent an easy and error-prove way to check if adding this scope is necessary.
-        # For now setting it each and every time (very save and not really bothering).
+        # Defining the scope if it isn't known yet
         res = %Q{
-          Ext.ns("#{js_full_scope}");
+          if (!#{js_full_scope}) {
+            Ext.ns("#{js_full_scope}");
+          }
         }
 
         if js_inheritance?

data/lib/netzke/controller_extensions.rb

@@ -1,14 +1,12 @@
 module Netzke
   module ControllerExtensions
     def self.included(base)
-      base.extend ControllerClassMethods
       base.send(:before_filter, :set_session_data)
     end
     
     def set_session_data
       Netzke::Base.session = session
       session[:netzke_user_id] = defined?(current_user) ? current_user.try(:id) : nil
-
       # set netzke_just_logged_in and netzke_just_logged_out states (may be used by Netzke widgets)
       if session[:_netzke_next_request_is_first_after_login]
         session[:netzke_just_logged_in] = true
@@ -24,111 +22,5 @@ module Netzke
         session[:netzke_just_logged_out] = false
       end
     end
-    
-    def method_missing(method_name)
-      if self.class.widget_config_storage == {}
-        super
-      else
-        widget, *action = method_name.to_s.split('__')
-        widget = widget.to_sym
-        action = !action.empty? && action.join("__").to_sym
-      
-        # only widget's actions starting with "api_" are accessible from outside (security)
-        if action
-          api_action = action.to_s.index('__') ? action : "api_#{action}"
-
-          # widget module
-          widget_class = "Netzke::#{self.class.widget_config_storage[widget][:widget_class_name]}".constantize
-
-          # instantiate the server part of the widget
-          widget_instance = widget_class.new(self.class.widget_config_storage[widget])
-
-          render :text => widget_instance.send(api_action, params), :layout => false
-        end
-      end
-    end
-    
-    module ControllerClassMethods
-
-      # widget_config_storage for all widgets
-      def widget_config_storage
-        @@widget_config_storage ||= {}
-        @@widget_config_storage[self.name] ||= {} # specific for controller
-      end
-    
-      #
-      # Use this method to declare a widget in the controller
-      #
-      def netzke(name, config={})
-        # which module is the widget?
-        config[:widget_class_name] ||= name.to_s.classify
-        config[:name] ||= name
-      
-        # register the widget config in the storage
-        widget_config_storage[name] = config
-
-        # provide widget helpers
-        ActionView::Base.module_eval <<-END_EVAL, __FILE__, __LINE__
-          def #{name}_server_instance(config = {})
-            default_config = controller.class.widget_config_storage[:#{name}]
-            if config.empty?
-              # only cache when the config is empty (which means that config specified in controller is used)
-              @widget_instance_cache ||= {}
-              @widget_instance_cache[:#{name}] ||= Netzke::Base.instance_by_config(default_config)
-            else
-              # if helper is called with parameters - always return a fresh instance of widget, no caching
-              Netzke::Base.instance_by_config(default_config.deep_merge(config))
-            end
-          end
-        
-          def #{name}_widget_instance(config = {})
-            #{name}_server_instance(config).js_widget_instance
-          end
-          
-          def #{name}_class_definition
-            @generated_widget_classes ||= []
-            res = #{name}_server_instance.js_missing_code(@generated_widget_classes)
-            
-            # prevent duplication of javascript when multiple homogeneous widgets are on the same page
-            @generated_widget_classes += #{name}_server_instance.dependencies
-            @generated_widget_classes.uniq!
-            res
-          end
-          
-          def #{name}_widget_html
-            #{name}_server_instance.js_widget_html
-          end
-          
-          def #{name}_widget_render
-            #{name}_server_instance.js_widget_render
-          end
-          
-        END_EVAL
-      
-        # add controller action which will render a simple HTML page containing the widget
-        define_method("#{name}_test") do
-          @widget_name = name
-          render :inline => <<-HTML
-<head>
-	<meta http-equiv="Content-type" content="text/html; charset=utf-8">
-	<title><%= @widget_name %></title>
-	<%= netzke_js_include %>
-	<%= netzke_css_include %>
-  <script type="text/javascript" charset="utf-8">
-    <%= #{name}_class_definition %>
-    Ext.onReady(function(){
-    	<%= #{name}_widget_instance %>
-    	<%= #{name}_widget_render %>
-    });
-	</script>
-</head>
-<body>
-  <%= #{name}_widget_html %>
-</body>
-          HTML
-        end
-      end
-    end
   end
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: netzke-core
 version: !ruby/object:Gem::Version 
-  version: 0.4.5.2
+  version: 0.5.0
 platform: ruby
 authors: 
 - Sergei Kozlov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-09 00:00:00 -06:00
+date: 2010-01-20 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - .autotest
 - .gitignore