netzke-core 0.12.3 → 1.0.0.0.pre

data/lib/netzke/core/{client_class.rb → client_class_config.rb}

@@ -1,31 +1,32 @@
 module Netzke
   module Core
-    # This class is responsible of creation of the client (JavaScript) class. It is passed as block parameter to the `js_configure` DSL method:
+    # This class is responsible of creation of the client (JavaScript) class. It is passed as block parameter to the `client_class` DSL method:
     #
     #     class MyComponent < Netzke::Base
-    #       js_configure do |c|
+    #       client_class do |c|
     #         c.extend = "Ext.form.Panel"
     #       end
     #     end
-    class ClientClass
-      attr_accessor :required_files, :base_class, :properties, :netzke_mixins, :translated_properties
+    class ClientClassConfig
+      attr_accessor :base_class, :properties, :translated_properties, :dir, :requires_as_string
 
-      def initialize(klass)
+      def initialize(klass, called_from)
         @klass = klass
-        @required_files = []
-        @netzke_mixins = []
+        @called_from = @dir = called_from
+        @requires_as_string = ""
+        @explicit_override_paths = []
         @properties = {
           extend: extended_class,
           alias: class_alias,
         }
-        @properties[:mixins] = ['Netzke.classes.Core.Mixin'] if extending_extjs_component?
+        @properties[:mixins] = ['Netzke.Base'] if extending_extjs_component?
         @translated_properties = []
       end
 
       # Allows assigning JavaScript prototype properties, including functions:
       #
       #     class MyComponent < Netzke::Base
-      #       js_configure do |c|
+      #       client_class do |c|
       #         # this will result in the +title+ property defined on the client class prototype
       #         c.title = "My cool component"
       #
@@ -38,19 +39,19 @@ module Netzke
       #       end
       #     end
       #
-      # An alternative way to define prototype properties is by using "mixins", see {ClientClass#mixin}
+      # An alternative way to define prototype properties is by using {ClientClassConfig#include}
       #
-      # Class attributes are accessible from inside +js_configure+:
+      # As attributes are accessible from inside +client_class+:
       #
       #     class MyComponent < Netzke::Base
       #       class_attribute :title
       #       self.title = "Some default title"
-      #       js_configure do |c|
+      #       client_class do |c|
       #         c.title = self.title
       #       end
       #     end
       #
-      # Now you can configure your component on a class level like this:
+      # ... you can configure your component on a class level like this:
       #
       #     # e.g. in Rails initializers
       #     MyComponent.title = "New title for all MyComponents"
@@ -76,36 +77,37 @@ module Netzke
       # Symbols will be expanded following a convention, e.g.:
       #
       #     class MyComponent < Netzke::Base
-      #       js_configure do |c|
+      #       client_class do |c|
       #         c.require :some_library
       #       end
       #     end
       #
-      # This will "require" a JavaScript file +{component_location}/my_component/javascripts/some_library.js+
+      # This will "require" a JavaScript file +{component_location}/my_component/client/some_library.js+
       #
       # Strings will be interpreted as full paths to the required JavaScript file:
       #
-      #     js_configure do |c|
+      #     client_class do |c|
       #       c.require "#{File.dirname(__FILE__)}/my_component/one.js", "#{File.dirname(__FILE__)}/my_component/two.js"
       #     end
-      def require(*args)
-        callr = caller.first
-
-        @required_files |= args.map{ |a| a.is_a?(Symbol) ? expand_require_path(a, callr) : a }
+      def require(*refs)
+        raise(ArgumentError, "wrong number of arguments (0 for 1 or more)") if refs.empty?
+        refs.each do |ref|
+          @requires_as_string << require_from_file(normalize_filepath(ref))
+        end
       end
 
-      # Use it to "mixin" JavaScript objects defined in a separate file. It may accept one or more symbols or strings.
+      # Use it to "include" JavaScript methods defined in a separate file. Behind the scenes it uses `Ext.Class.override` It may accept one or more symbols or strings.
       #
       # Symbols will be expanded following a convention, e.g.:
       #
       #     class MyComponent < Netzke::Base
-      #       js_configure do |c|
-      #         c.mixin :some_functionality
+      #       client_class do |c|
+      #         c.include :some_functionality
       #         #...
       #       end
       #     end
       #
