netzke-core 0.1.4 → 0.2.0

data/CHANGELOG

@@ -1,3 +1,15 @@
+v0.2.0
+* Some re-factoring and redesign. Now simple compound widgets can be created on the fly in the controller
+* Added ext_widget[:quiet] configuration option to suppress widget's feedback
+* Support for extra CSS sources, similar to JS
+* NETZKE_BOOT_CONFIG introduced to specify which Netzke functionality should be disabled to reduce the size of /netzke/netzke.[js|css]
+* FeedbackGhost widget added - invisible widget providing feedback to the user
+* netzke_widget controller class-method renamed into netzke
+* JS-comments now get stripped also from the extra files that get included in the netzke-* gems.
+* Permissions joined js_config
+
+Bug fixes
+
 v0.1.4
 Helpers added to facilitate ExtJS/netzke.js inclusion
 The route defined for netzke_controller

data/Manifest

@@ -1,4 +1,5 @@
 CHANGELOG
+css/core.css
 generators/netzke_core/netzke_core_generator.rb
 generators/netzke_core/templates/create_netzke_layouts.rb
 generators/netzke_core/templates/create_netzke_preferences.rb
@@ -13,6 +14,7 @@ lib/netzke/action_view_ext.rb
 lib/netzke/base.rb
 lib/netzke/controller_extensions.rb
 lib/netzke/core_ext.rb
+lib/netzke/feedback_ghost.rb
 lib/netzke/js_class_builder.rb
 lib/netzke/routing.rb
 lib/netzke-core.rb

data/css/core.css

@@ -0,0 +1,8 @@
+/* feedback */
+.netzke-feedback {
+    position:absolute;
+    left:25%;
+    top:0;
+    width:300px;
+    z-index:20000;
+}

data/generators/netzke_core/templates/create_netzke_preferences.rb

@@ -6,7 +6,7 @@ class CreateNetzkePreferences < ActiveRecord::Migration
       t.string :value
       t.integer :user_id
       t.integer :role_id
-      t.string :custom_field
+      t.string :widget_name
 
       t.timestamps
     end

data/javascripts/core.js

