netzke-core 0.3.1 → 0.4.2

data/lib/netzke/base_js.rb

@@ -0,0 +1,249 @@
+module Netzke
+  # == BaseJs
+  # *TODO: outdated*
+  # 
+  # Module which provides JS-class generation functionality for the widgets ("client-side"). The generated code 
+  # is evaluated once per widget class, and the results are cached in the browser. Included into Netzke::Base class.
+  # 
+  # == Widget javascript code
+  # Here's a brief explanation on how a javascript class for a widget gets built.
+  # Widget gets defined as a constructor (a function) by +js_class+ class method (see "Inside widget's contstructor").
+  # +Ext.extend+ provides inheritance from an Ext class specified in +js_base_class+ class method.
+  # 
+  # == Inside widget's constructor
+  # * Widget's constructor gets called with a parameter that is a configuration object provided by +js_config+ instance method. This configuration is specific for the instance of the widget, and, for example, contains this widget's unique id. As another example, by means of this configuration object, a grid receives the configuration array for its columns, a form - for its fields, etc. With other words, everything that may change from instance to instance of the same widget's class, goes in here.
+  # * Widget executes its specific initialization code which is provided by +js_before_consttructor+ class method. 
+  # For example, a grid may define its column model, a form - its fields, a tab panel - its tabs ("items").
+  # * Widget calls the constructor of the inherited class (see +js_class+ class method) with a parameter that is a merge of 
+  # 1) configuration parameter passed to the widget's constructor.
+  module BaseJs
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    #
+    # Instance methods
+    #
+
+    # Config that is used for instantiating the widget in javascript
+    def js_config
+      res = {}
+      
+      # Unique id of the widget
+      res.merge!(:id => id_name)
+  
+      # Recursively include configs of all non-late aggregatees, so that the widget can instantiate them
+      # in javascript immediately.
+      non_late_aggregatees.each_pair do |aggr_name, aggr_config|
+        aggr_instance = aggregatee_instance(aggr_name.to_sym)
+        aggr_instance.before_load
+        res["#{aggr_name}_config".to_sym] = aggr_instance.js_config
+      end
+  
+      # Api (besides the default "load_aggregatee_with_cache" - JavaScript side already knows about it)
+      api_points = self.class.api_points.reject{ |p| p == :load_aggregatee_with_cache }
+      res.merge!(: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)
+      
+      # Actions, toolbars and menus
+      # tools   && res.merge!(:tools   => tools)
+      actions && res.merge!(:actions => actions)
+      menu    && res.merge!(:menu    => menu)
+
+      # Merge with all config options passed as hash to config[:ext_config]
+      res.merge!(ext_config)
+  
+      res
+    end
+  
+    # 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 = [])
+      code = dependency_classes.inject("") do |r,k| 
+        cached_dependencies.include?(k) ? r : r + "Netzke::#{k}".constantize.js_code(cached_dependencies).strip_js_comments
+      end
+      code.blank? ? nil : code
+    end
+    
+    def css_missing_code(cached_dependencies = [])
+      code = dependency_classes.inject("") do |r,k| 
+        cached_dependencies.include?(k) ? r : r + "Netzke::#{k}".constantize.css_code(cached_dependencies)
+      end
+      code.blank? ? nil : code
+    end
+  
+    #
+    # The following methods are used when a widget is generated stand-alone (as a part of a HTML page)
+    #
+
+    # instantiating
+    def js_widget_instance
+      %Q{var #{name.jsonify} = new Ext.netzke.cache.#{short_widget_class_name}(#{js_config.to_nifty_json});}
+    end
+
+    # rendering
+    def js_widget_render
+      %Q{#{name.jsonify}.render("#{name.to_s.split('_').join('-')}");}
+    end
+
+    # container for rendering
+    def js_widget_html
+      %Q{<div id="#{name.to_s.split('_').join('-')}"></div>}
+    end
+
+    #
+    #
+    #
+ 
+    # Widget's actions, tools and menus that are loaded at the moment of instantiation
+    def actions; nil; end
+    def menu; nil; end
+    # def tools; 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
+  
+      # widget's menus
+      def js_menus; []; end
+  
+      # items
+      # def js_items; null; end
+      
+      # are we using JS inheritance? for now, if js_base_class is a Netzke class - yes
+      def js_inheritance?
+        superclass != Netzke::Base
+      end
+
+      # 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
+        if js_inheritance?
+          # In case of using javascript inheritance, little needs to be done
+          <<-END_OF_JAVASCRIPT
+          // Create the class
+          Ext.netzke.cache.#{short_widget_class_name} = function(config){
+            Ext.netzke.cache.#{short_widget_class_name}.superclass.constructor.call(this, config);
+          };
+          // Extend it with the class that we inherit from, and mix in js_extend_properties
+          Ext.extend(Ext.netzke.cache.#{short_widget_class_name}, Ext.netzke.cache.#{superclass.short_widget_class_name}, Ext.applyIf(#{js_extend_properties.to_nifty_json}, Ext.widgetMixIn));
+          END_OF_JAVASCRIPT
+        else
+          js_add_menus = "this.addMenus(#{js_menus.to_nifty_json});" unless js_menus.empty?
+          <<-END_OF_JAVASCRIPT
+          // Constructor
+          Ext.netzke.cache.#{short_widget_class_name} = function(config){
+            // Do all the initializations that every Netzke widget should do: create methods for API-points,
+            // process actions, tools, toolbars
+            this.commonBeforeConstructor(config);
+            
+            // Call the constructor of the inherited class
+            Ext.netzke.cache.#{short_widget_class_name}.superclass.constructor.call(this, config);
+
+            // What every widget should do after calling the constructor of the inherited class, like
+            // setting extra events
+            this.commonAfterConstructor(config);
+          };
+          Ext.extend(Ext.netzke.cache.#{short_widget_class_name}, #{js_base_class}, Ext.applyIf(#{js_extend_properties.to_nifty_json}, Ext.widgetMixIn));
+          END_OF_JAVASCRIPT
+        end
+      end
+      
+      #
+      # Extra JavaScript
+      # 
+      
+      # 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
+      
+      # Returns all extra JavaScript-code (as string) required by this widget's class
+      def js_included
+        res = ""
+
+        include_js.each do |path|
+          f = File.new(path)
+          res << f.read << "\n"
+        end
+
+        res
+      end
+      
+      # All JavaScript code needed for this class, including one from the ancestor widget
+      def js_code(cached_dependencies = [])
+        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)
+
+        # include static javascripts
+        res << js_included << "\n"
+
+        # our own JS class definition
+        res << js_class
+        res
+      end
+
+      #
+      # Extra CSS
+      # 
+
+      # Override this method. Must return an array of paths to css files that we depend on. 
+      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|
+          f = File.new(path)
+          res << f.read << "\n"
+        end
+
+        res
+      end
+      
+      # All CSS code needed for this class including the one from the ancestor widget
+      def css_code(cached_dependencies = [])
+        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 << css_included << "\n"
+        
+        res
+      end
+
+      
+      # Little helper
+      def this; "this".l; end
+
+      # Little helper
+      def null; "null".l; end
+    
+    end
+  end
+end

data/lib/netzke/controller_extensions.rb

@@ -7,9 +7,9 @@ module Netzke
     
     def set_session_data
       Netzke::Base.session = session
-      session[:user] = defined?(current_user) ? current_user : nil
+      session[:netzke_user_id] = defined?(current_user) ? current_user.try(:id) : nil
 
-      Netzke::Base.user = session[:user] # for backward compatibility (TODO: eliminate the need for this)
+      Netzke::Base.user = current_user # for backward compatibility (TODO: eliminate the need for this)
       
       # 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]
@@ -35,16 +35,19 @@ module Netzke
         widget = widget.to_sym
         action = !action.empty? && action.join("__").to_sym
       
-        # only widget's actions starting with "interface_" are accessible from outside (security)
+        # only widget's actions starting with "api_" are accessible from outside (security)
         if action
-          interface_action = action.to_s.index('__') ? action : "interface_#{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].merge(:controller => self)) # OPTIMIZE: top-level widgets have access to the controller - can we avoid that?
-          render :text => widget_instance.send(interface_action, params)
+          widget_instance = widget_class.new(self.class.widget_config_storage[widget])
+          # (OLD VERSION)
+          # widget_instance = widget_class.new(self.class.widget_config_storage[widget].merge(:controller => self)) # OPTIMIZE: top-level widgets have access to the controller - can we avoid that?
+          
+          render :text => widget_instance.send(api_action, params)
         end
       end
     end
@@ -54,6 +57,7 @@ module Netzke
       # widget_config_storage for all widgets
       def widget_config_storage
         @@widget_config_storage ||= {}
+        @@widget_config_storage[self.name] ||= {} # specific for controller
       end
     
       #
@@ -69,53 +73,38 @@ module Netzke
 
         # 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 = {})
-            # get the global config from the controller's singleton class
-            global_config = controller.class.widget_config_storage[:#{name}]
-
-            # when instantiating a client side instance, the configuration may be overwritten 
-            # (but the server side will know nothing about it!)
-            local_config = global_config.merge(config)
-
-            # instantiate it
-            widget_instance = Netzke::#{config[:widget_class_name]}.new(local_config)
-          
-            # return javascript code for instantiating on the javascript level
-            widget_instance.js_widget_instance
+            #{name}_server_instance(config).js_widget_instance
           end
           
-          def #{name}_class_definition_old
-            result = ""
-            config = controller.class.widget_config_storage[:#{name}]
-            @generated_widget_classes ||= []
-            # do not duplicate javascript code on the same page
-            unless @generated_widget_classes.include?("#{config[:widget_class_name]}")
-              @generated_widget_classes << "#{config[:widget_class_name]}"
-              result = Netzke::#{config[:widget_class_name]}.js_class_code
-            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
+            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
-            config = controller.class.widget_config_storage[:#{name}]
-            widget_instance = Netzke::Base.instance_by_config(config)
-            widget_instance.js_widget_html
+            #{name}_server_instance.js_widget_html
           end
           
           def #{name}_widget_render
-            config = controller.class.widget_config_storage[:#{name}]
-            widget_instance = Netzke::Base.instance_by_config(config)
-            widget_instance.js_widget_render
+            #{name}_server_instance.js_widget_render
           end
           
         END_EVAL

data/lib/netzke/core_ext.rb

@@ -9,17 +9,28 @@ class Hash
       h
     end : self
   end
+
+  def jsonify
+    self.inject({}) do |h,(k,v)|
+      new_key = k.instance_of?(String) || k.instance_of?(Symbol) ? k.jsonify : k
+      new_value = v.instance_of?(Array) || v.instance_of?(Hash) ? v.jsonify : v
+      h.merge(new_key => new_value)
+    end
+  end
   
   # First camelizes the keys, then convert the whole hash to JSON
-  def to_js
-    self.recursive_delete_if_nil.convert_keys{|k| k.camelize(:lower)}.to_json
-  end
-
-  # Converts values to strings
-  def stringify_values!
-    self.each_pair{|k,v| self[k] = v.to_s if v.is_a?(Symbol)}
+  def to_nifty_json
+    self.recursive_delete_if_nil.jsonify.to_json
   end
   
+  # Converts values of a Hash in such a way that they can be easily stored in the database: hashes and arrays are jsonified, symbols - stringified
+  def deebeefy_values
+    inject({}) do |options, (k, v)|
+      options[k] = v.is_a?(Symbol) ? v.to_s : (v.is_a?(Hash) || v.is_a?(Array)) ? v.to_json : v
+      options
+    end
+  end
+
   # We don't need to pass null values in JSON, they are null by simply being absent
   def recursive_delete_if_nil
     self.inject({}) do |h,(k,v)|
@@ -45,9 +56,13 @@ class Hash
 end
 
 class Array
+  def jsonify
+    self.map{ |el| el.instance_of?(Array) || el.instance_of?(Hash) ? el.jsonify : el }
+  end
+  
   # Camelizes the keys of hashes and converts them to JSON
-  def to_js
-    self.recursive_delete_if_nil.map{|el| el.is_a?(Hash) ? el.convert_keys{|k| k.camelize(:lower)} : el}.to_json
+  def to_nifty_json
+    self.recursive_delete_if_nil.jsonify.to_json
   end
   
   # Applies convert_keys to each element which responds to convert_keys
@@ -62,19 +77,22 @@ class Array
   end
 end
 
-class String
-  # Converts self to "literal JSON"-string - one that doesn't get quotes appended when being sent "to_json" method
-  def l
-    def self.to_json(options={})
-      self
-    end
+class LiteralString < String
+  def to_json(*args)
     self
   end
-  
-  def to_js
+end
+
+class String
+  def jsonify
     self.camelize(:lower)
   end
   
+  # Converts self to "literal JSON"-string - one that doesn't get quotes appended when being sent "to_json" method
+  def l
+    LiteralString.new(self)
+  end
+  
   # removes JS-comments (both single- and multi-line) from the string
   def strip_js_comments
     regexp = /\/\/.*$|(?m:\/\*.*?\*\/)/
@@ -92,9 +110,13 @@ class String
 end
 
 class Symbol
-  def to_js
+  def jsonify
     self.to_s.camelize(:lower).to_sym
   end
+  
+  def l
+    LiteralString.new(self.to_s)
+  end
 end
 
 module ActiveSupport