-      # This will "mixin" a JavaScript object defined in a file named +{component_location}/my_component/javascripts/some_functionality.js+, which way contain something like this:
+      # This will "include" a JavaScript object defined in the file named +{component_location}/my_component/client/some_functionality.js+, which way contain something like this:
       #
       #     {
       #       someProperty: 100,
@@ -114,15 +116,14 @@ module Netzke
       #       }
       #     }
       #
-      # Also accepts a string, which will be interpreted as a full path to the file (useful for sharing mixins between classes).
-      # With no parameters, will assume :<component_class_name>.
+      # Strings will be interpreted as a full path to the "included" file (useful for sharing client code between components).
       #
-      # Also, see defining JavaScript prototype properties with {ClientClass#method_missing}.
-      def mixin(*args)
-        args << @klass.name.split("::").last.underscore.to_sym if args.empty?
-        callr = caller.first
-        args.each do |a|
-          @netzke_mixins << (a.is_a?(Symbol) ? expand_require_path(a, callr) : a)
+      # Also, see defining JavaScript prototype properties with {ClientClassConfig#method_missing}.
+      def include(*refs)
+        raise(ArgumentError, "wrong number of arguments (0 for 1 or more)") if refs.empty?
+
+        refs.each do |ref|
+          @explicit_override_paths << normalize_filepath(ref)
         end
       end
 
@@ -137,7 +138,7 @@ module Netzke
       # E.g.:
       #
       #   class MyComponent < Netzke::Base
-      #     js_configure do |c|
+      #     client_class do |c|
       #       c.translate :overwrite_confirm, :overwrite_confirm_title, :delete_confirm, :delete_confirm_title
       #     end
       #   end
@@ -153,11 +154,11 @@ module Netzke
       # Builds this component's xtype
       # E.g.: netzkebasepackwindow, netzkebasepackgridpanel
       def xtype
-        "netzke" + @klass.name.gsub("::", "").downcase
+        @klass.name.gsub("::", "").downcase
       end
 
       # Component's JavaScript class declaration.
-      # It gets stored in the JS class cache storage (Netzke.classes) at the client side to be reused at the moment of component instantiation.
+      # It gets stored in the JS class cache storage (Netzke.cache) at the client side to be reused at the moment of component instantiation.
       def class_code
         res = []
         # Defining the scope if it isn't known yet
@@ -173,21 +174,21 @@ Netzke.cache.push('#{xtype}');
         res.join("\n")
       end
 
-      # Top level scope which will be used to scope out Netzke classes
+      # Additional scope for your Netzke components.
       def default_scope
-        "Netzke.classes"
+        ""
       end
 
       # Returns the scope of this component
-      # e.g. "Netzke.classes.Netzke.Basepack"
+      # e.g. "Netzke.Basepack"
       def scope
-        [default_scope, *@klass.name.split("::")[0..-2]].join(".")
+        [default_scope.presence, *@klass.name.split("::")[0..-2]].compact.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.Basepack.GridPanel"
+      # Returns the full name of the JavaScript class, including the scopes *and* the common scope, which is 'Netzke'.
+      # E.g.: "Netzke.Basepack.GridPanel"
       def class_name
-        [scope, @klass.name.split("::").last].join(".")
+        [scope.presence, @klass.name.split("::").last].compact.join(".")
       end
 
       # Whether we have to inherit from an Ext JS component, or a Netzke component
@@ -195,29 +196,16 @@ Netzke.cache.push('#{xtype}');
         @klass.superclass == Netzke::Base
       end
 
-      # Returns all required JavaScript files as a string
-      def required
-        res = ""
-
-        # Prevent re-including code that was already required by the parent
-        # (thus, only require those JS files when require_js was defined in the current class, not in its ancestors)
-        # FIXME!
-        ((@klass.singleton_methods(false).map(&:to_sym).include?(:include_js) ? include_js : []) + required_files).each do |path|
-          f = File.new(path)
-          res << f.read << "\n"
-        end
-
-        res
-      end
-
       # JavaScript code needed for this particulaer class. Includes external JS code and the JS class definition for self.
       def code_with_dependencies
-        [required, class_code].join("\n")
+        [requires_as_string, class_code].join("\n")
       end
 
       # Generates declaration of the JS class as direct extension of a Ext component
       def class_declaration