@@ -49,7 +49,8 @@ Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
 // Methods common to all widget classes
 Ext.widgetMixIn = {
 	widgetInit:function(config){
-    this.app = Ext.getCmp('application');
+    this.app = Ext.getCmp('feedback_ghost');
+    // this.app = Ext.getCmp('application');
     if (config.tools) Ext.each(config.tools, function(i){i.on.click = this[i.on.click].createDelegate(this)}, this);
     if (config.actions) Ext.each(config.actions, function(i){i.handler = this[i.handler].createDelegate(this);}, this);
 	},
@@ -67,6 +68,7 @@ Ext.widgetMixIn = {
 	},
 
 	feedback:function(msg){
+		if (this.initialConfig.quiet) return false;
 		if (this.app && !!this.app.showFeedback) {
 			this.app.showFeedback(msg)
 		} else {
@@ -127,3 +129,21 @@ Ext.override(Ext.Panel, {
 		
 	}
 });
+
+// Some Rubyish String extensions
+// from http://code.google.com/p/inflection-js/
+String.prototype.capitalize=function()
+{
+  var str=this.toLowerCase();
+  str=str.substring(0,1).toUpperCase()+str.substring(1);
+  return str;
+};
+
+String.prototype.humanize=function(lowFirstLetter)
+{
+  var str=this.toLowerCase();
+  str=str.replace(new RegExp('_id','g'),'');
+  str=str.replace(new RegExp('_','g'),' ');
+  if(!lowFirstLetter)str=str.capitalize();
+  return str;
+};

data/lib/app/controllers/netzke_controller.rb

@@ -9,6 +9,15 @@ class NetzkeController < ActionController::Base
           f = File.new(path)
           res << f.read
         end
+        render :text => res.strip_js_comments
+      }
+      
+      format.css {
+        res = ""
+        Netzke::Base.config[:css].each do |path|
+          f = File.new(path)
+          res << f.read
+        end
         render :text => res
       }
     end

data/lib/app/models/netzke_layout.rb

@@ -1,9 +1,4 @@
 class NetzkeLayout < ActiveRecord::Base
-  # has_many :layout_items#, :class_name => "ExtWidget::LayoutItem", :order => :position
-  # has_many :objects, :class_name => "Objects", :foreign_key => "class_name_id"
-  # belongs_to :role
-  # belongs_to :user
-
   UNRELATED_ATTRS = %w(created_at updated_at position layout_id)
 
   def self.user_id
@@ -14,16 +9,6 @@ class NetzkeLayout < ActiveRecord::Base
     items_class.constantize.find_all_by_layout_id(id, :order => 'position')
   end
   
-  #   
-  # def self.user_id=(user_id)
-  #   @@user_id = user_id
-  # end
-  # 
-  # def self.layout_items(widget_name)
-  #   layout = self.layout(widget_name)
-  #   layout.nil? ? nil : layout.layout_items.map(&:attributes).map{|item| item.delete_if{|k,v| UNRELATED_ATTRS.include?(k)}}
-  # end
-  # 
   def self.by_widget(widget_name)
     self.find(:first, :conditions => {:widget_name => widget_name, :user_id => self.user_id})
   end
@@ -34,42 +19,8 @@ class NetzkeLayout < ActiveRecord::Base
     layout_item.insert_at(new_index + 1)
   end
 
-  # def self.layout_items(widget_name)
-  #   layout = self.by_widget(widget_name)
-  #   if layout
-  #     layout.layout_items
-  #   else
-  #     # create new layout and fill it out with default values
-  #     layout = Layout.create({:widget_name => widget_name, :user_id => self.user_id})
-  #   end
-  # end
-  
   def items_hash
     layout_items.map(&:attributes).map{|item| item.delete_if{|k,v| UNRELATED_ATTRS.include?(k)}}.map{ |i| i.convert_keys{ |k| k.to_sym } }
   end
- 
-  # if layout items are provided, use them instead of defaults (exsposed) layout items, but merge their configs with the default
-  # def self.create_layout_for_widget(widget_name, data_class_name, layout_item_class_name, items = nil)
-  #   layout = self.create(:widget_name => widget_name, :items_class => layout_item_class_name, :user_id => self.user_id)
-  #   data_class = data_class_name.constantize
-  #   layout_item_class = layout_item_class_name.constantize
-  #   
-  #   
-  #   if items.nil?
-  #     complete_items = data_class.exposed_columns
-  #   else
-  #     # normalize columns
-  #     columns = columns.
-  #     default_columns = data_class.exposed_columns.map{|c| c.is_a?(Symbol) ? {:name => c} : c}
-  #     columns.each
-  #   
-  #   complete_columns = columns.nil? ?  : columns
-  #   complete_columns.each do |c|
-  #     config = c.is_a?(Hash) ? c : {:name => c}
-  #     # we have to merge layout_id in order to have :position set up properly
-  #     item = layout_item_class.create_with_defaults(config.merge({:layout_id => layout.id}), data_class)
-  #   end
-  #   layout
-  # end
   
 end

data/lib/app/models/netzke_preference.rb

@@ -9,12 +9,12 @@ class NetzkePreference < ActiveRecord::Base
     @@user ||= nil
   end
   
-  def self.custom_field=(value)
-    @@custom_field = value
+  def self.widget_name=(value)
+    @@widget_name = value
   end
   
-  def self.custom_field
-    @@custom_field ||= nil
+  def self.widget_name
+    @@widget_name ||= nil
   end
   
   def normalized_value
@@ -48,7 +48,7 @@ class NetzkePreference < ActiveRecord::Base
   
   def self.[](pref_name)
     pref_name = pref_name.to_s
-    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
+    conditions = {:name => pref_name, :user_id => self.user, :widget_name => self.widget_name}
     pref = self.find(:first, :conditions => conditions)
     # pref = @@user.nil? ? self.find_by_name(pref_name) : self.find_by_name_and_user_id(pref_name, @@user.id)
     pref && pref.normalized_value
@@ -56,7 +56,7 @@ class NetzkePreference < ActiveRecord::Base
   
   def self.[]=(pref_name, new_value)
     pref_name = pref_name.to_s
-    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
+    conditions = {:name => pref_name, :user_id => self.user, :widget_name => self.widget_name}
     pref = self.find(:first, :conditions => conditions) || self.create(conditions)
     # pref = self.user.nil? ? self.find_or_create_by_name(pref_name) : self.find_or_create_by_name_and_user_id(pref_name, self.user.id)
     pref.normalized_value = new_value

data/lib/netzke/action_view_ext.rb

@@ -18,6 +18,7 @@ module Netzke
     def netzke_css_include(theme_name = :default)
       res = stylesheet_link_tag("/extjs/resources/css/ext-all.css")
       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
       res
     end
   end

data/lib/netzke/base.rb

@@ -1,35 +1,78 @@
 require 'json'
 
 module Netzke
+  # 
+  # Configuration:
+  # * Define NETZKE_BOOT_CONFIG in environment.rb to specify which Netzke functionality should be disabled 
+  # to reduce the size of /netzke/netzke.[js|css]. Those Netzke gems that use additional JS-code 
+  # should be aware of this constant.
+  #
   class Base
-    # client-side code (generates JS-classes of the widgets)
-    include Netzke::JsClassBuilder
-
-    # Global Netzke configuration
-    def self.config
-      @@config ||= {
-        :javascripts => ["#{File.dirname(__FILE__)}/../../javascripts/core.js"] # locations of javascript files (which automatically will be collected into one file and sent as netzke.js)
-      }
-    end
-    
-    def self.js_class_code(cached_dependencies = [])
-      self.new(:js_class => true).js_missing_code(cached_dependencies)
-    end
-    
     # Helper class to read/write from/to widget's persistent preferences. TODO: rework it.
     class Config
       def initialize(widget_name)
         @widget_name = widget_name
       end
       def []=(k,v)
-        NetzkePreference.custom_field = @widget_name
+        NetzkePreference.widget_name = @widget_name
         NetzkePreference[k] = v
       end
       def [](k)
-        NetzkePreference.custom_field = @widget_name
+        NetzkePreference.widget_name = @widget_name
         NetzkePreference[k]
       end
     end
+
+    # Client-side code (generates JS-class of the widget)
+    include Netzke::JsClassBuilder
+
+    # Class methods
+    class << self
+      # Global Netzke configuration
+      def config
+        @@config ||= {
+          # locations of javascript and css files (which will be automatically collected into one file and sent as /netzke/netzke.js and /netzke/netzke.css respectively)
+          :javascripts => [],
+          :css => []
+        }
+      end
+      
+      def short_widget_class_name
+        name.split("::").last
+      end
+
+      #
+      # Use this class method to declare connection points between client side of a widget and its server side. A method in a widget class with the same name will be (magically) called by the client side of the widget. See Grid widget for an example
+      #
+      def interface(*interface_points)
+        interfacep = read_inheritable_attribute(:interface_points) || []
+        interface_points.each{|p| interfacep << p}
+        write_inheritable_attribute(:interface_points, interfacep)
+
+        interface_points.each do |interfacep|
+          module_eval <<-END, __FILE__, __LINE__
+          def interface_#{interfacep}(*args)
+            #{interfacep}(*args).to_js
+          end
+          # FIXME: commented out because otherwise ColumnOperations stop working
+          # def #{interfacep}(*args)
+          #   flash :warning => "API point '#{interfacep}' is not implemented for widget '#{short_widget_class_name}'"
+          #   {:flash => @flash}
+          # end
+          END
+        end
+      end
+
+      def interface_points
+        read_inheritable_attribute(:interface_points)
+      end
+      
+      # returns an instance of a widget defined in the config
+      def instance_by_config(config)
+        widget_class = "Netzke::#{config[:widget_class_name]}".constantize
+        widget_class.new(config)
+      end
+    end
   
     attr_accessor :config, :server_confg, :parent, :logger, :id_name, :permissions
     attr_reader :pref
@@ -57,47 +100,13 @@ module Netzke
       self.class.short_widget_class_name
     end
     
-    def self.short_widget_class_name
-      name.split("::").last
-    end
-    
-    #
-    # Use this class-method to declare connection points between client side of a widget and its server side. A method in a widget class with the same name will be (magically) called by the client-side of the widget. See Grid widget for an example
-    #
-    def self.interface(*interface_points)
-      interfacep = read_inheritable_attribute(:interface_points) || []
-      interface_points.each{|p| interfacep << p}
-      write_inheritable_attribute(:interface_points, interfacep)
-      
-      interface_points.each do |interfacep|
-        module_eval <<-END, __FILE__, __LINE__
-        def interface_#{interfacep}(*args)
-          #{interfacep}(*args).to_js
-        end
-        # FIXME: commented out because otherwise ColumnOperations stop working
-        # def #{interfacep}(*args)
-        #   flash :warning => "API point '#{interfacep}' is not implemented for widget '#{short_widget_class_name}'"
-        #   {:flash => @flash}
-        # end
-        END
-      end
-    end
-    
-    def self.interface_points
-      read_inheritable_attribute(:interface_points)
-    end
-    
-    def interface_points
-      self.class.interface_points
-    end
-
-    interface :get_widget # default
+    interface :get_widget # every widget gets this
 
     ## Dependencies
     def dependencies
       @dependencies ||= begin
-        non_late_aggregatees_widget_classes = aggregatees.values.map{|v| v[:widget_class_name]}
-        (initial_dependencies + non_late_aggregatees_widget_classes).uniq
+        non_late_aggregatees_widget_classes = non_late_aggregatees.values.map{|v| v[:widget_class_name]}
+        (initial_dependencies + non_late_aggregatees_widget_classes << self.class.short_widget_class_name).uniq
       end
     end
     
@@ -123,7 +132,7 @@ module Netzke
       aggregatees.merge!(aggr)
     end
     
-    # The difference between aggregatees and late aggregatees is the following: the former gets instantiated together with its aggregator and is normally instantly visible as a part of it. While a late aggregatee doesn't get instantiated along with its aggregator. Until it gets requested, it doesn't take any part in its aggregator's lifecycle. An example of late aggregatee could be a widget that is loaded by an application widget on user's request, or a preferences window that only gets instantiated when user wants to edit widget's preferences. An example of a normal aggregatee is any widget (like a grid) within a BorderLayout-based widget (i.e. aggregator) - it should get instantiated and shown along with its aggregator.
+    # The difference between aggregatees and late aggregatees is the following: the former gets instantiated together with its aggregator and is normally *instantly* visible as a part of it (for example, the widget in the initially expanded panel in an Accordion). A late aggregatee doesn't get instantiated along with its aggregator. Until it gets requested from the server, it doesn't take any part in its aggregator's life. An example of late aggregatee could be a widget that is loaded dynamically into a previously collapsed panel of an Accordion, or a preferences window (late aggregatee) for a widget (aggregator) that only gets shown when user wants to edit widget's preferences.
     def initial_late_aggregatees
       {}
     end
@@ -145,7 +154,6 @@ module Netzke
       aggregator
     end
     
-    
     def full_widget_class_name(short_name)
       "Netzke::#{short_name}"
     end
@@ -178,7 +186,7 @@ module Netzke
         config[:allow] && config[:allow].each{|p| @permissions.merge!(p.to_sym => true)} # allow
         
         # ... and then merge it with NetzkePreferences (if not instantiated to only generate JS-class code)
-        !config[:js_class] && available_permissions.each do |p|
+        available_permissions.each do |p|
           @permissions[p.to_sym] = @pref["permissions.#{p}"] if !@pref["permissions.#{p}"].nil?
         end
       end

data/lib/netzke/controller_extensions.rb

@@ -36,7 +36,7 @@ module Netzke
       #
       # Use this method to declare a widget in the controller
       #
-      def netzke_widget(name, config={})
+      def netzke(name, config={})
         # which module is the widget?
         config[:widget_class_name] ||= name.to_s.classify
         config[:name] ||= name
@@ -61,7 +61,7 @@ module Netzke
             widget_instance.js_widget_instance
           end
           
-          def #{name}_class_definition
+          def #{name}_class_definition_old
             result = ""
             config = controller.class.widget_config_storage[:#{name}]
             @generated_widget_classes ||= []
@@ -72,6 +72,16 @@ module Netzke
             end
             result
           end
+
+          def #{name}_class_definition
+            @generated_widget_classes ||= []
+            config = controller.class.widget_config_storage[:#{name}]
+            widget_instance = Netzke::#{config[:widget_class_name]}.new(config)
+            res = widget_instance.js_missing_code(@generated_widget_classes)
+            @generated_widget_classes += widget_instance.dependencies
+            @generated_widget_classes.uniq!
+            res
+          end
         END_EVAL
       
         # add controller action which will render a simple HTML page containing the widget

data/lib/netzke/feedback_ghost.rb

@@ -0,0 +1,43 @@
+module Netzke
+  #
+  # An invisible component that provides feedback service for all Netzke widgets
+  #
+  class FeedbackGhost < Base
+    class << self
+      def js_base_class
+        "Ext.Component" # yes, invisible
+      end
+
+      def js_extend_properties
+        {
+          :show_feedback => <<-JS.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') {
+                Ext.each(msg, function(m){
+                  showBox(m.msg, m.level)
+                })
+              } else {
+                showBox(msg)
+              }
+          	}
+          JS
+        }
+      end
+    end
+  end
+end

data/lib/netzke/js_class_builder.rb

@@ -5,110 +5,150 @@ module Netzke
   # Most of the methods below are meant to be overwritten by a concrete widget class.
   # 
   module JsClassBuilder
-    # the JS (Ext) class that we inherit from
-    def js_base_class; "Ext.Panel"; end
-
-    # widget's actions that are loaded at the moment of instantiating a widget
-    def actions; null; end
-
-    # widget's tools that are loaded at the moment of instantiating a widget see (js_config method)
-    def tools; []; end
-    
-    def tbar; null; end
-
-    def bbar; null; end
-
-    # functions and properties that will be used to extend the functionality of (Ext) JS-class specified in js_base_class
-    def js_extend_properties; {}; end
-    
-    # code executed before and after the constructor
-    def js_before_constructor; ""; end
-    def js_after_constructor; ""; end
-
-    # widget's listeners
-    def js_listeners; {}; end
-    
-    # widget's menus
-    def js_menus; []; end
-    
-    # items
-    def js_items; null; end
-
-    # default config that is passed into the constructor
-    def js_default_config
-      {
-        :title => short_widget_class_name,
-        :listeners => js_listeners,
-        :tools => "config.tools".l,
-        :actions => "config.actions".l,
-        :tbar => "config.tbar".l,
-        :bbar => "config.bbar".l,
-        :items => js_items,
-        :height => 400,
-        :width => 800,
-        :border => false
-      }
+    def self.included(base)
+      base.extend ClassMethods
     end
 
-    # declaration of widget's class (stored directly in the cache storage at the client side to be reused at the moment of widget instantiation)
-    def js_class
-      <<-JS
-      Ext.componentCache['#{short_widget_class_name}'] = Ext.extend(#{js_base_class}, Ext.chainApply([Ext.widgetMixIn, {
-        constructor: function(config){
-          this.widgetInit(config);
-          #{js_before_constructor}
-          Ext.componentCache['#{short_widget_class_name}'].superclass.constructor.call(this, Ext.apply(#{js_default_config.to_js}, config));
-          #{js_after_constructor}
-          this.setEvents();
-          this.addMenus(#{js_menus.to_js});
-        }
-      }, #{js_extend_properties.to_js}]))
-      JS
-    end
+    #
+    # Instance methods
+    #
 
-    # generate instantiating - used when a widget is generated stand-alone (as a part of a HTML page)
-    def js_widget_instance
-      %Q(var #{config[:name].to_js} = new Ext.componentCache['#{short_widget_class_name}'](#{js_config.to_js});)
-    end
-
-    # the config that is send from the server and is used for instantiating a widget
+    # The config that is sent from the server and is used for instantiating a widget
     def js_config
       res = {}
-      
-      # recursively include configs of all (non-late) aggregatees, so that the widget can instantiate them, too
+    
+      # recursively include configs of all (non-late) aggregatees, so that the widget can instantiate them
       aggregatees.each_pair do |aggr_name, aggr_config|
         next if aggr_config[:late_aggregation]
         res["#{aggr_name}_config".to_sym] = aggregatee_instance(aggr_name.to_sym).js_config
       end
-      
+    
       # interface
-      interface = interface_points.inject({}){|h,interfacep| h.merge(interfacep => widget_action(interfacep))}
+      interface = self.class.interface_points.inject({}){|h,interfacep| h.merge(interfacep => widget_action(interfacep))}
       res.merge!(:interface => interface)
-      
+    
       res.merge!(:widget_class_name => short_widget_class_name)
 
       res.merge!(config[:ext_config])
       res.merge!(:id => @id_name)
-      
+    
       # include tools and actions
-      res.merge!(:tools => tools)
-      res.merge!(:actions => actions)
+      res.merge!(:tools => tools) if tools
+      res.merge!(:actions => actions) if actions
+      res.merge!(:bbar => tbar) if tbar
+      res.merge!(:tbar => bbar) if bbar
+
+      # include permissions
+      res.merge!(:permissions => permissions) unless available_permissions.empty?
+      
+      # include eventual region_config
+      res.merge!(:region_config => config[:region_config])
       res
     end
+   
+    # Generate instantiating - used when a widget is generated stand-alone (as a part of a HTML page)
+    def js_widget_instance
+      %Q(var #{config[:name].to_js} = new Ext.componentCache['#{short_widget_class_name}'](#{js_config.to_js});)
+    end
 
-    # class definition of the widget plus that of all the dependencies, minus those that are specified as dependencies_to_exclude
+    # All the JS-code required by this *instance* of the widget. 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 = [])
       result = ""
       dependencies.each do |dep_name|
-        dependency_class = "Netzke::#{dep_name}".constantize
-        result << dependency_class.js_class_code(cached_dependencies)
+        unless cached_dependencies.include?(dep_name)
+          dependency_class = "Netzke::#{dep_name}".constantize
+          result << dependency_class.js_class
+        end
       end
-      result << js_class.strip_js_comments unless cached_dependencies.include?(short_widget_class_name) && !config[:no_caching]
       result
     end
    
+    # widget's actions, tools and toolbars that are loaded at the moment of instantiating a widget
+    def actions; nil; end
+    def tools; nil; end
+    def tbar; nil; end
+    def bbar; nil; end
+
     # little helpers
     def this; "this".l; end
     def null; "null".l; end
+
+
+    # Methods used to create the javascript class (only once per widget class). 
+    # The generated code gets cached at the browser, and the widget intstances (at the browser side)
+    # get instantiated from it.
+    # All these methods can be overwritten in case you want to extend the functionality of some pre-built widget
+    # instead of using it as is (using both would cause JS-code duplication)
+    module ClassMethods
+      # the JS (Ext) class that we inherit from on JS-level
+      def js_base_class; "Ext.Panel"; end
+
+      # functions and properties that will be used to extend the functionality of (Ext) JS-class specified in js_base_class
+      def js_extend_properties; {}; end
+    
+      # code executed before and after the constructor
+      def js_before_constructor; ""; end
+      def js_after_constructor; ""; end
+
+      # widget's listeners
+      def js_listeners; {}; end
+    
+      # widget's menus
+      def js_menus; []; end
+    
+      # items
+      def js_items; null; end
+
+      # default config that is always passed into the constructor
+      def js_default_config
+        {
+          :title => "config.id.humanize()".l,
+          :listeners => js_listeners,
+          :tools => "config.tools".l,
+          :actions => "config.actions".l,
+          :tbar => "config.tbar".l,
+          :bbar => "config.bbar".l,
+          # :items => "config.items".l,
+          # :items => js_items,
+          :height => 400,
+          :width => 800,
+          :border => false
+        }
+      end
+
+      # Declaration of widget's class (stored in the cache storage (Ext.componentCache) at the client side 
+      # to be reused at the moment of widget instantiation)
+      def js_class
+        <<-JS
+        Ext.componentCache['#{short_widget_class_name}'] = Ext.extend(#{js_base_class}, Ext.chainApply([Ext.widgetMixIn, {
+          constructor: function(config){
+            this.widgetInit(config);
+            #{js_before_constructor}
+            Ext.componentCache['#{short_widget_class_name}'].superclass.constructor.call(this, Ext.apply(#{js_default_config.to_js}, config));
+            #{js_after_constructor}
+            this.setEvents();
+            this.addMenus(#{js_menus.to_js});
+          }
+        }, #{js_extend_properties.to_js}]))
+        JS
+      end
+
+      # class definition of the widget plus that of all the dependencies, minus those that are specified as cached_dependencies
+      def js_missing_code(cached_dependencies = [])
+        result = ""
+        dependencies.each do |dep_name|
+          dependency_class = "Netzke::#{dep_name}".constantize
+          result << dependency_class.js_class_code(cached_dependencies)
+        end
+        result << js_class.strip_js_comments unless cached_dependencies.include?(short_widget_class_name) && !config[:no_caching]
+        result
+      end
+      
+      def this; "this".l; end
+      def null; "null".l; end
+      
+    end
+   
   end
 end

data/lib/netzke-core.rb

@@ -1,6 +1,7 @@
 # NetzkeCore
 require 'netzke/js_class_builder'
 require 'netzke/base'
+require 'netzke/feedback_ghost'
 require 'netzke/action_view_ext'
 require 'netzke/controller_extensions'
 require 'netzke/core_ext'
@@ -17,19 +18,26 @@ require 'vendor/facets/hash/recursive_merge'
   ActiveSupport::Dependencies.load_once_paths.delete(path)
 end
 
-# Provide controllers with netzke_widget class method
-ActionController::Base.class_eval do
-  include Netzke::ControllerExtensions
+if defined? ActionController
+  # Provide controllers with netzke class method
+  ActionController::Base.class_eval do
+    include Netzke::ControllerExtensions
+  end
+
+  # Include the route to netzke controller
+  ActionController::Routing::RouteSet::Mapper.send :include, Netzke::Routing::MapperExtensions
 end
 
+if defined? ActionView
+  # Helpers to be put into layouts
+  ActionView::Base.send :include, Netzke::ActionViewExt
+end  
+
 # Make this plugin auto-reloaded for easier development
 ActiveSupport::Dependencies.load_once_paths.delete(File.join(File.dirname(__FILE__)))
 
 # Include the javascript
 Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/core.js"
 
-# Include the route to netzke controller
-ActionController::Routing::RouteSet::Mapper.send :include, Netzke::Routing::MapperExtensions
-
-# Helpers to be put into layouts
-ActionView::Base.send :include, Netzke::ActionViewExt
+# Include CSS
+Netzke::Base.config[:css] << "#{File.dirname(__FILE__)}/../css/core.css"

data/netzke-core.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{netzke-core}
-  s.version = "0.1.4"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Sergei Kozlov"]
-  s.date = %q{2009-01-02}
+  s.date = %q{2009-01-07}
   s.description = %q{Build ExtJS/Rails widgets with minimum effort}
   s.email = %q{sergei@writelesscode.com}
-  s.extra_rdoc_files = ["CHANGELOG", "lib/app/controllers/netzke_controller.rb", "lib/app/models/netzke_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/action_view_ext.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/js_class_builder.rb", "lib/netzke/routing.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "README.mdown", "tasks/netzke_core_tasks.rake"]
-  s.files = ["CHANGELOG", "generators/netzke_core/netzke_core_generator.rb", "generators/netzke_core/templates/create_netzke_layouts.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_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/action_view_ext.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/js_class_builder.rb", "lib/netzke/routing.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "Manifest", "netzke-core.gemspec", "Rakefile", "README.mdown", "tasks/netzke_core_tasks.rake", "test/app_root/app/controllers/application.rb", "test/app_root/config/boot.rb", "test/app_root/config/database.yml", "test/app_root/config/environment.rb", "test/app_root/config/environments/in_memory.rb", "test/app_root/config/environments/mysql.rb", "test/app_root/config/environments/postgresql.rb", "test/app_root/config/environments/sqlite.rb", "test/app_root/config/environments/sqlite3.rb", "test/app_root/config/routes.rb", "test/app_root/script/console", "test/core_ext_test.rb", "test/netzke_core_test.rb", "test/test_helper.rb", "uninstall.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "lib/app/controllers/netzke_controller.rb", "lib/app/models/netzke_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/action_view_ext.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/feedback_ghost.rb", "lib/netzke/js_class_builder.rb", "lib/netzke/routing.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "README.mdown", "tasks/netzke_core_tasks.rake"]
+  s.files = ["CHANGELOG", "css/core.css", "generators/netzke_core/netzke_core_generator.rb", "generators/netzke_core/templates/create_netzke_layouts.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_layout.rb", "lib/app/models/netzke_preference.rb", "lib/netzke/action_view_ext.rb", "lib/netzke/base.rb", "lib/netzke/controller_extensions.rb", "lib/netzke/core_ext.rb", "lib/netzke/feedback_ghost.rb", "lib/netzke/js_class_builder.rb", "lib/netzke/routing.rb", "lib/netzke-core.rb", "lib/vendor/facets/hash/recursive_merge.rb", "LICENSE", "Manifest", "netzke-core.gemspec", "Rakefile", "README.mdown", "tasks/netzke_core_tasks.rake", "test/app_root/app/controllers/application.rb", "test/app_root/config/boot.rb", "test/app_root/config/database.yml", "test/app_root/config/environment.rb", "test/app_root/config/environments/in_memory.rb", "test/app_root/config/environments/mysql.rb", "test/app_root/config/environments/postgresql.rb", "test/app_root/config/environments/sqlite.rb", "test/app_root/config/environments/sqlite3.rb", "test/app_root/config/routes.rb", "test/app_root/script/console", "test/core_ext_test.rb", "test/netzke_core_test.rb", "test/test_helper.rb", "uninstall.rb"]
   s.has_rdoc = true
   s.homepage = %q{http://writelesscode.com}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Netzke-core", "--main", "README.mdown"]

data/test/netzke_core_test.rb

@@ -13,10 +13,6 @@ module Netzke
       }
     end
   
-    # def initial_dependencies
-    #   %w{NestedWidgetOne NestedWidgetTwo DeepNestedWidget}
-    # end
-  
     def available_permissions
       %w(read update)
     end
@@ -123,11 +119,16 @@ class NetzkeCoreTest < ActiveSupport::TestCase
     assert(!widget.dependencies.include?('DeepNestedWidget'))
   end
   
-  test "dependencies in JS class generators" do
-    js_code = Widget.js_class_code
-    assert(js_code.index("Ext.componentCache['NestedWidgetOne']"))
-    assert(js_code.index("Ext.componentCache['NestedWidgetTwo']"))
-    assert(js_code.index("Ext.componentCache['DeepNestedWidget']"))
+  # test "dependencies in JS class generators" do
+  #   js_code = Widget.js_class
+  #   assert(js_code.index("Ext.componentCache['NestedWidgetOne']"))
+  #   assert(js_code.index("Ext.componentCache['NestedWidgetTwo']"))
+  #   assert(js_code.index("Ext.componentCache['DeepNestedWidget']"))
+  # end
+
+  test "widget instance by config" do
+    widget = Netzke::Base.instance_by_config({:widget_class_name => 'Widget', :name => 'a_widget'})
+    assert(Widget, widget.class)
+    assert('a_widget', widget.config[:name])
   end
-  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: netzke-core
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Sergei Kozlov
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-02 00:00:00 -06:00
+date: 2009-01-07 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,7 @@ extra_rdoc_files:
 - lib/netzke/base.rb
 - lib/netzke/controller_extensions.rb
 - lib/netzke/core_ext.rb
+- lib/netzke/feedback_ghost.rb
 - lib/netzke/js_class_builder.rb
 - lib/netzke/routing.rb
 - lib/netzke-core.rb
@@ -37,6 +38,7 @@ extra_rdoc_files:
 - tasks/netzke_core_tasks.rake
 files: 
 - CHANGELOG
+- css/core.css
 - generators/netzke_core/netzke_core_generator.rb
 - generators/netzke_core/templates/create_netzke_layouts.rb
 - generators/netzke_core/templates/create_netzke_preferences.rb
@@ -51,6 +53,7 @@ files:
 - lib/netzke/base.rb
 - lib/netzke/controller_extensions.rb
 - lib/netzke/core_ext.rb
+- lib/netzke/feedback_ghost.rb
 - lib/netzke/js_class_builder.rb
 - lib/netzke/routing.rb
 - lib/netzke-core.rb