netzke-core 0.8.1 → 0.8.2

data/lib/netzke/core/config_to_dsl_delegator.rb

@@ -33,13 +33,6 @@ module Netzke::Core
 
       class_attribute :delegated_defaults
       self.delegated_defaults = {}
-
-      delegated_options.each do |property|
-        inherited_class.class.send(:define_method, property, lambda { |value|
-          self.delegated_defaults = self.delegated_defaults.dup if self.superclass.respond_to?(:delegated_defaults) && self.delegated_defaults == self.superclass.delegated_defaults
-          self.delegated_defaults[property.to_sym] = value
-        })
-      end
     end
 
     def configure(c)

data/lib/netzke/core/configuration.rb

@@ -59,5 +59,53 @@ module Netzke::Core
     def config
       @config ||= ActiveSupport::OrderedOptions.new
     end
+
+
+  protected
+
+    # During the normalization of config object, +extend_item+ is being called with each item found (recursively) in there.
+    # For example, symbols representing nested child components get replaced with a proper config hash, same goes for actions (see +Composition+ and +Actions+ respectively).
+    # Override to do any additional checks/enhancements. See, for example, +Netzke::Basepack::WrapLazyLoaded+ or +Netzke::Basepack::Fields+.
+    # @return [Object|nil] normalized item or nil. If nil is returned, this item will be excluded from the config.
+    def extend_item(item)
+      item.is_a?(Hash) && item[:excluded] ? nil : item
+    end
+
+    # Used for detecting actions and components referred by symbols. For example, say, action +do_something+ is declared. Then:
+    #
+    #     item #=> :do_something
+    #     item = detect_and_normalize :action, item
+    #     item #=> {netzke_action: :do_something, text: 'Do it'} # uses action declaration
+    def detect_and_normalize(thing, item)
+      if item.is_a?(Symbol) && thing_config = send(thing.to_s.pluralize)[item]
+        item = {:"netzke_#{thing}" => item, excluded: thing_config[:excluded]}
+      elsif item.is_a?(Hash)
+        # replace `action` key with `netzke_action`, which will be looked for at the JS side
+        item[:"netzke_#{thing}"] = item.delete(thing) if item[thing]
+      end
+      item
+    end
+
+    # We'll build a couple of useful instance variables here:
+    #
+    # +components_in_config+ - an array of components (by name) referred in items
+    # +normalized_config+ - a config that has all the config extensions applied
+    def normalize_config
+      @components_in_config = []
+      c = config.dup
+      config.each_pair do |k, v|
+        c.delete(k) if self.class.server_side_config_options.include?(k.to_sym)
+        if v.is_a?(Array)
+          c[k] = v.netzke_deep_map{|el| extend_item(el)}
+        end
+      end
+      @normalized_config = c
+    end
+
+    # @return [Hash] config with all placeholders (like child components referred by symbols) expanded
+    def normalized_config
+      # make sure we call normalize_config first
+      @normalized_config || (normalize_config || true) && @normalized_config
+    end
   end
 end

data/lib/netzke/core/dsl_support.rb

