netzke-core 0.5.5 → 0.6.0

data/lib/netzke/core_ext.rb

@@ -1,141 +1,5 @@
-class Hash
-
-  # Recursively convert the keys. Example:
-  # {:bla_bla => 1, "wow_now" => {:look_ma => true}}.deep_convert_keys{|k| k.to_s.camelize.to_sym} 
-  #   => {:BlaBla => 1, "WowNow" => {:LookMa => true}}
-  def deep_convert_keys(&block)
-    block_given? ? self.inject({}) do |h,(k,v)|
-      h[yield(k)] = v.respond_to?('deep_convert_keys') ? v.deep_convert_keys(&block) : v
-      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_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?
-        h[k] = v.respond_to?('recursive_delete_if_nil') ? v.recursive_delete_if_nil : v
-      end
-      h
-    end
-  end
-  
-  # add flatten_with_type method to Hash
-  def flatten_with_type(preffix = "")
-    res = []
-    self.each_pair do |k,v|
-      name = ((preffix.to_s.empty? ? "" : preffix.to_s + "__") + k.to_s).to_sym
-      if v.is_a?(Hash)
-        res += v.flatten_with_type(name)
-      else
-        res << {
-          :name => name, 
-          :value => v,
-          :type => (["TrueClass", "FalseClass"].include?(v.class.name) ? 'Boolean' : v.class.name).to_sym
-        }
-      end
-    end
-    res
-  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_nifty_json
-    self.recursive_delete_if_nil.jsonify.to_json
-  end
-  
-  # Applies deep_convert_keys to each element which responds to deep_convert_keys
-  def deep_convert_keys(&block)
-    block_given? ? self.map do |i|
-      i.respond_to?('deep_convert_keys') ? i.deep_convert_keys(&block) : i
-    end : self
-  end
-  
-  def recursive_delete_if_nil
-    self.map{|el| el.respond_to?('recursive_delete_if_nil') ? el.recursive_delete_if_nil : el}
-  end
-end
-
-class LiteralString < String
-  def to_json(*args)
-    self
-  end
-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 from the string and minfy it
-  def strip_js_comments
-    Netzke::Base.config[:minify_js] ? JSMin.minify(self) : self
-  end
-  
-  # "false" => false, "whatever_else" => true
-  def to_b
-    self != "false"
-  end
-end
-
-class Symbol
-  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
+require "netzke/core_ext/array"
+require "netzke/core_ext/hash"
+require "netzke/core_ext/string"
+require "netzke/core_ext/symbol"
+require "netzke/core_ext/time_with_zone"

data/lib/netzke/embedding.rb

