netzke-core 0.12.3 → 1.0.0.0.pre

data/lib/netzke/core/configuration.rb

@@ -5,7 +5,7 @@ module Netzke::Core
   #     class_attribute :title
   #     self.title = "Title for all descendants of MyComponent"
   #
-  #     js_configure do |c|
+  #     client_class do |c|
   #       c.title = title
   #     end
   #   end
@@ -28,14 +28,30 @@ module Netzke::Core
     #     config.enable_awesome_feature = true
     #   end
     module ClassMethods
+      # Do class-level config of a component, e.g.:
+      #
+      #   Netzke::Basepack::GridPanel.setup do |c|
+      #     c.rows_reordering_available = false
+      #   end
       def setup
         yield self
       end
 
       # An array of server class config options that should not be passed to the client class. Can be overridden.
       def server_side_config_options
-        [:eager_loading, :klass, :client_config]
+        [:klass, :client_config]
       end
+
+      # Instance of component by config
+      def instance_by_config(config)
+        klass = config[:klass] || config[:class_name].constantize
+        klass.new(config)
+      end
+    end
+
+    included do
+      # Config that has all the config extensions applied (via `extend_item`)
+      attr_accessor :normalized_config
     end
 
     # Override to auto-configure components. Example:
@@ -60,7 +76,7 @@ module Netzke::Core
       @config ||= ActiveSupport::OrderedOptions.new
     end
 
-    # Config options that have been set on the fly on the client side of the component in the `netzkeClientConfig` object. Can be
+    # Config options that have been set on the fly on the client side of the component in the `serverConfig` object. Can be
     # used to dynamically change component configuration. Those changes won't affect the way component is rendered, of
     # course, but can be useful to reconfigure child components, e.g.:
     #
@@ -69,7 +85,7 @@ module Netzke::Core
     #     this.callParent();
     #
     #     this.netzkeGetComponent('authors').on('rowclick', function(grid, record) {
-    #       this.netzkeClientConfig.author_id = record.getId();
+    #       this.serverConfig.author_id = record.getId();
     #       this.netzkeGetComponent('book_grid').getStore().load();
     #     }
     #   }
@@ -82,13 +98,14 @@ module Netzke::Core
       ActiveSupport::OrderedOptions.new.merge!(config.client_config)
     end
 
-  protected
+    protected
 
-    # Override to validate configuration and raise eventual exceptions
+    # Override to validate or enforce certain configuration options
     # E.g.:
     #
     #     def validate_config(c)
     #       raise ArgumentError, "Grid requires a model" if c.model.nil?
+    #       c.paging = true if c.edit_inline
     #     end
     def validate_config(c)
     end
@@ -104,12 +121,13 @@ module Netzke::Core
 
     # We'll build a couple of useful instance variables here:
     #
-    # +components_in_config+ - an array of components (by name) referred in items
+    # +components_in_config+ - an array of components (by name) referred in `configure`
+    # +inline_components+ - a hash with configs of components defined inline in `configure`
     # +normalized_config+ - a config that has all the config extensions applied
     def normalize_config
-      # @actions = @components = {} # in v1.0 this should replace DSL definition
       @components_in_config = []
       @implicit_component_index = 0
+      @inline_components = {}
       c = config.dup
       config.each_pair do |k, v|
         c.delete(k) if self.class.server_side_config_options.include?(k.to_sym)
@@ -119,11 +137,5 @@ module Netzke::Core
       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/core_i18n.rb

@@ -0,0 +1,17 @@
+module Netzke
+  module Core
+    module CoreI18n
+      extend ActiveSupport::Concern
+      module ClassMethods
+        # The ID used to locate this component's block in locale files
+        def i18n_id
+          name.split("::").map{|c| c.underscore}.join(".")
+        end
+      end
+
+      def i18n_id
+        self.class.i18n_id
+      end
+    end
+  end
+end

data/lib/netzke/core/css_config.rb

@@ -1,9 +1,9 @@
 module Netzke
   module Core