@@ -0,0 +1,71 @@
+module Netzke
+  module Core
+    module DslSupport
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # It's the easiest to be explained by an example:
+        #
+        #     declare_dsl_for :components
+        #
+        # This creates:
+        #
+        # 1) DSL method `component` for declaration of child component in a given class, e.g.:
+        #
+        #     component :simple_panel do |c|
+        #       # ...
+        #     end
+        #
+        # Each call to the created `component` method results in an instance method:
+        #
+        #     def simple_panel_component(c)
+        #       # ...
+        #     end
+        #
+        # 2) Instance method `components` that returns a hash of all components configs. This hash is built by passing a new instance of `Netzke::Core::ComponentConfig` to each of the methods described in 1). Presence of `Netzke::Core::ComponentConfig` is assumed.
+        #
+        # Besides components, this method is being used in Core for DSL for actions.
+        def declare_dsl_for(things)
+          things = things.to_s
+          storage_attribute = :"_declared_#{things}"
+
+          class_attribute storage_attribute
+          send("#{storage_attribute}=", [])
+
+          define_dsl_method(things, storage_attribute)
+          define_collector_method(things, storage_attribute)
+        end
+
+
+        def define_dsl_method(things, storage_attribute)
+          thing = things.singularize
+
+          define_singleton_method thing do |name, &block|
+            self.send("#{storage_attribute}=", self.send(storage_attribute) | [name])
+            method_name = "#{name}_#{thing}"
+            define_method(method_name, &(block || ->(c){c}))
+          end
+        end
+
+        def define_collector_method(things, storage_attribute)
+          thing = things.singularize
+          config_class = "Netzke::Core::#{thing.camelcase}Config".constantize
+
+          define_method things do
+            # memoization
+            return instance_variable_get("@#{things}") if instance_variable_get("@#{things}")
+
+            config_hash = self.class.send(storage_attribute).inject({}) do |out, name|
+              c = config_class.new(name, self)
+              send("#{name}_#{thing}", c)
+              c.set_defaults!
+              out.merge(name.to_sym => c.excluded ? {excluded: true} : c)
+            end
+
+            instance_variable_set "@#{things}", config_hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netzke/core/dynamic_assets.rb

@@ -16,7 +16,7 @@ module Netzke
             res << f.read
           end
 
-          defined?(::Rails) && ::Rails.env.production? ? res.strip_js_comments : res
+          strip_js_comments(res)
         end
 
         def ext_css
@@ -31,6 +31,14 @@ module Netzke
           res
         end
 
+        def strip_js_comments(js_string)
+          if defined?(::Rails) && !::Rails.env.development? && compressor = ::Rails.application.assets.js_compressor
+            compressor.processor.call(nil, js_string)
+          else
+            js_string
+          end
+        end
+
       private
 
         # Generates initial javascript code that is dependent on Rails settings