@@ -0,0 +1,21 @@
+module Netzke
+  # The following methods are used when a component is generated stand-alone (as a part of a HTML page)
+  module Embedding
+    
+    # Instantiating
+    def js_component_instance
+      %Q{Netzke.page.#{name.jsonify} = Ext.create(#{js_config.to_nifty_json});}
+    end
+
+    # Rendering
+    def js_component_render
+      %Q{Netzke.page.#{name.jsonify}.render("#{name.to_s.split('_').join('-')}-netzke");} unless self.class.js_xtype == "netzkewindow"
+    end
+
+    # Container for rendering
+    def js_component_html
+      %Q{<div id="#{name.to_s.split('_').join('-')}-netzke" class="netzke-component"></div>}
+    end
+    
+  end
+end

data/lib/netzke/ext_component.rb

@@ -0,0 +1,25 @@
+module Netzke
+  class ExtComponent
+    attr_accessor :name
+    
+    def initialize(name, config = {})
+      @name = name
+      @config = config
+    end
+    
+    def config
+      @config ||= {}
+    end
+    
+    # Rendering
+    def js_component_render
+      %Q{Ext.ComponentMgr.create(#{config.to_nifty_json}).render("ext-#{name.to_s.split('_').join('-')}");}
+    end
+
+    # Container for rendering
+    def js_component_html
+      %Q{<div id="ext-#{name.to_s.split('_').join('-')}" class="ext-component"></div>}
+    end
+    
+  end
+end

data/lib/netzke/javascript.rb

@@ -0,0 +1,248 @@
+module Netzke
+  # == Component javascript code
+  # Here's a brief explanation on how a javascript class for a component gets built.
+  # Component gets defined as a constructor (a function) by +js_class+ class method (see "Inside component's contstructor").
+  # +Ext.extend+ provides inheritance from an Ext class specified in +js_base_class+ class method.
+  # 
+  # == Inside component's constructor
+  # * Component's constructor gets called with a parameter that is a configuration object provided by +config+ instance method. This configuration is specific for the instance of the component, and, for example, contains this component'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.
+  module Javascript
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :js_included_files
+      self.js_included_files = []
+    end
+    
+    module ClassMethods
+
+      # The JS (Ext) class that we inherit from on the JS level
+      def js_base_class(class_name = nil)
+        class_name.nil? ? (read_inheritable_attribute(:js_base_class) || "Ext.Panel") : write_inheritable_attribute(:js_base_class, class_name)
+      end
+      
+      # Definition of a public JS method, e.g.:
+      #     js_method :on_call_server, <<-JS
+      #       function(){
+      #         this.whatsUp();
+      #       }
+      #     JS
+      def js_method(name, definition = nil)
+        definition = yield.l if block_given?
+        current_js_methods = read_clean_inheritable_hash(:js_methods)
+        current_js_methods.merge!(name => definition.l)
+        write_inheritable_attribute(:js_methods, current_js_methods)
+      end
+      
+      # Returns all JS method definitions in a hash
+      def js_methods
+        read_clean_inheritable_hash(:js_methods)
+      end
+
+      # Definition of JS files which will be dynamically loaded together with this component, e.g.:
+      #     js_include "#{File.dirname(__FILE__)}/my_component/static.js"
+      # or
+      #     js_include "#{File.dirname(__FILE__)}/my_component/one.js","#{File.dirname(__FILE__)}/my_component/two.js"
+      # This is alternative to defining self.include_js
+      def js_include(*args)
+        self.js_included_files += args
+      end
+      
+      # Definition of a public JS property, e.g.:
+      #     js_property :title, "My Netzke Component"
+      def js_property(name, value = nil)
+        name = name.to_sym
+        if value.nil?
+          (read_inheritable_attribute(:js_properties) || {})[name]
+        else
+          current_js_properties = read_clean_inheritable_hash(:js_properties)
+          current_js_properties[name] = value
+          write_inheritable_attribute(:js_properties, current_js_properties)
+        end
+      end
+      
+      # Assignment of multiple public JS properties in a bunch, e.g.:
+      #     js_properties :title => "My Component", :border => true, :html => "Inner HTML"
+      def js_properties(hsh = nil)
+        if hsh.nil?
+          read_clean_inheritable_hash(:js_properties)
+        else
+          current_js_properties = read_clean_inheritable_hash(:js_properties)
+          current_js_properties.merge!(hsh)
+          write_inheritable_attribute(:js_properties, current_js_properties)
+        end
+      end
+      
+      # JS properties and methods merged together
+      def js_extend_properties
+        @_js_extend_properties ||= js_properties.merge(js_methods)
+          # res = js_properties.merge(js_methods)
+          # extracted_actions = extract_actions(res)
+          # res.merge!(:actions => extracted_actions) if !extracted_actions.empty?
+          # res
+        # end
+      end
+      
+      # TODO: the code below needs refactoring and cleaning-up
+      
+      # component's menus
+      # def js_menus; []; end
+
+      # Given class name, e.g. GridPanelLib::Components::RecordFormWindow, 
+      # returns its scope: "Components.RecordFormWindow"
+      def js_class_name_to_scope(name)
+        name.split("::")[0..-2].join(".")
+      end
+
+      # Top level scope which will be used to scope out Netzke classes
+      def js_default_scope
+        "Netzke.classes"
+      end
+
+      # Scope of this component without default scope
+      # e.g.: GridPanelLib.Components
+      def js_scope
+        js_class_name_to_scope(short_component_class_name)
+      end
+
+      # Returns the scope of this component
+      # e.g. "Netzke.classes.GridPanelLib"
+      def js_full_scope
+        js_scope.empty? ? js_default_scope : [js_default_scope, js_scope].join(".")
+      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
+        [js_full_scope, short_component_class_name.split("::").last].join(".")
+      end
+
+      # Builds this component's xtype
+      # E.g.: netzkewindow, netzkegridpanel
+      def js_xtype
+        name.gsub("::", "").downcase
+      end
+
+      # are we using JS inheritance? for now, if js_base_class is a Netzke class - yes
+      def extends_netzke_component?
+        superclass != Netzke::Base
+      end
+
+      # Declaration of component's class (stored in the cache storage (Ext.netzke.cache) at the client side 
+      # to be reused at the moment of component instantiation)
+      def js_class(cached = [])
+        res = []
+        # Defining the scope if it isn't known yet
+        res << %{Ext.ns("#{js_full_scope}");} unless js_full_scope == js_default_scope
+
+        res << (extends_netzke_component? ? js_class_declaration_extending_component : js_class_declaration_new_component)
+
+        res << %(Ext.reg("#{js_xtype}", #{js_full_class_name});)
+
+        res.join("\n")
+      end
+      
+      
+      def js_extra_code
+        ""
+      end
+      
+      # Generates declaration of the JS class as direct extension of a Ext component
+      def js_class_declaration_new_component
+        %(#{js_full_class_name} = Ext.extend(#{js_base_class}, Ext.apply(Netzke.componentMixin(#{js_base_class}),
+#{js_extend_properties.to_nifty_json}));)
+      end
+      
+      # Generates declaration of the JS class as extension of another Netzke component
+      def js_class_declaration_extending_component
+        base_class = superclass.js_full_class_name
+
+        # Do we specify our own extend properties? 
+        # If so, include them, if not - don't re-include those from the parent.
+        js_extend_properties.empty? ? \
+        %{#{js_full_class_name} = #{base_class};} :
+        %{#{js_full_class_name} = Ext.extend(#{base_class}, #{js_extend_properties.to_nifty_json});}
+      end
+      
+      # Returns all extra JavaScript-code (as string) required by this component's class
+      def js_included
+        res = ""
+
+        # Prevent re-including code that was already included by the parent
+        # (thus, only include those JS files when include_js was defined in the current class, not in its ancestors)
+        ((singleton_methods(false).map(&:to_sym).include?(:include_js) ? include_js : []) + js_included_files).each do |path|
+          f = File.new(path)
+          res << f.read << "\n"
+        end
+        
+        res
+      end
+
+      def include_js
+        []
+      end
+
+      # JavaScript code needed for this particulaer class. Includes external JS code and the JS class definition for self.
+      def js_code(cached = [])
+        [js_included, js_class(cached)].join("\n")
+      end
+      
+      # Little helper
+      def this; "this".l; end
+
+      # Little helper
+      def null; "null".l; end
+
+    end
+    
+    module InstanceMethods
+      # Config that is used for instantiating the component in javascript
+      def js_config
+        res = {}
+
+        # Unique id of the component
+        res.merge!(:id => global_id)
+
+        # Non-late components
+        comp_hash = {}
+        non_late_components.each_pair do |comp_name, comp_config|
+          comp_instance = component_instance(comp_name.to_sym)
+          comp_instance.before_load
+          comp_hash[comp_name] = comp_instance.js_config
+        end
+        
+        # All our non-lazy-loaded children are specified here, while in +items+ we barely reference them, because
+        # +items+, generally, only contain a subset of all non-lazy-loaded children.
+        res[:components] = comp_hash unless comp_hash.empty?
+
+        # Api (besides the default "deliver_component" - JavaScript side already knows about it)
+        endpoints = self.class.endpoints - [:deliver_component]
+        res.merge!(:endpoints => endpoints) unless endpoints.empty?
+
+        # Inform the JavaScript side if persistent_config is enabled
+        # res[:persistent_config] = persistence_enabled?
+
+        # Include our xtype
+        res[:xtype] = self.class.js_xtype
+
+        # Merge with the rest of config options, besides those that are only meant for the server side
+        res.merge!(config.reject{ |k,v| self.class.server_side_config_options.include?(k.to_sym) })
+        
+        res[:items] = items unless items.blank?
+        
+        res
+      end
+
+      # All the JS-code required by this instance of the component to be instantiated in the browser.
+      # It includes JS-classes for the parents, non-lazy-loaded child components, and itself.
+      def js_missing_code(cached = [])
+        code = dependency_classes.inject("") do |r,k| 
+          cached.include?(k.to_s) ? r : r + k.js_code(cached)#.strip_js_comments
+        end
+        code.blank? ? nil : code
+      end
+      
+    end
+  end
+end

data/lib/netzke/persistence.rb

@@ -0,0 +1,118 @@
+module Netzke
+  # TODO: 
+  # rename persistence_ to persistence_
+  module Persistence
+    
+    module ClassMethods
+      # Persistent config manager class
+      def persistence_manager_class
+        Netzke::Base.persistence_manager.try(:constantize)
+      rescue NameError
+        nil
+      end
+
+    end
+  
+    module InstanceMethods
+      
+      # If the component has persistent config in its disposal
+      def persistence_enabled?
+        !persistence_manager_class.nil? && initial_config[:persistent_config]
+      end
+      
+      # Access to own persistent config, e.g.:
+      #     persistent_config["window.size"] = 100
+      #     persistent_config["window.size"] => 100
+      # This method is user/role-aware
+      # def persistent_config
+      #   if persistence_enabled?
+      #     config_class = self.class.persistence_manager_class
+      #     config_class.component_name = persistence_key.to_s # pass to the config class our unique name
+      #     config_class
+      #   else
+      #     # if we can't use presistent config, all the calls to it will always return nil, 
+      #     # and the "="-operation will be ignored
+      #     logger.debug "==> NETZKE: no persistent config is set up for component '#{global_id}'"
+      #     {}
+      #   end
+      # end
+
+      # Access to the global persistent config (e.g. of another component)
+      def global_persistent_config(owner = nil)
+        config_class = self.class.persistence_manager_class
+        config_class.component_name = owner
+        config_class
+      end
+
+      # A string which will identify NetzkePreference records for this component. 
+      # If <tt>persistence_key</tt> is passed, use it. Otherwise use global component's id.
+      def persistence_key #:nodoc:
+        # initial_config[:persistence_key] ? parent.try(:persistence_key) ? "#{parent.persistence_key}__#{initial_config[:persistence_key]}".to_sym : initial_config[:persistence_key] : global_id.to_sym
+        initial_config[:persistence_key] ? initial_config[:persistence_key] : global_id.to_sym
+      end
+
+      # def update_persistent_ext_config(hsh)
+      #   current_config = persistent_config[:ext_config] || {}
+      #   current_config.deep_merge!(hsh.deep_convert_keys{ |k| k.to_s }) # first, recursively stringify the keys
+      #   persistent_config[:ext_config] = current_config
+      # end
+      
+      # Returns a hash built from all persistent config values for the current component, following the double underscore
+      # naming convention. E.g., if we have the following persistent config pairs:
+      #     enabled  => true
+      #     layout__width => 100
+      #     layout__header__height => 20
+      # 
+      # this method will return the following hash:
+      #     {:enabled => true, :layout => {:width => 100, :header => {:height => 20}}}
+      # def persistence_hash_OLD
+      #   return {} if !persistence_enabled?
+      #   
+      #   @persistence_hash ||= begin
+      #     prefs = NetzkePreference.find_all_for_component(persistence_key.to_s)
+      #     res = {}
+      #     prefs.each do |p|
+      #       hsh_levels = p.name.split("__").map(&:to_sym)
+      #       tmp_res = {} # it decends into itself, building itself
+      #       anchor = {} # it will keep the tail of tmp_res
+      #       hsh_levels.each do |level_prefix|
+      #         tmp_res[level_prefix] ||= level_prefix == hsh_levels.last ? p.normalized_value : {}
+      #         anchor = tmp_res[level_prefix] if level_prefix == hsh_levels.first
+      #         tmp_res = tmp_res[level_prefix]
+      #       end
+      #       # Now 'anchor' is a hash that represents the path to the single value, 
+      #       # for example: {:ext_config => {:title => 100}} (which corresponds to ext_config__title)
+      #       # So we need to recursively merge it into the final result
+      #       res.deep_merge!(hsh_levels.first => anchor)
+      #     end
+      #     res.deep_convert_keys{ |k| k.to_sym } # recursively symbolize the keys
+      #   end
+      # end
+      
+      def update_persistent_options(hash)
+        if persistence_enabled?
+          options = persistent_options
+          persistence_manager_class.pref_to_write(global_id).update_attribute(:value, options.deep_merge(hash))
+        else
+          logger && logger.debug("Netzke warning: No persistence enabled for component '#{global_id}'")
+        end
+      end
+      
+      def persistent_options
+        return {} if !persistence_enabled?
+        persistence_manager_class.pref_to_read(global_id).try(:value) || {}
+      end
+      
+      # A convenience method for instances
+      def persistence_manager_class
+        self.class.persistence_manager_class
+      end
+      
+    end
+  
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end

data/lib/netzke/rails/action_view_ext.rb

@@ -0,0 +1,103 @@
+module Netzke
+  module ActionViewExt
+    # Include JavaScript
+    def netzke_js_include
+      res = []
+      
+      # ExtJS
+      res << (ENV['RAILS_ENV'] == 'development' ? javascript_include_tag("/extjs/adapter/ext/ext-base-debug", "/extjs/ext-all-debug") : javascript_include_tag("/extjs/adapter/ext/ext-base", "/extjs/ext-all"))
+      
+      # Netzke (dynamically generated)
+      res << javascript_include_tag("/netzke/netzke")
+      res.join("\n")
+    end
+
+    # Include CSS
+    def netzke_css_include(theme_name = "default")
+      # ExtJS base
+      res = stylesheet_link_tag("/extjs/resources/css/ext-all")
+      # ExtJS theming
+      res << "\n" << stylesheet_link_tag("/extjs/resources/css/xtheme-#{theme_name}") unless theme_name.to_s == "default"
+      # Netzke (dynamically generated)
+      res << "\n" << stylesheet_link_tag("/netzke/netzke")
+      
+      # External stylesheets (which cannot be loaded dynamically along with the rest of the component, e.g. due to that 
+      # relative paths are used in them)
+      res << "\n" << stylesheet_link_tag(Netzke::Core.external_css)
+      
+      res
+    end
+    
+    # JavaScript for all Netzke classes in this view, and Ext.onReady which renders all Netzke components in this view
+    def netzke_js
+      res = []
+      if Netzke::Core.javascript_on_main_page
+        res << content_for(:netzke_js_classes)
+        res << "\n"
+      end
+      res << "Ext.onReady(function(){"
+      res << content_for(:netzke_on_ready)
+      res << "});"
+      
+      javascript_tag res.join("\n")
+    end
+    
+    def netzke_css
+      %{
+<style type="text/css" media="screen">
+  #{content_for(:netzke_css)}
+</style>}
+    end
+    
+    # Wrapper for all the above. Use it in your layout.
+    # Params: <tt>:ext_theme</tt> - the name of ExtJS theme to apply (optional)
+    # E.g.:
+    #   <%= netzke_init :ext_theme => "grey" %>
+    def netzke_init(params = {})
+      theme = params[:ext_theme] || :default
+      raw([netzke_css_include(theme), netzke_css, netzke_js_include, netzke_js].join("\n"))
+    end
+    
+    # Use this helper in your views to embed Netzke components. E.g.:
+    #   netzke :my_grid, :class_name => "Basepack::GridPanel", :columns => [:id, :name, :created_at]
+    # On how to configure a component, see documentation for Netzke::Base or/and specific component
+    def netzke(name, config = {})
+      @rendered_classes ||= []
+      
+      # if we are the first netzke call on the page, reset components hash in the session
+      if @rendered_classes.empty?
+        Netzke::Core.reset_components_in_session
+      end
+      
+      class_name = config[:class_name] ||= name.to_s.camelcase
+      
+      config[:name] = name
+      
+      Netzke::Core.reg_component(config)
+      
+      w = Netzke::Base.instance_by_config(config)
+      w.before_load # inform the component about initial load
+      
+      if Netzke::Core.javascript_on_main_page
+        content_for :netzke_js_classes, raw(w.js_missing_code(@rendered_classes))
+      end
+      
+      content_for :netzke_css, raw(w.css_missing_code(@rendered_classes))
+      
+      content_for :netzke_on_ready, raw("#{w.js_component_instance}\n\n#{w.js_component_render}")
+      
+      # Now mark this component's class as rendered, so that we only generate it once per view
+      @rendered_classes << class_name unless @rendered_classes.include?(class_name)
+
+      # Return the html for this component
+      raw(w.js_component_html)
+    end
+    
+    def ext(name, config = {})
+      comp = Netzke::ExtComponent.new(name, config)
+      content_for :netzke_on_ready, raw("#{comp.js_component_render}")
+      raw(comp.js_component_html)
+    end
+  end
+end
+

data/lib/netzke/{controller_extensions.rb → rails/controller_extensions.rb}

@@ -2,12 +2,13 @@ module Netzke
   module ControllerExtensions
     def self.included(base)
       base.send(:before_filter, :set_session_data)
+      base.send(:before_filter, :set_controller)
     end
     
     def set_session_data
-      Netzke::Base.session = session
+      ::Netzke::Core.session = session
       session[:netzke_user_id] = defined?(current_user) ? current_user.try(:id) : nil
-      # set netzke_just_logged_in and netzke_just_logged_out states (may be used by Netzke widgets)
+      # set netzke_just_logged_in and netzke_just_logged_out states (may be used by Netzke components)
       if session[:_netzke_next_request_is_first_after_login]
         session[:netzke_just_logged_in] = true
         session[:_netzke_next_request_is_first_after_login] = false
@@ -22,5 +23,9 @@ module Netzke
         session[:netzke_just_logged_out] = false
       end
     end
+
+    def set_controller
+       ::Netzke::Core.controller = self
+    end
   end
 end

data/lib/netzke/rails/routes.rb

@@ -0,0 +1,7 @@
+module ActionDispatch::Routing
+  class Mapper
+    def netzke
+      match "/netzke/:action(.:format)" => "netzke"      
+    end
+  end
+end