-    # This class is responsible of assemblage of stylesheet dependencies. It is passed as block parameter to the +css_configure+ DSL method:
+    # This class is responsible of assemblage of stylesheet dependencies. It is passed as block parameter to the +client_styles+ DSL method:
     #
     #     class MyComponent < Netzke::Base
-    #       css_configure do |c|
+    #       client_styles do |c|
     #         c.require :extra_styles
     #       end
     #     end
@@ -23,16 +23,16 @@ module Netzke
       # Symbols will be expanded following a convention, e.g.:
       #
       #     class MyComponent < Netzke::Base
-      #       css_configure do |c|
+      #       client_styles do |c|
       #         c.require :some_styles
       #       end
       #     end
       #
-      # This will "require" a stylesheet file +{component_location}/my_component/stylesheets/some_styles.js+
+      # This will "require" a stylesheet file +{component_location}/my_component/client/some_styles.css+
       #
       # Strings will be interpreted as full paths to the required JavaScript file:
       #
-      #     css_configure do |c|
+      #     client_styles do |c|
       #       c.require "#{File.dirname(__FILE__)}/my_component/one.css", "#{File.dirname(__FILE__)}/my_component/two.css"
       #     end
       def require(*args)
@@ -43,7 +43,7 @@ module Netzke
     private
 
       def expand_css_require_path(sym, callr)
