netzke-core 0.8.1 → 0.8.2

data/CHANGELOG.md

@@ -1,6 +1,21 @@
+# v0.8.2 - 2013-03-12
+* bug fix
+  * RuntimeError "can't add a new key into hash during iteration" in Composition in some scenarious (thanks @wupdiwup)
+  * netzkeReload works again
+
+* improvements
+  * minimize core Ruby class extensions
+  * tests can now be run by simply executing `rake` from the gem's root (thanks @allomov)
+  * feedback delay is now globally configurable
+  * netzkeFeedback now understands {delay: seconds} as second parameter
+  * add support for arbitrary controllers replacing NetzkeController
+  * add support for HAML templates
+  * some code refactoring
+  * tests are rewritten with Mocha.js and CoffeeScript
+
 # v0.8.1 - 2012-12-15
 * bug fix
-  * in production, JS comment stripping could cause modification of form_authenticity_token (issue #43) - by @scho
+  * in production, JS comment stripping could cause modification of form_authenticity_token (issue #43) (thanks @scho)
 
 # v0.8.0 - 2012-12-09
 ## Misc

data/Gemfile

@@ -0,0 +1,12 @@
+source 'http://rubygems.org'
+
+gemspec
+
+gem 'haml'
+
+group :test do
+  gem 'capybara'
+  gem 'database_cleaner'
+  gem 'rspec-rails'
+  gem 'pry-rails'
+end

data/README.md

@@ -1,4 +1,4 @@
-# Netzke Core [![Build Status](https://secure.travis-ci.org/nomadcoder/netzke-core.png?branch=master)](http://travis-ci.org/nomadcoder/netzke-core) [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/netzke/netzke-core)
+# Netzke Core [![Gem Version](https://fury-badge.herokuapp.com/rb/netzke-core.png)](http://badge.fury.io/rb/netzke-core) [![Build Status](https://travis-ci.org/netzke/netzke-core.png?branch=master)](https://travis-ci.org/netzke/netzke-core) [![Code Climate](https://codeclimate.com/github/netzke/netzke-core.png)](https://codeclimate.com/github/netzke/netzke-core)
 
 [RDocs](http://rdoc.info/projects/netzke/netzke-core)
 
@@ -31,6 +31,8 @@ All this extremely facilitates building fast, low-traffic, robust, and highly ma
 
 *This component is distributed as a part of the test application, see `test/core_test_app/components`.*
 
+Ext JS files are not distributed with Netzke, so, make sure that they are located in (or sym-linked as) `YOUR_APP/public/extjs`.
+
 In `YOUR_APP/components/hello_world.rb`:
 
 ```ruby
@@ -248,7 +250,7 @@ Actions can also be referred to is submenus:
   c.tbar = [{text: 'Menu', menu: {items: [:show_report]}}]
 ```
 
-For more details on composition refer to [Netzke::Core::Action](http://rdoc.info/github/netzke/netzke-core/Netzke/Core/Action).
+For more details on composition refer to [Netzke::Core::Actions](http://rdoc.info/github/netzke/netzke-core/Netzke/Core/Actions).
 
 ## Client-server interaction
 
@@ -285,7 +287,7 @@ An endpoint can instruct the client class to execute a set of methods after its
 ```ruby
 class SimpleComponent < Netzke::Base
   endpoint :whats_up_server do |params, this|
-    this.set_title("All quiet here on the server")
+    this.set_title("Response from server")
     this.my_method
   end
 end
@@ -317,6 +319,10 @@ Netzke Core will automatically include Ext JS localization files based on curren
 
 Also, Netzke Core uses some conventions for localizing actions. Refer to [Netzke::Core::Actions](http://rdoc.info/github/netzke/netzke-core/Netzke/Core/Actions).
 
+## HAML support (experimental)
+
+Netzke provides support for HAML templates in case you don't want to put HTML into Ruby files.
+
 ## Requirements
 
 * Ruby ~> 1.9.2
@@ -325,41 +331,42 @@ Also, Netzke Core uses some conventions for localizing actions. Refer to [Netzke
 
 ## Installation
 
-  $ gem install netzke-core
+    $ gem install netzke-core
 
 For the latest ("edge") stuff, instruct the bundler to get the gem straight from github:
 
 ```ruby
-gem 'netzke-core', git: "git://github.com/netzke/netzke-core.git"
+gem 'netzke-core', github: "netzke/netzke-core"
 ```
 
-By default, Netzke assumes that your Ext JS library is located in public/extjs. It can be a symbolic link, e.g.:
+By default, Netzke assumes that your Ext JS library is located in `public/extjs`. It can be a symbolic link, e.g.:
 
-    $ ln -s ~/code/sencha/ext-4.1.1 public/extjs
+    $ ln -s PATH/TO/YOUR/EXTJS/FILES public/extjs
 
 *(Make sure that the location of the license.txt distributed with Ext JS is exactly `public/extjs/license.txt`)*
 
 ## Running tests
 
-The bundled `test/core_test_app` application used for automated testing can be easily run as a stand-alone Rails app. It's a good source of concise, focused examples. After starting the application, access any of the test components (located in `app/components`) by using the following url:
+The bundled `test/core_test_app` application used for automated testing can be easily run as a stand-alone Rails app. It's a good source of concise, focused examples. After starting the application, access any of the test components (located in `test/core_test_app/app/components`) by using the following url:
 
     http://localhost:3000/components/{name of the component's class}
 
-For example [http://localhost:3000/components/ServerCaller](http://localhost:3000/components/ServerCaller)
+For example [http://localhost:3000/components/Endpoints](http://localhost:3000/components/Endpoints)
 
-Before being able run the test app and the tests themselves, you must link your Ext JS library to `test/core_test_app/public`, e.g. (from the gems's root):
+To run a specific Mocha JS spec (located in `spec/mocha`) for a component, append `?spec={name of spec}`, for example:
 
-    $ ln -s ~/code/sencha/ext-4.1.1 test/core_test_app/public/extjs
+    [http://localhost:3000/components/Endpoints?spec=endpoints](http://localhost:3000/components/Endpoints?spec=endpoints)
 
-For cucumber tests (from `test/core_test_app`):
+To run all the tests (from the gem's root):
 
-    $ cucumber features
+    $ rake
 
-For RSpec tests (from `test/core_test_app`):
+This assumes that the Ext JS library is located/symlinked in `test/core_test_app/public/extjs`. If you want to use Sencha CDN instead, run:
 
-    $ rspec spec
+    $ EXTJS_SRC=cdn rake
 
 ## Useful links
+
 * [Project website](http://netzke.org)
 * [Live demo](http://netzke-demo.herokuapp.com) (features [Netzke Basepack](https://github.com/netzke/netzke-basepack), with sample code)
 * [Twitter](http://twitter.com/netzke) - latest news about the framework

data/Rakefile

@@ -1,44 +1,25 @@
-begin
-  require 'jeweler'
-  require './lib/netzke/core/version'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.version = Netzke::Core::Version::STRING
-    gemspec.name = "netzke-core"
-    gemspec.summary = "Client-server GUI components with Sencha Ext JS and Ruby"
-    gemspec.description = "Allows building complex RIA by greatly facilitating modular development"
-    gemspec.email = "nmcoder@gmail.com"
-    gemspec.homepage = "http://netzke.org"
-    gemspec.authors = ["nomadcoder"]
-    gemspec.add_dependency("activesupport", ">=3.1.0")
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
+require "bundler/gem_tasks"
+require 'yard'
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/*_test.rb'
-  test.verbose = true
-end
+# Load tasks, that will be available for Rails user
+Dir[File.join(File.dirname(__FILE__), './lib/tasks/*.rake')].each { |file| load file }
 
-begin
-  require 'yard'
+# Load tasks for gem development
+Dir[File.join(File.dirname(__FILE__), 'tasks/*.rake')].each { |file| load file }
 
-  YARD::Rake::YardocTask.new do |t|
-    t.options = ['--title', "Netzke Core #{Netzke::Core::Version::STRING}"]
-  end
+YARD::Rake::YardocTask.new do |t|
+  t.options = ['--title', "Netzke Core #{Netzke::Core::Version::STRING}"]
+end
 
-  namespace :yard do
-    desc "Publish docs to api.netzke.org"
-    task publish: :yard do
-      dir = 'www/api.netzke.org/core'
-      puts "Publishing to fl:#{dir}..."
-      `ssh fl "mkdir -p #{dir}"`
-      `scp -r doc/* fl:#{dir}`
-    end
+namespace :yard do
+  desc "Publish docs to api.netzke.org"
+  task publish: :yard do
+    dir = 'www/api.netzke.org/core'
+    puts "Publishing to fl:#{dir}..."
+    `ssh fl "mkdir -p #{dir}"`
+    `scp -r doc/* fl:#{dir}`
   end
-rescue
-  puts "To enable yard do 'gem install yard'"
 end
+
+desc 'rake test'
+task default: :test

data/app/controllers/netzke_controller.rb

@@ -1,81 +1,3 @@
 class NetzkeController < ApplicationController
-  # Action for Ext.Direct RPC calls
-  def direct
-    result=""
-    error=false
-    if params['_json'] # this is a batched request
-      params['_json'].each do |batch|
-        result += result.blank? ? '[' : ', '
-        begin
-          result += invoke_endpoint(batch[:act], batch[:method].underscore, batch[:data].first, batch[:tid])
-        rescue Exception  => e
-          logger.error "!!! Netzke: Error invoking endpoint: #{batch[:act]} #{batch[:method].underscore} #{batch[:data].inspect} #{batch[:tid]}\n"
-          logger.error e.message
-          logger.error e.backtrace.join("\n")
-          error=true
-          break;
-        end
-      end
-      result+=']'
-    else # this is a single request
-      result=invoke_endpoint params[:act], params[:method].underscore, params[:data].first, params[:tid]
-    end
-    render :text => result, :layout => false, :status => error ? 500 : 200
-  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 invoke_endpoint(endpoint_path, action, params, tid)
-    component_name, *sub_components = endpoint_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])
-      result = component_instance.invoke_endpoint((sub_components + [action]).join("__"), params).to_nifty_json
-    else
-      result = {:netzke_component_not_in_session => true}.to_nifty_json
-    end
-
-    # 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 => result.present? && result.l || {}
-    }.to_json
-  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).to_nifty_json, :layout => false
-  end
-
+  include Netzke::Railz::ControllerExtensions
 end

data/javascripts/ext.js

@@ -22,25 +22,26 @@ Ext.QuickTips.init();
 
 // FeedbackGhost is a little class that displays unified feedback from Netzke components.
 Ext.define('Netzke.FeedbackGhost', {
-  showFeedback: function(msg){
-    if (!msg) Netzke.exception("Netzke.FeedbackGhost#showFeedback: wrong number of arguments (0 for 1)");
+  showFeedback: function(msg, options){
+    options = options || {};
+    options.delay = options.delay || Netzke.core.FeedbackDelay;
     if (Ext.isObject(msg)) {
-      this.msg(msg.level.camelize(), msg.msg);
+      this.msg(msg.level.camelize(), msg.msg, options.delay);
     } else if (Ext.isArray(msg)) {
       Ext.each(msg, function(m) { this.showFeedback(m); }, this);
     } else {
-      this.msg(null, msg); // no header for now
+      this.msg(null, msg, options.delay); // no header for now
     }
   },
 
-  msg: function(title, format){
+  msg: function(title, format, delay){
       if(!this.msgCt){
           this.msgCt = Ext.core.DomHelper.insertFirst(document.body, {id:'msg-div'}, true);
       }
       var s = Ext.String.format.apply(String, Array.prototype.slice.call(arguments, 1));
       var m = Ext.core.DomHelper.append(this.msgCt, this.createBox(title, s), true);
       m.hide();
-      m.slideIn('t').ghost("t", { delay: 1000, remove: true});
+      m.slideIn('t').ghost("t", { delay: delay, remove: true});
   },
 
   createBox: function(t, s){
@@ -356,12 +357,15 @@ Ext.define(null, {
   },
 
   /**
-   * Reloads current component (calls the parent to reload us as its component)
+   * Reloads itself by instructing the parent to call `netzkeLoadComponent`.
+   * Note: in order for this to work, the component must be nested in a container with the 'fit' layout.
   */
   netzkeReload: function(){
     var parent = this.netzkeGetParentComponent();
+
     if (parent) {
-      parent.netzkeLoadComponent({id:this.netzkeLocalId(parent), container:this.ownerCt.id});
+      var name = this.netzkeLocalId(parent);
+      parent.netzkeLoadComponent(name, {container:this.ownerCt.id});
     } else {
       window.location.reload();
     }
@@ -396,13 +400,13 @@ Ext.define(null, {
   /**
   * Provides a visual feedback. TODO: refactor
   */
-  netzkeFeedback: function(msg){
-    if (this.initialConfig && this.initialConfig.quiet) {
-      return false;
-    }
+  netzkeFeedback: function(msg, options){
+    if (this.initialConfig && this.initialConfig.quiet) return false;
+
+    options = options || {};
 
     if (this.feedbackGhost) {
-      this.feedbackGhost.showFeedback(msg);
+      this.feedbackGhost.showFeedback(msg, {delay: options.delay});
     } else {
       // there's no application to show the feedback - so, we do it ourselves
       if (typeof msg == 'string'){

data/lib/netzke/base.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext'
 require 'netzke/core/ruby_ext'
+require 'netzke/core/dsl_support'
 require 'netzke/core/javascript'
 require 'netzke/core/stylesheets'
 require 'netzke/core/services'
@@ -10,6 +11,7 @@ require 'netzke/core/state'
 require 'netzke/core/embedding'
 require 'netzke/core/actions'
 require 'netzke/core/session'
+require 'netzke/core/html' if Module.const_defined?(:Haml)
 
 module Netzke
   # The base class for every Netzke component. Its main responsibilities include:
@@ -43,6 +45,7 @@ module Netzke
   #
   # This doesn't necessarily have to be used in toolbars, but also in other places in config (i.e. layouts).
   class Base
+    include Core::DslSupport
     include Core::Session
     include Core::State
     include Core::Configuration
@@ -53,7 +56,9 @@ module Netzke
     include Core::Stylesheets
     include Core::Embedding
     include Core::Actions
+    include Core::Html if const_defined? :Haml
 
+    # DELETE ME
     class_attribute :default_instance_config
     self.default_instance_config = {}
 
@@ -104,8 +109,7 @@ module Netzke
 
     # Instantiates a component instance. A parent can optionally be provided.
     def initialize(conf = {}, parent = nil)
-      @passed_config = conf # configuration passed at the moment of instantiation
-      @passed_config.deep_freeze
+      @passed_config = conf.deep_dup # configuration passed at the moment of instantiation
       @parent        = parent
       @name          = conf[:name] || self.class.name.underscore
       @js_id         = parent.nil? ? @name : "#{parent.js_id}__#{@name}"

data/lib/netzke/core/action_config.rb

@@ -4,6 +4,8 @@ module Netzke::Core
   #   class MyComponent < Netzke::Base
   #     action :do_something do |c|
   #       c.text = "Do it!"
+  #       c.tooltip = "Do something"
+  #       c.icon = :tick
   #     end
   #   end
   class ActionConfig < ActiveSupport::OrderedOptions
@@ -14,6 +16,7 @@ module Netzke::Core
 
       build_localized_attributes
 
+      self.name = @name
       self.text = @text.presence || @name.humanize
       self.tooltip = @tooltip.presence || @name.humanize
       self.icon = @icon.to_sym if @icon.present?
@@ -23,6 +26,10 @@ module Netzke::Core
       self[:icon] = path.is_a?(Symbol) ? Netzke::Base.uri_to_icon(path) : path
     end
 
+    # later
+    def set_defaults!
+    end
+
   private
 
     def build_localized_attributes

data/lib/netzke/core/actions.rb

@@ -67,29 +67,12 @@ module Netzke::Core
   module Actions
     extend ActiveSupport::Concern
 
-    ACTION_METHOD_NAME = "%s_action"
-
     included do
-      # Returns registered actions
-      class_attribute :registered_actions
-      self.registered_actions = []
+      # Declares Base.action, for declaring actions, and Base#actions, which returns a [Hash] of all action configs by name
+      declare_dsl_for :actions
     end
 
     module ClassMethods
-      def action(name, &block)
-        self.registered_actions |= [name]
-
-        method_name = ACTION_METHOD_NAME % name
-
-        if block_given?
-          define_method(method_name, &block)
-        else
-          define_method(method_name) do |action_config|
-            action_config
-          end
-        end
-      end
-
       # Must stay public, used from ActionConfig
       # @return [String|nil] full URI to an icon file by its name (provided we have a controller)
       def uri_to_icon(icon)
@@ -97,24 +80,15 @@ module Netzke::Core
       end
     end
 
-    # All actions for this instance
-    def actions
-      @actions ||= self.class.registered_actions.inject({}) do |res, name|
-        action_config = Netzke::Core::ActionConfig.new(name, self)
-        send(ACTION_METHOD_NAME % name, action_config)
-        if action_config.excluded
-          res.merge(name.to_sym => {excluded: true})
-        else
-          res.merge(name.to_sym => action_config)
-        end
-      end
-    end
-
     def js_configure(c)
       super
       c.actions = actions
     end
 
+    def extend_item(item)
+      super detect_and_normalize(:action, item)
+    end
+
   private
     def uri_to_icon(icon)
       self.class.uri_to_icon(icon)

data/lib/netzke/core/client_class.rb

@@ -235,7 +235,7 @@ Netzke.cache.push('#{xtype}');
       end
 
       def properties_as_string
-        [properties.to_nifty_json.chop,  mixins_as_string].compact.join(",\n") + "}"
+        [properties.netzke_jsonify.to_json.chop,  mixins_as_string].compact.join(",\n") + "}"
       end
 
       # Default extended class

data/lib/netzke/core/component_config.rb

@@ -1,6 +1,6 @@
 module Netzke::Core
   class ComponentConfig < ActiveSupport::OrderedOptions
-    def initialize(name)
+    def initialize(name, parent)
       self.name = name.to_s
     end
 

data/lib/netzke/core/composition.rb

@@ -79,16 +79,10 @@ module Netzke::Core
   module Composition
     extend ActiveSupport::Concern
 
-    COMPONENT_METHOD_NAME = "%s_component"
-
-
     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
 
-      # Returns registered components
-      class_attribute :registered_components
-      self.registered_components = []
-
-      # @!method Foobar
       # Loads a component on browser's request. Every Netzke component gets this endpoint.
       # <tt>params</tt> should contain:
       # * <tt>:cache</tt> - an array of component classes cached at the browser
@@ -112,44 +106,6 @@ module Netzke::Core
 
     end # included
 
-    module ClassMethods
-
-      # Declares a child (nested) component.
-      # @param name [Symbol] component name
-      # @param block [Proc] config block
-      # @example
-      #   component :users do |c|
-      #     c.klass = Netzke::Basepack::Grid
-      #     c.modul = "User"
-      #   end
-      def component(name, &block)
-        self.registered_components |= [name]
-
-        method_name = COMPONENT_METHOD_NAME % name
-        if block_given?
-          define_method(method_name, &block)
-        else
-          define_method(method_name) do |component_config|
-            component_config
-          end
-        end
-      end
-    end
-
-    # @return [Hash] component configs by name
-    def components
-      @components ||= self.class.registered_components.inject({}) do |out, name|
-        component_config = Netzke::Core::ComponentConfig.new(name)
-        send(COMPONENT_METHOD_NAME % name, component_config)
-        component_config.set_defaults!
-        if component_config.excluded
-          out.merge(name.to_sym => {excluded: true})
-        else
-          out.merge(name.to_sym => component_config)
-        end
-      end
-    end
-
     # @return [Hash] configs of eagerly loaded components by name
     def eagerly_loaded_components
       @eagerly_loaded_components ||= components.select{|k,v| components_in_config.include?(k) || v[:eager_loading]}
@@ -163,30 +119,18 @@ module Netzke::Core
     # Called when the method_missing tries to processes a non-existing component. Override when needed.
     def component_missing(aggr)
       flash :error => "Unknown component #{aggr} for #{name}"
-      {:feedback => @flash}.to_nifty_json
+      {:feedback => @flash}.netzke_jsonify.to_json
     end
 
     # Recursively instantiates a child component based on its "path": e.g. if we have component :component1 which in its turn has component :component2, the path to the latter would be "component1__component2"
     # @param name [Symbol] component name
     def component_instance(name)
-      raise ArgumentError, "No component '#{name.inspect}' defined for '#{self.js_id}'" if !name.present?
-
-      @component_instance_cache ||= {}
-      @component_instance_cache[name] ||= begin
-        composite = self
-        name.to_s.split('__').each do |cmp|
-          cmp = cmp.to_sym
-
-          component_config = composite.components[cmp]
-          raise ArgumentError, "No component '#{cmp}' defined for '#{composite.js_id}'" if component_config.nil? || component_config[:excluded]
-
-          klass = component_config[:klass]
-
-          instance_config = component_config.merge(:name => cmp)
-
-          composite = klass.new(instance_config, composite) # params: config, parent
-        end
-        composite
+      @_component_instance ||= {} # memoization
+      @_component_instance[name] ||= name.to_s.split('__').inject(self) do |out, cmp_name|
+        cmp_config = out.components[cmp_name.to_sym]
+        raise ArgumentError, "No component '#{cmp_name}' defined for '#{out.js_id}'" if cmp_config.nil? || cmp_config[:excluded]
+        cmp_config[:name] = cmp_name
+        cmp_config[:klass].new(cmp_config, out)
       end
     end
 
@@ -218,57 +162,19 @@ module Netzke::Core
       end
     end
 
-  protected
-
-    # During normalization of the config object, this method 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.
-    # Override to do any additional checks/enhancements. See, for example, +Netzke::Basepack::WrapLazyLoaded+.
-    # @return [Object] extended item
     def extend_item(item)
-      # in a situation of action and component being equally named, action will take precedence
-
-      if item.is_a?(Symbol) && item_config = actions[item]
-        item = {netzke_action: item}
-      elsif item.is_a?(Symbol) && item_config = components[item]
-        item = {netzke_component: item}
-      end
-
-      item[:excluded] = true if item_config && item_config[:excluded]
-
-      if item.is_a?(Hash)
-        return nil if item[:excluded] # it'll get compacted away by Array#deep_map
-
-        # replace the `component` and `action` keys with `netzke_component` and `netzke_action`, which will be looked for at the JS side
-        item[:netzke_action] = item.delete(:action) if item[:action]
-        item[:netzke_component] = item.delete(:component) if item[:component]
-
-        @components_in_config << item[:netzke_component] if item[:netzke_component] && item[:eager_loading] != false
-      end
-
-      item
+      item = detect_and_normalize(:component, item)
+      @components_in_config << item[:netzke_component] if include_component?(item)
+      super item
     end
 
   private
 
-    # 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 = []
-      @normalized_config = config.dup.tap do |c|
-        c.each_pair do |k,v|
-          c.delete(k) if self.class.server_side_config_options.include?(k.to_sym)
-          c[k] = v.deep_map{|el| extend_item(el)} if v.is_a?(Array)
-        end
-      end
-    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
+    def include_component?(cmp_config)
+      cmp_config.is_a?(Hash) &&
+        cmp_config[:netzke_component] &&
+        cmp_config[:eager_loading] != false &&
+        !cmp_config[:excluded]
     end
-
   end
 end