netzke-core 0.4.5 → 0.4.5.1

data/CHANGELOG.rdoc

@@ -1,4 +1,8 @@
-= edge
+= v0.4.5.1 - 2009-11-09
+* Regression: fixing inheritance and caching.
+* FeedbackGhost is too simple to be a Netzke widget (having no server part), so, moved to static JavaScript.
+
+= v0.4.5 - 2009-11-08
 * API change: Netzke::Base: <tt>id_name</tt> accessor renamed to <tt>global_id</tt>
 * Code: several internal code changes
 * Code: lightly better test coverage

data/Rakefile

@@ -1,7 +1,7 @@
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.version = "0.4.5"
+    gemspec.version = "0.4.5.1"
     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

@@ -3,10 +3,11 @@ This file gets loaded along with the rest of Ext library at the initial load
 */
 
 Ext.BLANK_IMAGE_URL = "/extjs/resources/images/default/s.gif";
-Ext.namespace('Ext.netzke'); // namespace for extensions that depend on Ext
-Ext.namespace('Netzke.classes'); // namespace for extensions that do not depend on Ext
+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(); // seems obligatory in Ext v2.2.1, otherwise Ext.Component#destroy() stops working properly
+Ext.QuickTips.init();
 
 // To comply with Rails' forgery protection
 Ext.Ajax.extraParams = {
@@ -98,11 +99,11 @@ Ext.widgetMixIn = {
     var apiParams = Ext.apply({id: params.id, container: params.container}, params.params); 
     
     // build the cached widgets list to send it to the server
-    var cachedWidgetNames = [];
-    for (name in Netzke.classes) {
-      cachedWidgetNames.push(name);
+    var cachedWidgetNames = "";
+    for (name in Netzke.cache) {
+      cachedWidgetNames += name + ",";
     }
-    apiParams.cache = Ext.encode(cachedWidgetNames);
+    apiParams.cache = cachedWidgetNames;
     
     // remember the passed callback for the future
     if (params.callback) {
@@ -415,7 +416,7 @@ Ext.widgetMixIn = {
   // At this moment component is fully initializied
   commonAfterConstructor : function(config){
     // From everywhere accessible FeedbackGhost
-    this.feedbackGhost = Ext.getCmp('feedback_ghost');
+    this.feedbackGhost = new Netzke.FeedbackGhost();
 
     // Add the menus
     if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu, this);}
@@ -524,6 +525,9 @@ Ext.override(Ext.Container, {
     Ext.each(n.split("."), function(s){
       klass = klass[s];
     });
+    // Caching the class
+    Netzke.cache[n] = true;
+    // console.info(Netzke.cache);
     return klass;
   },
 

data/lib/netzke/base.rb

@@ -47,12 +47,20 @@ module Netzke
     # Class-level Netzke::Base configuration. The defaults also get specified here.
     def self.config
       set_default_config({
-        # which javascripts and stylesheets must get included at the initial load (see netzke-core.rb)
+        # Which javascripts and stylesheets must get included at the initial load (see netzke-core.rb)
         :javascripts               => [],
         :stylesheets               => [],
         
+        # AR model that provides us with persistent config functionality
         :persistent_config_manager => "NetzkePreference",
+        
+        # Default location of extjs library
         :ext_location              => defined?(RAILS_ROOT) && "#{RAILS_ROOT}/public/extjs",
+        
+        # Default location of icons (TODO: has no effect for now)
+        :icons_location            => defined?(RAILS_ROOT) && "#{RAILS_ROOT}/public/images/icons",
+        
+        # Default instance config
         :default_config => {
           :persistent_config => true
         }
@@ -83,7 +91,7 @@ module Netzke
     # Short widget class name, e.g.: 
     #   Netzke::Module::SomeWidget => Module::SomeWidget
     def self.short_widget_class_name
-      self.name.sub("Netzke::", "")
+      self.name.sub(/^Netzke::/, "")
     end
 
     # Access to controller sessions
@@ -397,6 +405,7 @@ module Netzke
     end
 
     # recursively instantiates an aggregatee based on its "path": e.g. if we have an aggregatee :aggr1 which in its turn has an aggregatee :aggr10, the path to the latter would be "aggr1__aggr10"
+    # TODO: introduce memoization
     def aggregatee_instance(name, strong_config = {})
       aggregator = self
       name.to_s.split('__').each do |aggr|
@@ -481,7 +490,7 @@ module Netzke
     # * <tt>:id</tt> - reference to the aggregatee
     # * <tt>:container</tt> - Ext id of the container where in which the aggregatee will be rendered
     def load_aggregatee_with_cache(params)
-      cache = ActiveSupport::JSON.decode(params.delete(:cache))
+      cache = params[:cache].gsub(".", "::").split(",") # array of cached class names (in Ruby)
       relative_widget_id = params.delete(:id).underscore.to_sym
       widget = aggregatees[relative_widget_id] && aggregatee_instance(relative_widget_id)
       

data/lib/netzke/base_js.rb

@@ -57,7 +57,6 @@ module Netzke
       res[:persistent_config] = persistent_config_enabled?
 
       # Merge with all config options passed as hash to config[:ext_config]
-      logger.debug "!!! ext_config: #{ext_config.inspect}\n"
       res.merge!(ext_config)
 
       res
@@ -65,16 +64,16 @@ module Netzke
   
     # All the JS-code required by this instance of the widget to be instantiated in the browser.
     # It includes the JS-class for the widget itself, as well as JS-classes for all widgets' (non-late) aggregatees.
-    def js_missing_code(cached_dependencies = [])
+    def js_missing_code(cached = [])
       code = dependency_classes.inject("") do |r,k| 
-        cached_dependencies.include?(k) ? r : r + "Netzke::#{k}".constantize.js_code(cached_dependencies).strip_js_comments
+        cached.include?(k) ? r : r + "Netzke::#{k}".constantize.js_code(cached).strip_js_comments
       end
       code.blank? ? nil : code
     end
     
-    def css_missing_code(cached_dependencies = [])
+    def css_missing_code(cached = [])
       code = dependency_classes.inject("") do |r,k| 
-        cached_dependencies.include?(k) ? r : r + "Netzke::#{k}".constantize.css_code(cached_dependencies)
+        cached.include?(k) ? r : r + "Netzke::#{k}".constantize.css_code(cached)
       end
       code.blank? ? nil : code
     end
@@ -90,13 +89,7 @@ module Netzke
 
     # rendering
     def js_widget_render
-      %Q{
-        if (#{name.jsonify}.isXType("netzkewindow")) {
-          #{name.jsonify}.show();
-        } else {
-          #{name.jsonify}.render("#{name.to_s.split('_').join('-')}-div");
-        }
-      }
+      self.class.js_xtype == "netzkewindow" ? %Q{#{name.jsonify}.show();} : %Q{#{name.jsonify}.render("#{name.to_s.split('_').join('-')}-div");}
     end
 
     # container for rendering
@@ -132,35 +125,52 @@ module Netzke
       def js_extend_properties 
         {}
       end
-    
-      # Returns the scope of this widget, 
-      # e.g. "Netzke.GridPanelLib"
+
+      # widget's menus
+      def js_menus; []; end
+  
+      # Given class name, e.g. GridPanelLib::Widgets::RecordFormWindow, 
+      # returns its scope: "Widgets.RecordFormWindow"
+      def js_class_name_to_scope(name)
+        name.split("::")[0..-2].join(".")
+      end
+
+      # Top level scope which will be used to cope out Netzke classes, e.g. "Netzke.classes" (default)
+      def js_default_scope
+        "Netzke.classes"
+      end
+  
+      # Scope of this widget without default scope
+      # e.g.: GridPanelLib.Widgets
       def js_scope
-        js_full_class_name.split(".")[0..-2].join(".")
+        js_class_name_to_scope(short_widget_class_name)
+      end
+  
+      # Returns the scope of this widget
+      # e.g. "Netzke.classes.GridPanelLib"
+      def js_full_scope
+        js_scope.empty? ? js_default_scope : [js_default_scope, js_scope].join(".")
       end
   
-      # Returns the name of the JavaScript class for this widget, including the scopes, 
-      # e.g.: "Netzke.GridPanelLib.RecordFormWindow"
+      # Returns the name of the JavaScript class for this widget, including the scope
+      # e.g.: "GridPanelLib.RecordFormWindow"
       def js_scoped_class_name
-        name.gsub("::", ".")
+        short_widget_class_name.gsub("::", ".")
       end
 
       # Returns the full name of the JavaScript class, including the scopes *and* the common scope, which is
       # Netzke.classes.
       # E.g.: "Netzke.classes.Netzke.GridPanelLib.RecordFormWindow"
       def js_full_class_name
-        "Netzke.classes." + js_scoped_class_name
+        [js_full_scope, short_widget_class_name.split("::").last].join(".")
       end
-
+      
       # Builds this widget's xtype
       # E.g.: netzkewindow, netzkegridpanel
       def js_xtype
         name.gsub("::", "").downcase
       end
   
-      # widget's menus
-      def js_menus; []; end
-  
       # are we using JS inheritance? for now, if js_base_class is a Netzke class - yes
       def js_inheritance?
         superclass != Netzke::Base
@@ -168,28 +178,40 @@ 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
+      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).
+        res = %Q{
+          Ext.ns("#{js_full_scope}");
+        }
+
         if js_inheritance?
-          # In case of using javascript inheritance, little needs to be done
-          <<-END_OF_JAVASCRIPT
-          // Define the scope
-          Ext.ns("#{js_scope}");
-          // Create the class
+          # Using javascript inheritance
+          res << <<-END_OF_JAVASCRIPT
+          // Costructor
           #{js_full_class_name} = function(config){
             #{js_full_class_name}.superclass.constructor.call(this, config);
           };
-          // Extend it with the class that we inherit from, and mix in js_extend_properties
-          Ext.extend(#{js_full_class_name}, #{superclass.js_full_class_name}, Ext.applyIf(#{js_extend_properties.to_nifty_json}, Ext.widgetMixIn));
-          // Register xtype
-          Ext.reg("#{js_xtype}", #{js_full_class_name});
+          END_OF_JAVASCRIPT
+          
+          # Do we specify our own extend properties (overrriding js_extend_properties)? If so, include them, if not - don't re-include those from the parent!
+          res << (singleton_methods(false).include?("js_extend_properties") ? %Q{
+          Ext.extend(#{js_full_class_name}, #{superclass.js_full_class_name}, #{js_extend_properties.to_nifty_json});
+          } : %Q{
+          Ext.extend(#{js_full_class_name}, #{superclass.js_full_class_name});
+          })
           
+          res << <<-END_OF_JAVASCRIPT
+          // Register our xtype
+          Ext.reg("#{js_xtype}", #{js_full_class_name});
           END_OF_JAVASCRIPT
           
         else
+          # Menus
           js_add_menus = "this.addMenus(#{js_menus.to_nifty_json});" unless js_menus.empty?
-          <<-END_OF_JAVASCRIPT
-          // Define the scope
-          Ext.ns("#{js_scope}");
+          
+          res << <<-END_OF_JAVASCRIPT
           // Constructor
           #{js_full_class_name} = function(config){
             // Do all the initializations that every Netzke widget should do: create methods for API-points,
@@ -204,9 +226,10 @@ module Netzke
           Ext.extend(#{js_full_class_name}, #{js_base_class}, Ext.applyIf(#{js_extend_properties.to_nifty_json}, Ext.widgetMixIn));
           // Register xtype
           Ext.reg("#{js_xtype}", #{js_full_class_name});
-          
           END_OF_JAVASCRIPT
         end
+        
+        res
       end
       
       #
@@ -215,15 +238,16 @@ module Netzke
       
       # Override this method. Must return an array of paths to javascript files that we depend on. 
       # This javascript code will be loaded along with the widget's class, and before it.
-      def include_js
-        []
-      end
+      # def include_js
+      #   []
+      # end
       
       # Returns all extra JavaScript-code (as string) required by this widget's class
       def js_included
         res = ""
-
-        include_js.each do |path|
+        
+        # Prevent re-including code that was already included by the parent
+        singleton_methods(false).include?("include_js") && include_js.each do |path|
           f = File.new(path)
           res << f.read << "\n"
         end
@@ -232,17 +256,19 @@ module Netzke
       end
       
       # All JavaScript code needed for this class, including one from the ancestor widget
-      def js_code(cached_dependencies = [])
+      def js_code(cached = [])
         res = ""
 
         # include the base-class javascript if doing JS inheritance
-        res << superclass.js_code << "\n" if js_inheritance? && !cached_dependencies.include?(superclass.short_widget_class_name)
+        if js_inheritance? && !cached.include?(superclass.short_widget_class_name)
+          res << superclass.js_code(cached) << "\n"
+        end
 
         # include static javascripts
         res << js_included << "\n"
 
         # our own JS class definition
-        res << js_class
+        res << js_class(cached)
         res
       end
 
@@ -251,15 +277,15 @@ module Netzke
       # 
 
       # Override this method. Must return an array of paths to css files that we depend on. 
-      def include_css
-        []
-      end
+      # def include_css
+      #   []
+      # end
       
       # Returns all extra CSS code (as string) required by this widget's class
       def css_included
         res = ""
         
-        include_css.each do |path|
+        singleton_methods(false).include?("include_css") && include_css.each do |path|
           f = File.new(path)
           res << f.read << "\n"
         end
@@ -268,11 +294,11 @@ module Netzke
       end
       
       # All CSS code needed for this class including the one from the ancestor widget
-      def css_code(cached_dependencies = [])
+      def css_code(cached = [])
         res = ""
 
         # include the base-class javascript if doing JS inheritance
-        res << superclass.css_code << "\n" if js_inheritance? && !cached_dependencies.include?(superclass.short_widget_class_name)
+        res << superclass.css_code << "\n" if js_inheritance? && !cached.include?(superclass.short_widget_class_name)
         
         res << css_included << "\n"
         

data/lib/netzke-core.rb

@@ -8,8 +8,6 @@ require 'netzke/controller_extensions'
 require 'netzke/core_ext'
 require 'netzke/routing'
 
-require 'netzke/feedback_ghost'
-
 # Load models and controllers from lib/app
 %w{ models controllers }.each do |dir|
   path = File.join(File.dirname(__FILE__), 'app', dir)

data/test/unit/netzke_core_test.rb

@@ -56,6 +56,11 @@ module Netzke
   class JsInheritanceWidget < Widget
   end
   
+  module ScopedWidgets
+    class SomeScopedWidget < Base
+    end
+  end
+  
   class InheritedWidget < Widget
     def self.config
       super.merge({
@@ -144,8 +149,8 @@ class NetzkeCoreTest < ActiveSupport::TestCase
 
   test "js inheritance" do
     widget = JsInheritanceWidget.new
-    assert(widget.js_missing_code.index("Netzke.classes.Netzke.JsInheritanceWidget"))
-    assert(widget.js_missing_code.index("Netzke.classes.Netzke.Widget"))
+    assert(widget.js_missing_code.index("Netzke.classes.JsInheritanceWidget"))
+    assert(widget.js_missing_code.index("Netzke.classes.Widget"))
   end
 
   test "class-level configuration" do
@@ -163,4 +168,16 @@ class NetzkeCoreTest < ActiveSupport::TestCase
     
   end
 
+  test "JS class names and scopes" do
+    klass = Netzke::NestedWidgetOne
+    assert_equal("Netzke.classes", klass.js_full_scope)
+    assert_equal("", klass.js_class_name_to_scope(klass.short_widget_class_name))
+    
+    klass = Netzke::ScopedWidgets::SomeScopedWidget
+    assert_equal("Netzke.classes", klass.js_default_scope)
+    assert_equal("ScopedWidgets::SomeScopedWidget", klass.short_widget_class_name)
+    assert_equal("ScopedWidgets", klass.js_class_name_to_scope(klass.short_widget_class_name))
+    assert_equal("Netzke.classes.ScopedWidgets", klass.js_full_scope)
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: netzke-core
 version: !ruby/object:Gem::Version 
-  version: 0.4.5
+  version: 0.4.5.1
 platform: ruby
 authors: 
 - Sergei Kozlov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-08 00:00:00 -06:00
+date: 2009-11-09 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -46,7 +46,6 @@ files:
 - lib/netzke/base_js.rb
 - lib/netzke/controller_extensions.rb
 - lib/netzke/core_ext.rb
-- lib/netzke/feedback_ghost.rb
 - lib/netzke/routing.rb
 - stylesheets/core.css
 - tasks/netzke_core_tasks.rake

data/lib/netzke/feedback_ghost.rb

@@ -1,43 +0,0 @@
-module Netzke
-  #
-  # An invisible component that provides feedback service for all Netzke widgets
-  #
-  class FeedbackGhost < Base
-    def self.js_base_class
-      "Ext.Component" # yes, invisible
-    end
-
-    def self.js_extend_properties
-      {
-        :show_feedback => <<-END_OF_JAVASCRIPT.l,
-          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);
-            }
-        	}
-        END_OF_JAVASCRIPT
-      }
-    end
-  end
-end