-        %Q(#{callr.split(".rb:").first}/stylesheets/#{sym}.css)
+        %Q(#{callr.split(".rb:").first}/client/#{sym}.css)
       end
 
     end

data/lib/netzke/core/dynamic_assets.rb

@@ -3,14 +3,13 @@ require 'uglifier'
 module Netzke
   module Core
     module DynamicAssets
+      CORE_FILES = %w[js_extensions core notifications remoting_provider base routing]
+
       class << self
         def ext_js(form_authenticity_token)
           res = initial_dynamic_javascript(form_authenticity_token) << "\n"
 
-          include_base_js(res)
-
-          # Ext-specific JavaScript
-          res << File.new(File.expand_path("../../../../javascripts/ext.js", __FILE__)).read
+          include_core_js(res)
 
           # Pluggable JavaScript (used by other Netzke-powered gems like netzke-basepack)
           Netzke::Core.ext_javascripts.each do |path|
@@ -35,7 +34,7 @@ module Netzke
 
         def minify_js(js_string)
           if ::Rails.env.test? || ::Rails.env.development?
-            js_string
+            js_string.gsub(/\/\*\*[^*]*\*+(?:[^*\/][^*]*\*+)*\//, '') # strip docs
           else
             Uglifier.compile(js_string)
           end
@@ -45,28 +44,22 @@ module Netzke
 
         # Generates initial javascript code that is dependent on Rails settings
         def initial_dynamic_javascript(form_authenticity_token)
-          res = []
-          res << %(Ext.Ajax.setExtraParams({authenticity_token: '#{form_authenticity_token}'}); // Rails' forgery protection)
-          res << %{Ext.ns('Netzke');}
-          res << %{Ext.ns('Netzke.core');}
-          res << %{Netzke.RelativeUrlRoot = '#{ActionController::Base.config.relative_url_root}';}
-          res << %{Netzke.ControllerUrl = '#{ActionController::Base.config.relative_url_root}#{Rails.application.routes.url_helpers.netzke_path}/';}
-          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")
+          url_root = ActionController::Base.config.relative_url_root
+          %(Ext.Ajax.setExtraParams({authenticity_token: '#{form_authenticity_token}'});
+Ext.ns('Netzke.Core');
+Netzke.RelativeUrlRoot = '#{url_root}';
+Netzke.ControllerUrl = '#{url_root}#{Rails.application.routes.url_helpers.netzke_path}/';
+Netzke.RelativeExtUrl = '#{url_root}#{Netzke::Core.ext_uri}';
+Netzke.Core.directMaxRetries = #{Netzke::Core.js_direct_max_retries};
+Netzke.Core.NotificationDelay = #{Netzke::Core.client_notification_delay};
+)
         end
 
-        def include_base_js(arry)
-          # JavaScript extensions
-          arry << File.new(File.expand_path("../../../../javascripts/js_extensions.js", __FILE__)).read
-
-          # Base Netzke component JavaScript
-          arry << File.new(File.expand_path("../../../../javascripts/base.js", __FILE__)).read
+        def include_core_js(arry)
+          CORE_FILES.each do |script|
+            arry << File.new(File.expand_path("../../../../javascripts/#{script}.js", __FILE__)).read
+          end
         end
-
       end
     end
   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.to_s.camelize(:lower)} = Ext.create("#{self.class.js_config.class_alias}", #{js_config.netzke_jsonify.to_json});}
+      %Q{Netzke.page.#{name.to_s.camelize(:lower)} = Ext.create("#{self.class.client_class_config.class_alias}", #{js_config.netzke_jsonify.to_json});}
     end
 
     # Rendering
     def js_component_render
-      %Q{Netzke.page.#{name.to_s.camelize(:lower)}.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.client_class_config.xtype == "netzkewindow"
     end
 
     # Container for rendering

data/lib/netzke/core/endpoint_response.rb

@@ -1,6 +1,12 @@
 module Netzke::Core
-  # Represents the endpoint response at the server side.
-  # An instance of it is passed as the second parameter to the +endpoint+ block.
+  # Represents the endpoint response at the server side. Collects instructions for the client-side object. Accessible as
+  # the `client` in the endpoint calls, e.g.:
+  #
+  #       class SimpleComponent < Netzke::Base
+  #         endpoint :whats_up_server do
+  #           client.set_title("Response from server")
+  #         end
+  #       end
   class EndpointResponse < ::Hash
     def method_missing(name, *params)
       if name.to_s =~ /(.+)=$/

data/lib/netzke/core/inheritance.rb

@@ -0,0 +1,33 @@
+module Netzke
+  module Core
+    module Inheritance
+      extend ActiveSupport::Concern
+      module ClassMethods
+        attr_accessor :called_from
+
+        # Ancestor classes in the Netzke class hierarchy up to (and excluding) +Netzke::Base+, including self; in comparison to Ruby's own Class.ancestors, the order is reversed.
+        def netzke_ancestors
+          if self == Netzke::Base
+            []
+          else
+            superclass.netzke_ancestors + [self]
+          end
+        end
+
+        # Keep track of component's file. Inspired by Rails railties code.
+        def inherited(base)
+          base.called_from = begin
+            cllr = if Kernel.respond_to?(:caller_locations)
+              location = caller_locations.first
+              location.absolute_path || location.path
+            else
+              caller.first
+            end
+
+            cllr.split(".rb").first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netzke/core/plugins.rb

@@ -12,11 +12,8 @@ module Netzke::Core
       # Defines a plugin
       def plugin(name, &block)
         register_plugin(name)
-        component name do |c|
+        component name, eager_load: true do |c|
           block.call(c) if block_given?
-
-          # plugins are *always* eagerly loaded
-          c.eager_loading = true
         end
       end
 

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

@@ -54,7 +54,7 @@ module Netzke
         content_for :netzke_on_ready, raw("#{cmp.js_component_instance}\n\n#{cmp.js_component_render}")
 
         # Now mark all this component's dependency classes (including self) as rendered (by storing their xtypes), so that we only generate a class once per view
-        @rendered_classes = (@rendered_classes + cmp.dependency_classes.map{|k| k.js_config.xtype}).uniq
+        @rendered_classes = (@rendered_classes + cmp.dependency_classes.map{|k| k.client_class_config.xtype}).uniq
 
         # Return the html for this component
         raw(cmp.js_component_html)

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

@@ -15,15 +15,13 @@ module Netzke
           @params[:endpoint].underscore
         end
 
+        # arguments for endpoint call
         def args
-          # for backward compatibility, fall back to old data structure (with the endpoint params being in the root of
-          # 'data')
-          remoting_args.has_key?("args") ? remoting_args["args"] : remoting_args.reject{|k,v| k == 'configs' }
+          res = remoting_args.has_key?("args") ? remoting_args["args"] : remoting_args
+          res.is_a?(Array) ? res : [res].compact # need to wrap into array to normalize
         end
 
         def client_configs
-          # if no configs are provided, the behavior is the old one, and thus all instances the same child component
-          # will be treated as one
           remoting_args["configs"] || []
         end
 
@@ -33,8 +31,9 @@ module Netzke
 
       private
 
+        # raw arguments from the client
         def remoting_args
-          @_remoting_args ||= @params[:data].first
+          @_remoting_args ||= @params[:data]
         end
       end
 
@@ -87,6 +86,7 @@ module Netzke
 
     protected
 
+      # Receives DirectRequest and result of invoke_endpoint, returns hash understood by client-side's Direct function
       def direct_response(request, endpoint_response)
         component_name, *sub_components = request.cmp_path.split('__')
 
@@ -101,17 +101,16 @@ module Netzke
         }
       end
 
+      # Receives DirectRequest, returns an array/hash of methods for the client side (consumed by netzkeBulkExecute)
       def invoke_endpoint(request)
         component_name, *sub_components = request.cmp_path.split('__')
-        components_in_session = session[:netzke_components].try(:symbolize_keys)
 
-        if components_in_session
-          cmp_config = components_in_session[component_name.to_sym].symbolize_keys
+        if cmp_config = config_in_session(component_name)
           cmp_config[:client_config] = request.client_configs.shift || {}
           component_instance = Netzke::Base.instance_by_config(cmp_config)
           component_instance.invoke_endpoint((sub_components + [request.endpoint]).join("__"), request.args, request.client_configs)
         else
-          {netzke_session_expired: []}
+          { netzke_on_session_expired: [] }
         end
       end
 
@@ -120,19 +119,26 @@ module Netzke
       # 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"
+        if cmp_config = config_in_session(component_name)
+          cmp_config[:client_config] = ActiveSupport::JSON.decode(params[:configs]).shift || {}
+          component_instance = Netzke::Base.instance_by_config(cmp_config)
 
-        render :text => component_instance.invoke_endpoint(sub_components.join("__"), params).netzke_jsonify.to_json, :layout => false
+          render text: component_instance.invoke_endpoint(sub_components.join("__"), [params]).netzke_jsonify.to_json, layout: false
+        else
+          render text: { netzke_on_session_expired: [] }.to_json, layout: false
+        end
       end
 
       def set_controller_and_session
         Netzke::Base.controller = self
         Netzke::Base.session = session
       end
+
+      def config_in_session(component_name)
+        components_in_session = (session[:netzke_components] || {}).symbolize_keys
+        components_in_session[component_name.to_sym].try(:symbolize_keys)
+      end
     end
   end
 end

data/lib/netzke/core/services.rb

@@ -5,7 +5,7 @@ module Netzke::Core
   #
   # An endpoint is defined through the +endpoint+ class method on the Ruby class:
   #
-  #     endpoint :do_something do |params, this|
+  #     endpoint :do_something do
   #       # ...
   #     end
   #
@@ -14,74 +14,78 @@ module Netzke::Core
   #
   # == Calling an endpoint from JavaScript
   #
-  # By defining the endpoint on the Ruby class, the client side automatically gets an equally named (but camelcased) method that is used to call the endpoint at the server. In the previous example, that would be +doSomething+. Its signature goes as follows:
+  # By defining the endpoint on the Ruby class, the client side automatically gets an equally named (in camelCase) function that is used to call the endpoint. In the previous example, that would be +doSomething+. Its signature goes as follows:
   #
-  #     this.doSomething(argsObject, callbackFunction, scope);
+  #     this.server.doSomething(args..., callback, scope);
   #
-  # * +argsObject+ is what the server side will receive as the +params+ argument
-  # * +callbackFunction+ (optional) will be called after the server successfully processes the request
-  # * +scope+ (optional) the scope in which +callbackFunction+ will be called
+  # * +args+ (optional) is what the +endpoint+ block at the server will receive as parameters
+  # * +callback+ (optional) will be called after the server successfully processes the request
+  # * +scope+ (optional) the scope in which +callback+ will be called, defaults to component instance
   #
   # The callback function can optionally receive an argument set by the endpoint at the server (see "Providing the argument to the callback function").
   #
   # == Envoking JavaScript methods from the server
   #
-  # An endpoint, after doing some useful job at the server, is able to instruct the client side of the component to call multiple methods (preserving the call order) with provided arguments. It's done by using the second parameter of the endpoint block (which is illustratively called 'this'):
+  # An endpoint, after doing some useful job at the server, is able to instruct the client side of the component to call multiple methods (preserving the call order) with provided arguments. It's done via the +client+ variable:
   #
-  #     endpoint :do_something do |params, this|
+  #     endpoint :do_something do
   #       # ... do the thing
-  #       this.set_title("New title")
-  #       this.add_class("some-extra-css")
+  #       client.set_title("New title")
+  #       client.add_class("some-extra-css")
   #     end
   #
-  # This will result in successive calling the +setTitle+ and +addClass+ methods on the JavaScript instance of our component.
+  # This will result in successive calling the +setTitle+ and +addClass+ methods on the JavaScript instance of the component.
   #
   # Besides "calling" methods on the current component itself, it's also possible to address its instantiated children at any level of the hierarchy:
   #
-  #     endpoint :do_something do |params, this|
+  #     endpoint :do_something do
   #       # ... do the thing
-  #       this.east_panel_component.set_title("New east panel title")
-  #       this.east_panel_component.deep_nested_component.do_something_very_special("With", "some", "arguments")
+  #       client.east_panel_component.set_title("New east panel title")
+  #       client.east_panel_component.deep_nested_component.do_something_very_special("With", "some", "arguments")
   #     end
   #
   # == Providing arguments to the callback function
   #
-  # The callback function provided at the moment of calling an endpoint may receive an argument set by the endpoint by "calling" the special +netzke_set_result+ method. :
+  # The callback function provided at the moment of calling an endpoint will receive as its only argument the result of
+  # the +endpoint+ block execution:
   #
-  #     endpoint :do_something do |params, this|
+  #     endpoint :get_the_answer do
   #       # ... do the thing
-  #       this.netzke_set_result(42)
+  #       42
   #     end
   #
   # By calling the endpoint from the client side like this:
   #
-  #     this.doSomething({}, function(result){ console.debug(result); });
+  #     this.server.getTheAnswer(function(result){ console.debug(result); });
   #
-  # ... the value of +result+ after the execution of the endpoint will be set to 42. Using this mechanism can be seen as doing an asyncronous call to a function at the server, which returns a value.
+  # ... the value of +result+ after the endpoint execution will be 42. Using this mechanism can be seen as doing an asyncronous call to a server-side function that returns a value.
   #
   # == Overriding an endpoint
   #
   # When overriding an endpoint, you can call the original endpoint by using +super+ and explicitely providing the block parameters to it:
   #
-  #     endpoint :do_something do |params, this|
-  #       super(params, this)
-  #       this.doMore
+  #     endpoint :do_something do |arg1, arg2|
+  #       super(arg1, arg2)
+  #       client.do_more
   #     end
   #
-  # If you want to reuse the original arguments set in +super+, you can access them from the +this+ object. Provided we are overriding the +do_something+ endpoint from the example in "Envoking JavaScript methods from the server", we will have:
+  # If you want to reuse the original arguments set in +super+, you can access them from the +client+ object. Provided we are overriding the +do_something+ endpoint from the example in "Envoking JavaScript methods from the server", we will have:
   #
-  #     endpoint :do_something do |params, this|
-  #       super(params, this)
-  #       original_arguments_for_set_title = this.set_title # => ["New title"]
-  #       original_arguments_for_add_class = this.add_class # => ["some-extra-css"]
+  #     endpoint :do_something do |params|
+  #       super(params)
+  #       original_arguments_for_set_title = client.set_title # => ["New title"]
+  #       original_arguments_for_add_class = client.add_class # => ["some-extra-css"]
   #     end
   module Services
     extend ActiveSupport::Concern
 
     included do
-       # Returns all endpoints as a hash
+      # Returns all endpoints as a hash
       class_attribute :endpoints
       self.endpoints = {}
+
+      # instance of EndpointResponse
+      attr_accessor :client
     end
 
     module ClassMethods
@@ -99,34 +103,33 @@ module Netzke::Core
       end
     end
 
-    # Invokes an endpoint call
+    # Invokes an endpoint
+    #
     # +endpoint+ may contain the path to the endpoint in a component down the hierarchy, e.g.:
+    # +params+ contains an Array of parameters to pass to the endpoint
     #
     #     invoke_endpoint(:users__center__get_data, params)
+    #
+    # Returns instance of EndpointResponse
     def invoke_endpoint(endpoint, params, configs = [])
-      endpoint_response = Netzke::Core::EndpointResponse.new
+      self.client = Netzke::Core::EndpointResponse.new
 
       if has_endpoint?(endpoint)
-        send("#{endpoint}_endpoint", params, endpoint_response)
-        endpoint_response
+        client.netzke_set_result(send("#{endpoint}_endpoint", *params))
+        client
       else
-        # Let's try to find it recursively in a component down the hierarchy
+        # Let's try to find it in a component down the tree
         child_component, *action = endpoint.to_s.split('__')
-        child_component = child_component.to_sym
+
         action = !action.empty? && action.join("__").to_sym
+        return unknown_exception(:endpoint, endpoint) if !action
+
+        client_config = configs.shift || {}
+        child_config = component_config(child_component.to_sym, client_config: client_config)
 
-        raise RuntimeError, "Component '#{self.class.name}' does not have endpoint '#{endpoint}'" if !action
-
-        if components[child_component]
-          client_config = configs.shift || {}
-          js_id = client_config.delete("component_id")
-          cmp_strong_config = {client_config: client_config, js_id: js_id}
-          component_instance(child_component, cmp_strong_config).invoke_endpoint(action, params, configs)
-        else
-          # component_missing can be overridden if necessary
-          component_missing(child_component, params, endpoint_response)
-          endpoint_response
-        end
+        return unknown_exception(:component, child_component) if child_config.nil?
+
+        component_instance(child_config).invoke_endpoint(action, params, configs)
       end
     end
 
@@ -136,9 +139,19 @@ module Netzke::Core
 
     # Called when the method_missing tries to processes a non-existing component. Override when needed.
     # Note: this should actually never happen unless you mess up with Netzke component loading mechanisms.
-    def component_missing(missing_component, params, this)
-      this.netzke_feedback "Unknown component '#{missing_component}' in '#{name}'"
+    def component_missing(missing_component, *params)
+      client.netzke_notify "Unknown component '#{missing_component}' in '#{name}'"
     end
 
+    private
+
+    def unknown_exception(entity_name, entity)
+      client.netzke_set_result(error: {
+        type: "UNKNOWN_#{entity_name.to_s.upcase}",
+        msg: "Component '#{self.class.name}' does not have #{entity_name} '#{entity}'"
+      })
+
+      client
+    end
   end
 end

data/lib/netzke/core/session.rb

@@ -7,8 +7,6 @@ module Netzke::Core
         @component_id = component_id.to_s
         Netzke::Base.session ||= {}
         Netzke::Base.session[:netzke_sessions] ||= {}
-        # @session = Netzke::Base.session[:netzke_sessions][@component_id] ||= {}
-        # @session = {}
       end
 
       # Delegate everything to session