-%(Ext.define('#{class_name}', #{properties_as_string});)
+%(Ext.define('#{class_name}', #{properties_as_string});
+
+#{overrides_as_string})
       end
 
       # Alias prefix: 'widget' for components, 'plugin' for plugins
@@ -225,27 +213,47 @@ Netzke.cache.push('#{xtype}');
         @klass < Netzke::Plugin ? "plugin" : "widget"
       end
 
-      def mixins_as_string
-        netzke_mixins.presence && netzke_mixins.map do |f|
-          as_string = File.read(f)
-          as_string.sub!('{', ' ')
-          as_string[as_string.rindex('}')] = ' '
-          as_string.rstrip
-        end.join(",\n")
-      end
-
       def properties_as_string
-        [properties.netzke_jsonify.to_json.chop,  mixins_as_string].compact.join(",\n") + "}"
+        [properties.netzke_jsonify.to_json.chop].compact.join(",\n") + "}"
       end
 
       # Default extended class
       def extended_class
-        extending_extjs_component? ? "Ext.panel.Panel" : @klass.superclass.js_config.class_name
+        extending_extjs_component? ? "Ext.panel.Panel" : @klass.superclass.client_class_config.class_name
+      end
+
+      def expand_client_code_path(ref)
+        "#{@dir}/client/#{ref}.js"
+      end
+
+      def override_paths
+        return @override_paths if @override_paths
+
+        @override_paths = @explicit_override_paths
+        @dir = @called_from
+        default_override_path = expand_client_code_path(@dir.split("/").last)
+        @override_paths.prepend(default_override_path) if File.exist?(default_override_path)
+        @override_paths
+      end
+
+      def overrides_as_string
+        override_paths.map { |path| override_from_file(path) }.join("\n\n")
+      end
+
+      private
+
+      def override_from_file(path)
+        str = File.read(path)
+        str.chomp!("\n")
+        %(#{class_name}.override(#{str});)
+      end
+
+      def require_from_file(path)
+        File.new(path).read + "\n"
       end
 
-    private
-      def expand_require_path(sym, callr)
-        %Q(#{callr.split(".rb:").first}/javascripts/#{sym}.js)
+      def normalize_filepath(ref)
+        ref.is_a?(Symbol) ? expand_client_code_path(ref) : ref
       end
     end
   end

data/lib/netzke/core/client_code.rb

@@ -0,0 +1,157 @@
+module Netzke::Core
+  # Client class definition and instantiation.
+  module ClientCode
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Configures client class
+      # Example:
+      #
+      #   client_class do |c|
+      #     # c is an instance of ClientClassConfig
+      #     c.title = "My title"
+      #     c.require :extra_js
+      #     # ...etc
+      #   end
+      #
+      # For more details see {Netzke::Core::ClientClassConfig}
+      def client_class &block
+        raise ArgumentError, "client_class called without block" unless block_given?
+        @configure_blocks ||= []
+        @configure_blocks << [block, dir(caller.first)]
+      end
+
+      # Class-level client class config.
+      # Note: late evaluation of `client_class` blocks allows us using class-level configs in those blocks, e.g.:
+      #
+      #     class ConfigurableOnClassLevel < Netzke::Base
+      #       class_attribute :title
+      #       self.title = "Default"
+      #       client_class do |c|
+      #         c.title = self.title
+      #       end
+      #     end
+      #
+      #     ConfigurableOnClassLevel.title = "Overridden"
+      def client_class_config
+        return @client_class_config if @client_class_config
+
+        @client_class_config = Netzke::Core::ClientClassConfig.new(self, called_from)
+
+        (@configure_blocks || []).each do |block, dir|
+          @client_class_config.dir = dir
+          block.call(@client_class_config) if block
+        end
+
+        @client_class_config
+      end
+
+      # Path to the dir with this component/extension's extra code (ruby modules, scripts, stylesheets)
+      def dir(cllr)
+        %Q(#{cllr.split(".rb:").first})
+      end
+    end
+
+    # Builds {#js_config} used for instantiating a client class. Override it when you need to extend/modify the config for the JS component intance. It's *not* being called when the *server* class is being instantiated (e.g. to process an endpoint call). With other words, it's only being called before a component is first being loaded in the browser. so, it's ok to do heavy stuf fhere, like building a tree panel nodes from the database.
+    def configure_client(c)
+      c.merge!(normalized_config)
+
+      %w[id item_id path netzke_components endpoints xtype alias i18n netzke_plugins].each do |thing|
+        js_thing = send(:"js_#{thing}")
+        c[thing] = js_thing if js_thing.present?
+        c.client_config = client_config.netzke_literalize_keys # because this is what we'll get back from client side as server config, and the keys must be snake_case
+      end
+
+      # reset component session
+      # TODO: also remove empty hashes from the global session
+      component_session.clear
+    end
+
+    def js_path
+      @path
+    end
+
+    # Global id in the component tree, following the double-underscore notation, e.g. +books__config_panel__form+
+    def js_id
+      @js_id ||= parent.nil? ? @item_id : [parent.js_id, @item_id].join("__")
+    end
+
+    def js_xtype
+      self.class.client_class_config.xtype
+    end
+
+    def js_item_id
+      @item_id
+    end
+
+    # Ext.createByAlias may be used to instantiate the component.
+    def js_alias
+      self.class.client_class_config.class_alias
+    end
+
+    def js_endpoints
+      self.class.endpoints.keys.map{ |p| p.to_s.camelcase(:lower) }
+    end
+
+    def js_netzke_plugins
+      plugins.map{ |p| p.to_s.camelcase(:lower) }
+    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.
+    # Not to be overridden, override {#configure_client} instead.
+    def js_config
+      @js_config ||= ActiveSupport::OrderedOptions.new.tap{|c| configure_client(c)}
+    end
+
+    # Hash containing configuration for all child components to be instantiated at the JS side
+    def js_components
+      @js_components ||= eagerly_loaded_components.inject({}) do |out, name|
+        instance = component_instance(name.to_sym)
+        out.merge(name => instance.js_config)
+      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, excluding cached
+    # code.
+    # 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.client_class_config.xtype) ? r : r + k.client_class_config.code_with_dependencies
+      end
+      code.blank? ? nil : Netzke::Core::DynamicAssets.minify_js(code)
+    end
+
+    protected
+
+    # Allows referring to client-side function that will be called in the scope of the component. Handy to specify
+    # handlers for tools/actions, or any other functions that have to be passed as configuration to different Ext JS
+    # components. Usage:
+    #
+    #   class MyComponent < Netzke::Base
+    #     def configure(c)
+    #       super
+    #       c.bbar = [{text: 'Export', handler: f(:do_export)}]
+    #     end
+    #   end
+    #
+    #   As a result, `MyComponent`'s client-side `doExport` function will be called in the component's scope, receiving all the
+    #   usual handler parameters from Ext JS.
+    #   Read more on how to define client-side functions in `Netzke::Core::ClientClassConfig`.
+    def f(name)
+      Netzke::Core::JsonLiteral.new("function(){var c=Ext.getCmp('#{js_id}'); return c.#{name.to_s.camelize(:lower)}.apply(c, arguments);}")
+    end
+
+    private
+
+    # Merges all the translations in the class hierarchy
+    # Note: this method can't be moved out to ClientClassConfig, because I18n is loaded only once, when other Ruby classes are evaluated; so, this must remain at instance level.
+    def js_i18n
+      @js_i18n ||= self.class.netzke_ancestors.inject({}) do |r,klass|
+        hsh = klass.client_class_config.translated_properties.inject({}) { |h,t| h.merge(t => I18n.t("#{klass.i18n_id}.#{t}")) }
+        r.merge(hsh)
+      end
+    end
+  end
+end

data/lib/netzke/core/component_config.rb

@@ -6,8 +6,8 @@ module Netzke::Core
     end
 
     def set_defaults!
-      self.item_id ||= name # default item_id
-      self.klass ||= self.class_name.try(:constantize) || name.camelize.constantize # default klass
+      self.item_id ||= name
+      self.klass ||= self.class_name.try(:constantize) || name.camelize.constantize
     end
   end
 end

data/lib/netzke/core/composition.rb

@@ -46,7 +46,7 @@ module Netzke::Core
   #       ]
   #     end
   #
-  # If an extra (layout) configuration should be provided, a component can be referred to by using the +component+ key in the configuration hash (this can be useful when overriding a layout of a child component):
+  # If extra (layout) configuration is needed, a component can be referred to by using the +component+ key in the configuration hash (this can be useful when overriding a layout of a child component):
   #
   #     component :tab_one # ...
   #     component :tab_two # ...
@@ -61,11 +61,10 @@ module Netzke::Core
   #
   # == Lazily vs eagerly loaded components
   #
-  # By default, if a component is not used in the layout, it is lazily loaded, which means that the code for this component is not loaded in the browser until the moment the component gets dynamically loaded by the JavaScript method `netzkeLoadComponent` (see {Netzke::Core::Javascript}). Referring a component in the layout (the `items` property) automatically makes it eagerly loaded. Sometimes it's desired to eagerly load a component without using it directly in the layout (an example can be a window that we need to render instantly without requesting the server). In this case an option `eager_loading` can be set to true:
+  # By default, if a component is not used in the layout, it is lazily loaded, which means that the code for this component is not loaded in the browser until the moment the component gets dynamically loaded by the JavaScript method `netzkeLoadComponent` (see {Netzke::Core::ClientCode}). Referring a component in the layout (the `items` property) automatically makes it eagerly loaded. Sometimes it's desired to eagerly load a component without using it directly in the layout (an example can be a window that we need to render instantly without requesting the server). In this case an option `eager_load` can be set to true:
   #
-  #     component :eagerly_loaded_window do |c|
+  #     component :eagerly_loaded_window, eager_load: true do |c|
   #       c.klass = SomeWindowComponent
-  #       c.eager_loading = true
   #     end
   #
   # == Dynamic component loading
@@ -76,78 +75,107 @@ module Netzke::Core
   #
   # You can make a child component inavailable for dynamic loading by using the +excluded+ option. When an excluded component is used in the layout, it will be skipped.
   # This can be used for authorization.
+  #
+  # == Preventing name clashing with actions
+  #
+  # If a component has an action and a child component sharing the name, referring to them by symbols in the
+  # configuration will result in a name clash. In that case refer to the child component by a hash, e.g.:
+  #
+  #     class Dashboard < Netzke::Base
+  #       action :users
+  #
+  #       component :users
+  #
+  #       def configure(c)
+  #         super
+  #         c.bbar = [:users]
+  #         c.items = [{component: :users}]
+  #       end
+  #     end
   module Composition
     extend ActiveSupport::Concern
 
+    module ClassMethods
+      def component(name, options = {}, &block)
+        define_method :"#{name}_component", &(block || ->(c){c})
+        # NOTE: "<<" won't work here as this will mutate the array shared between classes
+        self.eagerly_loaded_dsl_components += [name] if options[:eager_load]
+      end
+    end
+
     included do
-      # Declares Base.component, for declaring child componets, and Base#components, which returns a [Hash] of all component configs by name
-      declare_dsl_for :components, config_class: Netzke::Core::ComponentConfig
+      # Hash of components declared inline in the config
+      attr_accessor :inline_components
 
-      attr_accessor :components_in_config
+      # Components declared in DSL and marked with `eager_load: true`
+      class_attribute :eagerly_loaded_dsl_components
+      self.eagerly_loaded_dsl_components = []
 
       # Loads a component on browser's request. Every Netzke component gets this endpoint.
       # +params+ should contain:
       #   [cache] an array of component classes cached at the browser
       #   [name] name of the child component to be loaded
       #   [index] clone index of the loaded component
-      endpoint :deliver_component do |params, this|
+      endpoint :deliver_component do |params|
         cache = params[:cache].split(",") # array of cached xtypes
         component_name = params[:name].underscore.to_sym
 
-        item_id = "#{component_name}#{params[:index]}"
-
-        cmp_instance = components[component_name] &&
-          !components[component_name][:excluded] &&
-          component_instance(component_name, {item_id: item_id, client_config: params[:client_config]})
+        item_id = params[:item_id]
+        cmp_instance = component_instance(component_name, {item_id: item_id, client_config: params[:client_config]})
 
         if cmp_instance
           js, css = cmp_instance.js_missing_code(cache), cmp_instance.css_missing_code(cache)
-          this.netzke_eval_js(js) if js.present?
-          this.netzke_eval_css(css) if css.present?
-
-          this.netzke_component_delivered(cmp_instance.js_config);
+          { js: js, css: css, config: cmp_instance.js_config }
         else
-          this.netzke_component_delivery_failed(item_id: item_id, msg: "Couldn't load component '#{item_id}'")
+          { error: "Couldn't load component '#{component_name}'" }
         end
       end
-
     end # included
 
-    # @return [Hash] configs of eagerly loaded components by name
+    # @return [Array] names of eagerly loaded components
     def eagerly_loaded_components
-      @eagerly_loaded_components ||= components.select{|k,v| components_in_config.include?(k) || v[:eager_loading]}
+      self.class.eagerly_loaded_dsl_components + @components_in_config
     end
 
     # Instantiates a child component by its name.
     # +params+ can contain:
     #   [client_config] a config hash passed from the client class
-    #   [item_id] overridden item_id (used in case of multi-instance loading)
-    def component_instance(name, options = {})
-      if respond_to?(:"#{name}_component")
-        cfg = ComponentConfig.new(name, self)
-        cfg.client_config = options[:client_config] || {}
-        cfg.item_id = options[:item_id]
-        cfg.js_id = options[:js_id]
-        send("#{name}_component", cfg)
-        cfg.set_defaults!
-      else
-        cfg = ComponentConfig.new(name, self)
-        cfg.merge!(components[name.to_sym])
-      end
-
-      component_instance_from_config(cfg) if cfg
+    #   [item_id] overridden item_id, used in case of loading multiple instances of the same child component
+    def component_instance(name_or_config, overrides = {})
+      cfg = name_or_config.is_a?(Hash) ? name_or_config : component_config(name_or_config, overrides)
+      return nil if cfg.nil? || cfg[:excluded]
+      klass = cfg.klass || cfg.class_name.constantize
+      klass.new(cfg, self)
     end
 
-    def component_instance_from_config(c)
-      klass = c.klass || c.class_name.constantize
-      klass.new(c, self)
+    # @return [Hash] Given component's name and overrides, returns complete component's config, ready for
+    # instantiation
+    def component_config(component_name, overrides = {})
+      return nil if component_name.nil?
+
+      component_name = component_name.to_sym
+
+      ComponentConfig.new(component_name, self).tap do |cfg|
+        cfg.client_config = overrides[:client_config] || {}
+        cfg.item_id = overrides[:item_id]
+
+        if respond_to?(:"#{component_name}_component")
+          send("#{component_name}_component", cfg)
+        elsif inline_components[component_name]
+          cfg.merge!(inline_components[component_name])
+        else
+          return nil
+        end
+
+        cfg.set_defaults!
+      end
     end
 
     # @return [Array<Class>] All component classes that we depend on (used to render all necessary javascripts and stylesheets)
     def dependency_classes
       res = []
 
-      eagerly_loaded_components.keys.each do |aggr|
+      eagerly_loaded_components.each do |aggr|
         res += component_instance(aggr).dependency_classes
       end
 
@@ -156,36 +184,28 @@ module Netzke::Core
     end
 
     def extend_item(item)
-      item = detect_and_normalize_component(item)
-      components_in_config << item[:netzke_component] if include_component?(item)
-      super item
+      super detect_and_normalize_component(item)
     end
 
   private
 
-    def include_component?(cmp_config)
-      cmp_config.is_a?(Hash) &&
-        cmp_config[:netzke_component] &&
-        cmp_config[:eager_loading] != false &&
-        !cmp_config[:excluded]
-    end
-
     def detect_and_normalize_component(item)
-      item = {component: item} if item.is_a?(Symbol) && components[item]
-      if item.is_a?(Hash) && component_name = item[:component]
-        cfg = components[component_name]
-        cfg.merge!(item)
-        if cfg[:excluded]
-          {excluded: true}
-        else
-          # cfg.merge(item).merge(netzke_component: item.delete(:component))
-          item.merge(netzke_component: cfg[:component]) # TODO: TEST THIS
-        end
-      elsif item.is_a?(Hash) && (item[:klass] || item[:class_name])
-        # declare component on the fly
-        component_name = :"component_#{@implicit_component_index += 1}"
-        components[component_name] = item.merge(eager_loading: true) unless item[:excluded]
-        {netzke_component: component_name}
+      item = {component: item} if item.is_a?(Symbol) && respond_to?(:"#{item}_component")
+      return item unless item.is_a?(Hash)
+      return nil if item[:excluded]
+
+      if item[:klass] || item[:class_name]
+        # declared inline
+        item_id = item[:item_id] || :"component_#{@implicit_component_index}"
+        @implicit_component_index += 1
+        # components[item_id] = item
+        inline_components[item_id.to_sym] = item
+        @components_in_config << item_id
+        {netzke_component: item_id}
+      elsif item_id = item.delete(:component)
+        return nil if component_config(item_id)[:excluded]
+        @components_in_config << item_id
+        item.merge(netzke_component: item_id)
       else
         item
       end