skozlov-netzke-core 0.1.0.2 → 0.4.1

data/lib/netzke/base_js.rb

@@ -0,0 +1,258 @@
+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)
+      res.merge!(:api => self.class.api_points.reject{ |p| p == :load_aggregatee_with_cache })
+  
+      # 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
+      
+      def css_include(*args)
+        included_css = read_inheritable_attribute(:included_css) || []
+        args.each do |inclusion|
+          if inclusion.is_a?(Hash)
+            # we are signalized a non-default file location (e.g. Ext examples)
+            case inclusion.keys.first
+            when :ext_examples
+              location = Netzke::Base.config[:ext_location] + "/examples/"
+            end
+            files = inclusion.values.first
+          else
+            location = ""
+            files = inclusion
+          end
+          
+          files = [files] if files.is_a?(String)
+          
+          for f in files
+            included_css << location + f
+          end
+        end
+        write_inheritable_attribute(:included_css, included_css)
+      end
+
+      # all JS 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
+
+
+      # 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 js-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
+
+      
+      # returns all extra js-code (as string) required by this widget's class
+      def css_included
+        res = ""
+        
+        included_css = read_inheritable_attribute(:included_css) || []
+        res << included_css.inject("") do |r, path|
+          f = File.new(path)
+          r << f.read
+        end
+
+        res
+      end
+      
+      # all JS 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
+
+      def this; "this".l; end
+      def null; "null".l; end
+    
+    end
+  end
+end

data/lib/netzke/controller_extensions.rb

@@ -2,6 +2,29 @@ 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
+
+      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]
+        session[:netzke_just_logged_in] = true
+        session[:_netzke_next_request_is_first_after_login] = false
+      else
+        session[:netzke_just_logged_in] = false
+      end
+
+      if session[:_netzke_next_request_is_first_after_logout]
+        session[:netzke_just_logged_out] = true
+        session[:_netzke_next_request_is_first_after_logout] = false
+      else
+        session[:netzke_just_logged_out] = false
+      end
     end
     
     def method_missing(method_name)
@@ -12,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
@@ -31,12 +57,13 @@ module Netzke
       # 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_widget(name, config={})
+      def netzke(name, config={})
         # which module is the widget?
         config[:widget_class_name] ||= name.to_s.classify
         config[:name] ||= name
@@ -46,39 +73,63 @@ 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
-            config = controller.class.widget_config_storage[:#{name}]
-            Netzke::#{config[:widget_class_name]}.new(config).js_missing_code
+            @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
-          render :inline => %Q(
-          <script type="text/javascript" charset="utf-8">
-          <%= #{name}_class_definition %>
-          Ext.onReady(function(){
-          	<%= #{name}_widget_instance %>
-          	#{name.to_js}.render("#{name.to_s.split('_').join('-')}");
-          })
-        	</script>
-          <div id="#{name.to_s.split('_').join('-')}"></div>
-          ), :layout => "netzke"
+          @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

data/lib/netzke/core_ext.rb

@@ -9,18 +9,29 @@ 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.delete_if{ |k,v| v.nil? } # we don't need to explicitely pass null values to javascript
-    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)|
       if !v.nil?
@@ -29,13 +40,29 @@ class Hash
       h
     end
   end
+
+  # Javascrit-like access to Hash values
+  def method_missing(method, *args)
+    if method.to_s =~ /=$/ 
+      method_base = method.to_s.sub(/=$/,'').to_sym
+      key = self[method_base.to_s].nil? ? method_base : method_base.to_s
+      self[key] = args.first
+    else
+      key = self[method.to_s].nil? ? method : method.to_s
+      self[key]
+    end
+  end
   
 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
@@ -50,28 +77,52 @@ 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
-      self
-    end
+class LiteralString < String
+  def to_json(*args)
     self
   end
-  
-  def to_js
+end
+
+class String
+  def jsonify
     self.camelize(:lower)
   end
   
-  # removes JS-comments (both single-line and multiple-line) from the string
+  # 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:\/\*.*?\*\/)/
-    self.gsub(regexp, '')
+    self.gsub!(regexp, '')
+
+    # also remove empty lines
+    regexp = /^\s*\n/
+    self.gsub!(regexp, '')
+  end
+  
+  # "false" => false, "whatever_else" => true
+  def to_b
+    self != "false"
   end
 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
+  class TimeWithZone
+    def to_json(options = {})
+      self.to_s(:db).to_json
+    end
+  end
 end