@@ -44,6 +52,7 @@ module Netzke
           res << %{Netzke.RelativeExtUrl = '#{ActionController::Base.config.relative_url_root}#{Netzke::Core.ext_uri}';}
 
           res << %{Netzke.core.directMaxRetries = #{Netzke::Core.js_direct_max_retries};}
+          res << %{Netzke.core.FeedbackDelay = #{Netzke::Core.js_feedback_delay};}
 
           res.join("\n")
         end

data/lib/netzke/core/embedding.rb

@@ -3,12 +3,12 @@ module Netzke::Core
   module Embedding
     # Instantiating
     def js_component_instance
-      %Q{Netzke.page.#{name.jsonify} = Ext.create("#{self.class.js_config.class_alias}", #{js_config.to_nifty_json});}
+      %Q{Netzke.page.#{name.to_s.camelize(:lower)} = Ext.create("#{self.class.js_config.class_alias}", #{js_config.netzke_jsonify.to_json});}
     end
 
     # Rendering
     def js_component_render
-      %Q{Netzke.page.#{name.jsonify}.render("#{name.to_s.split('_').join('-')}-netzke");} unless self.class.js_config.xtype == "netzkewindow"
+      %Q{Netzke.page.#{name.to_s.camelize(:lower)}.render("#{name.to_s.split('_').join('-')}-netzke");} unless self.class.js_config.xtype == "netzkewindow"
     end
 
     # Container for rendering

data/lib/netzke/core/html.rb

@@ -0,0 +1,29 @@
+module Netzke
+  module Core
+    # Provides support for HTML rendering (currently HAML only)
+    module Html
+      # Will render an HTML template found in +{component_location}/html/+ For example:
+      #
+      #     class MyComponent < Netzke::Base
+      #       def js_configure(c)
+      #         super
+      #         c.html = render(:body)
+      #       end
+      #     end
+      #
+      # This will render the HAML file located in +app/components/my_component/html/body.html.haml
+      # The implementation is very simplistic at the moment - e.g. no caching, no support for .erb
+      def render(what)
+        callr = caller.first
+        engine = Haml::Engine.new(File.read(expand_html_path(what, callr)))
+        engine.method(:render).call(self)
+      end
+
+    private
+
+      def expand_html_path(sym, callr = nil)
+        %Q(#{callr.split(".rb:").first}/html/#{sym}.html.haml)
+      end
+    end
+  end
+end

data/lib/netzke/core/javascript.rb

@@ -43,35 +43,39 @@ module Netzke::Core
     def js_configure(c)
       c.merge!(normalized_config)
 
-      # Unique id of the component
-      c.id = js_id
-
-      # Configuration for all of our non-lazy-loaded children specified here. We can refer to them in +items+ so they get instantiated by Ext.
-      c.netzke_components = js_components unless js_components.empty?
-
-      # Endpoints (besides the default "deliver_component" - JavaScript side already knows about it)
-      endpoints = self.class.endpoints.keys - [:deliver_component]
-
-      # pass them as strings, not as symbols
-      c.endpoints = endpoints.map(&:to_s) unless endpoints.empty?
+      # So we can use getComponent(<component_name>) to retrieve a child component
+      c.item_id ||= name
 
-      # Include our xtype
-      c.xtype = self.class.js_config.xtype
+      %w[id netzke_components endpoints xtype alias i18n netzke_plugins flash].each do |thing|
+        js_thing = send "js_#{thing}"
+        c[thing] = js_thing if js_thing.present?
+      end
 
-      # Include our alias: Ext.createByAlias may be used to instantiate the component.
-      c.alias = self.class.js_config.class_alias
+      # reset component session
+      # TODO: also remove empty hashes from the global session
+      component_session.clear
+    end
 
-      # So we can use getComponent(<component_name>) to retrieve a child component
-      c.item_id ||= name
+    def js_xtype
+      self.class.js_config.xtype
+    end
 
-      c.i18n = js_translate_properties if js_translate_properties.present?
+    # Ext.createByAlias may be used to instantiate the component.
+    def js_alias
+      self.class.js_config.class_alias
+    end
 
-      c.netzke_plugins = plugins.map{ |p| p.to_s.camelcase(:lower) } if plugins.present?
+    # Endpoints (besides the default "deliver_component" - JavaScript side already knows about it)
+    def js_endpoints
+      self.class.endpoints.keys - [:deliver_component]
+    end
 
-      # we need to pass them as strigs, not as symbols
-      c.tools = c.tools.map(&:to_s) if c.tools.present?
+    def js_netzke_plugins
+      plugins.map{ |p| p.to_s.camelcase(:lower) }
+    end
 
-      c.flash = session[:flash] if session && session[:flash].present?
+    def js_flash
+      session && session[:flash]
     end
 
     # Instance-level client class config. The result of this method (a hash) is converted to a JSON object and passed as options to the constructor of our JavaScript class.
@@ -88,21 +92,23 @@ module Netzke::Core
       end
     end
 
+    alias js_netzke_components js_components
+
     # All the JS-code required by this instance of the component to be instantiated in the browser.
     # It includes JS-classes for the parents, eagerly loaded child components, and itself.
     def js_missing_code(cached = [])
       code = dependency_classes.inject("") do |r,k|
-        cached.include?(k.js_config.xtype) ? r : r + k.js_config.code_with_dependencies.strip_js_comments
+        cached.include?(k.js_config.xtype) ? r : r + k.js_config.code_with_dependencies
       end
-      code.blank? ? nil : code
+      code.blank? ? nil : Netzke::Core::DynamicAssets.strip_js_comments(code)
     end
 
   private
 
     # Merges all the translations in the class hierarchy
     # Note: this method can't be moved out to ClientClass, because I18n is loaded only once, when other Ruby classes are evaluated; so, this must remain at instance level.
-    def js_translate_properties
-      @js_translate_properties ||= self.class.netzke_ancestors.inject({}) do |r,klass|
+    def js_i18n
+      @js_i18n ||= self.class.netzke_ancestors.inject({}) do |r,klass|
         hsh = klass.js_config.translated_properties.inject({}) { |h,t| h.merge(t => I18n.t("#{klass.i18n_id}.#{t}")) }
         r.merge(hsh)
       end

data/lib/netzke/core/railz/action_view_ext/ext.rb

@@ -8,7 +8,7 @@ module Netzke
 
         def netzke_ext_css_include(params)
           # ExtJS base
-          res = ["#{Netzke::Core.ext_uri}/resources/css/ext-#{params[:theme]}"]
+          res = ["#{Netzke::Core.ext_uri}/resources/css/ext-#{params[:theme]}.css"]
 
           # Netzke-related dynamic css
           res << netzke_path(:ext)
@@ -22,7 +22,7 @@ module Netzke
           res = []
 
           # ExtJS
-          res << (params[:minified] ? "#{Netzke::Core.ext_uri}/ext-all" : "#{Netzke::Core.ext_uri}/ext-all-debug")
+          res << (params[:minified] ? "#{Netzke::Core.ext_uri}/ext-all.js" : "#{Netzke::Core.ext_uri}/ext-all-debug.js")
 
           # Ext I18n
           res << "#{Netzke::Core.ext_uri}/locale/ext-lang-#{I18n.locale}" if I18n.locale != :en

data/lib/netzke/core/railz/controller_extensions.rb

@@ -2,16 +2,109 @@ module Netzke
   module Railz
     # Before each request, Netzke::Base.controller and Netzke::Base.session are set, to be accessible from components.
     module ControllerExtensions
-      def self.included(base)
-        base.send(:before_filter, :set_controller_and_session)
+      extend ActiveSupport::Concern
+
+      included do
+        send(:before_filter, :set_controller_and_session)
+      end
+
+      # Handles Ext.Direct RPC calls
+      def direct
+        if params['_json'] # this is a batched request
+          response = []
+          params['_json'].each do |batch|
+            # response << invoke_endpoint(batch)
+            response << direct_response(batch, invoke_endpoint(batch))
+          end
+        else # this is a single request
+          response = direct_response(params, invoke_endpoint(params))
+        end
+
+        render text: response.to_json, layout: false
+      end
+
+      # On-the-fly generation of public/netzke/ext.[js|css]
+      def ext
+        respond_to do |format|
+          format.js {
+            render :text => Netzke::Core::DynamicAssets.ext_js(form_authenticity_token)
+          }
+
+          format.css {
+            render :text => Netzke::Core::DynamicAssets.ext_css
+          }
+        end
+      end
+
+      # Old-way action used at multi-part form submission (endpointUrl)
+      def dispatcher
+        endpoint_dispatch(params[:address])
+      end
+
+    protected
+
+      def direct_response(request_params, endpoint_response)
+        path, action, params, tid = parse_request_params(request_params)
+        component_name, *sub_components = path.split('__')
+
+        # We render text/plain, so that the browser never modifies our response
+        response.headers["Content-Type"] = "text/plain; charset=utf-8"
+
+        { :type => "rpc",
+          :tid => tid,
+          :action => component_name,
+          :method => action,
+          :result => ActiveSupport::JSON::Variable.new(endpoint_response.netzke_jsonify.to_json)
+        }
       end
 
-      protected
+      def invoke_endpoint(request_params)
+        path, action, params, tid = parse_request_params(request_params)
+
+        component_name, *sub_components = path.split('__')
+        components_in_session = session[:netzke_components]
+
+        if components_in_session
+          component_instance = Netzke::Base.instance_by_config(components_in_session[component_name.to_sym])
+          component_instance.invoke_endpoint((sub_components + [action]).join("__"), params)
+        else
+          {:netzke_component_not_in_session => true}
+        end
+      end
+
+      def parse_request_params(params)
+        path = params[:act]
+        action = params[:method].underscore
+        ep_params = params[:data].try(:first) # Rails >= 3.2.11 returns nil in request_params[:data]
+        tid = params[:tid]
+
+        [path, action, ep_params, tid]
+      end
+
+      # The dispatcher for the old-style requests (used for multi-part form submission). The URL contains the name of the component,
+      # as well as the method of this component to be called, according to the double underscore notation.
+      # E.g.: some_grid__post_grid_data.
+      def endpoint_dispatch(endpoint_path)
+        component_name, *sub_components = endpoint_path.split('__')
+        component_instance = Netzke::Base.instance_by_config(session[:netzke_components][component_name.to_sym])
+
+        # We can't do this here; this method is only used for classic form submission, and the response from the server should be the (default) "text/html"
+        # response.headers["Content-Type"] = "text/plain; charset=utf-8"
+
+        render :text => component_instance.invoke_endpoint(sub_components.join("__"), params).netzke_jsonify.to_json, :layout => false
+      end
 
       def set_controller_and_session
         Netzke::Base.controller = self
         Netzke::Base.session = session
       end
+
+    private
+
+      # inform AbstractController::Base that methods direct, ext, and dispatcher are actually actions
+      def action_method?(name)
+        %w(direct ext dispatcher).include?(name.to_s) || super
+      end
     end
   end
 end

data/lib/netzke/core/railz/routes.rb

@@ -1,10 +1,21 @@
 module ActionDispatch::Routing
   class Mapper
-    # Enable routes for Netzke assets and endpoint calls. By default the URL is "/netzke", but this can be changed by providing an argument:
+    # Enables routes for Netzke assets and endpoint calls (by default routes to NetzkeController). The default URL is "/netzke", but this can be changed:
     #
     #     netzke "/some/path/netzke"
-    def netzke(prefix = "/netzke")
-      match "#{prefix}/:action(.:format)", to: "netzke", as: 'netzke'
+    #
+    # If you want to use your own controller instead of NetzkeController, you can specify it like this:
+    #
+    #     netzke "/netzke", controller: :admin
+    #
+    # This will make Netzke use AdminController. Note, that in that case AdminController MUST implement the actions required by Netzke. The way to do this is to include Netzke::Railz::ControllerExtensions in your controller, e.g.:
+    #
+    #     class AdminController < ApplicationController
+    #       include Netzke::Railz::ControllerExtensions
+    #     end
+    def netzke(prefix = "/netzke", options = {})
+      controller = options[:controller] || :netzke
+      match "#{prefix}/:action(.:format)", to: controller.to_s, as: 'netzke'
     end
   end
 end

data/lib/netzke/core/ruby_ext/array.rb

@@ -1,23 +1,9 @@
 class Array
-  def deep_map(&block)
-    self.map{ |el| el.respond_to?(:deep_map) ? block.call(el.deep_map(&block)) : block.call(el) }.compact
+  def netzke_deep_map(&block)
+    self.map{ |el| el.respond_to?(:netzke_deep_map) ? block.call(el.netzke_deep_map(&block)) : block.call(el) }.compact
   end
 
-  def jsonify
-    self.map{ |el| el.is_a?(Array) || el.is_a?(Hash) ? el.jsonify : el }
-  end
-
-  # Camelizes the keys of hashes and converts them to JSON
-  def to_nifty_json
-    self.jsonify.to_json
-  end
-
-  def deep_each_pair(&block)
-    self.each{ |el| el.respond_to?('deep_each_pair') && el.deep_each_pair(&block) }
-  end
-
-  def deep_freeze
-    each { |j| j.deep_freeze if j.respond_to? :deep_freeze }
-    freeze
+  def netzke_jsonify
+    self.map{ |el| el.is_a?(Array) || el.is_a?(Hash) ? el.netzke_jsonify : el }
   end
 end

data/lib/netzke/core/ruby_ext/hash.rb

@@ -1,47 +1,41 @@
 class Hash
-  def deep_map(&block)
+  def netzke_deep_map(&block)
     self.dup.tap do |h|
       h.each_pair do |k,v|
-        h[k] = v.deep_map(&block) if v.respond_to?('deep_map')
+        h[k] = v.netzke_deep_map(&block) if v.respond_to?('netzke_deep_map')
       end
     end
   end
 
-  def deep_each_pair(&block)
-    self.each_pair do |k,v|
-      v.respond_to?('deep_each_pair') ? v.deep_each_pair(&block) : yield(k,v)
-    end
-  end
-
-  def jsonify
+  def netzke_jsonify
     self.inject({}) do |h,(k,v)|
-      new_key = (k.is_a?(String) || k.is_a?(Symbol)) && !k.is_a?(ActiveSupport::JSON::Variable) ? k.jsonify : k
-      new_value = v.is_a?(Array) || v.is_a?(Hash) ? v.jsonify : v
-      h.merge(new_key => new_value)
-    end
-  end
+      new_key = if k.is_a?(ActiveSupport::JSON::Variable)
+                  k
+                elsif k.is_a?(String)
+                  k.camelize(:lower)
+                elsif k.is_a?(Symbol)
+                  k.to_s.camelize(:lower).to_sym
+                else
+                  k
+                end
 
-  # First camelizes the keys, then convert the whole hash to JSON
-  def to_nifty_json
-    self.jsonify.to_json
-  end
+      new_value = v.is_a?(Array) || v.is_a?(Hash) ? v.netzke_jsonify : v
 
-  def deep_freeze
-    each { |k,v| v.deep_freeze if v.respond_to? :deep_freeze }
-    freeze
+      h.merge(new_key => new_value)
+    end
   end
 
   # From http://rubyworks.github.com/facets
-  def update_keys #:yield:
+  def netzke_update_keys #:yield:
     if block_given?
       keys.each { |old_key| store(yield(old_key), delete(old_key)) }
     else
-      to_enum(:update_keys)
+      to_enum(:netzke_update_keys)
     end
   end
 
-  def literalize_keys
-    update_keys{ |k| k.to_s.l }
+  def netzke_literalize_keys
+    netzke_update_keys{ |k| ActiveSupport::JSON::Variable.new(k.to_s) }
     self
   end
 end

data/lib/netzke/core/ruby_ext/time_with_zone.rb

@@ -4,4 +4,4 @@ module ActiveSupport
       self.to_s(:db).to_json
     end
   end
-end
+end

data/lib/netzke/core/ruby_ext.rb

@@ -1,5 +1,3 @@
 require "netzke/core/ruby_ext/array"
 require "netzke/core/ruby_ext/hash"
-require "netzke/core/ruby_ext/string"
-require "netzke/core/ruby_ext/symbol"
 require "netzke/core/ruby_ext/time_with_zone"

data/lib/netzke/core/session.rb

@@ -4,13 +4,20 @@ module Netzke::Core
     # Instance of this class is returned through component_session, and allows writing/reading to/from the session part reserved for a specific component (specified by component's js_id).
     class ComponentSessionProxy < Object
       def initialize(component_id)
-        @session = Netzke::Base.session.nil? ? {} : Netzke::Base.session[component_id] ||= {}
+        @component_id = component_id
+        Netzke::Base.session ||= {}
+        Netzke::Base.session[:netzke_sessions] ||= {}
+        @session = Netzke::Base.session[:netzke_sessions][@component_id] ||= {}
       end
 
       # Delegate everything to session
       def method_missing(method, *args)
         @session.send(method, *args)
       end
+
+      def clear
+        Netzke::Base.session[:netzke_sessions].delete(@component_id)
+      end
     end
 
     # Component-specific session.

data/lib/netzke/core/state.rb

@@ -26,15 +26,15 @@ module Netzke::Core
     #
     #     state[:position] #=> {:x => 100, :y => 200}
     #
-    # May be overridden by persistence subsystems. The object returned by this should implement at least the following methods:
+    # May be overridden by persistence subsystems. The object returned by this should implement the following methods:
     #
     # * []
     # * []=
     # * delete(key)
     # * clear
     def state
-      session[:state] ||= {}
-      session[:state][persistence_key] ||= {}
+      session[:netzke_states] ||= {}
+      session[:netzke_states][persistence_key] ||= {}
     end
   end
 end

data/lib/netzke/core/version.rb

@@ -3,7 +3,7 @@ module Netzke
     module Version
       MAJOR = 0
       MINOR = 8
-      PATCH = 1
+      PATCH = 2
 
       STRING = [MAJOR, MINOR, PATCH].compact.join('.')
     end