netzke-core 0.6.5 → 0.6.6

data/CHANGELOG.rdoc

@@ -1,3 +1,10 @@
+= v0.6.6 - 2011-02-26
+* enhancements
+  * Client-server communication is updated to use Ext.Direct (many thanks to @pschyska)
+  * Introduced +js_translate+ class method that allows specifying i18n properties used in the JavaScript class
+  * Better handling of actions i18n
+  * New `Netzke::Base.class_config_option` method to specify a class-level configuration options for a component, e.g. (in GridPanel): `class_config_option :column_filters_available, true`. This option then can be set in Rails application configuration, e.g.: `config.netzke.basepack.grid_panel.column_filters_available = false`, or directly on `Netzke::Core.config`, e.g.: `Netzke::Core.config.netzke.basepack.grid_panel.column_filters_available = false`.
+
 = v0.6.5 - 2011-01-14
 * enhancements
   * Various fixes for IE

data/TODO

@@ -1,9 +1,11 @@
+Make :items option understand also a hash.
 Caching for netzke_controller-provided JS and CSS.
 Caching - investigate reusing (fragment?) caching of Rails.
 Use Ext.Direct in the Netzke controller.
 Let specify per API point if it will use a GET or a POST request.
 
 
+
 = Ideas that didn't work out
 
 == Making value from super-class accessible in the block parameters in endpoints, e.g.:

data/app/controllers/netzke_controller.rb

@@ -1,8 +1,5 @@
 class NetzkeController < ApplicationController
 
-  # Collect javascripts and stylesheets from all plugins that registered it in Netzke::Core.javascripts
-  # TODO: caching
-  # caches_action :netzke
   def ext
     respond_to do |format|
       format.js {
@@ -69,33 +66,88 @@ class NetzkeController < ApplicationController
     end
   end
 
-
-  # Main dispatcher of the HTTP requests. 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 method_missing(method_name)
-    component_name, *action = method_name.to_s.split('__')
-    component_name = component_name.to_sym
-    action = !action.empty? && action.join("__").to_sym
-
-    if action
-      w_instance = Netzke::Base.instance_by_config(Netzke::Core.session[:netzke_components][component_name])
-      # only component's actions starting with "endpoint_" are accessible from outside (security)
-      endpoint_action = action.to_s.index('__') ? action : "_#{action}_ep_wrapper"
-      render :text => w_instance.send(endpoint_action, params), :layout => false
-    else
-      super
+  # 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], batch[:tid]
+        rescue Exception  => e
+          Rails.logger.error "!!! Netzke: Error invoking endpoint: #{batch[:act]} #{batch[:method].underscore} #{batch[:data].inspect} #{batch[:tid]}\n"
+          Rails.logger.error e.message
+          Rails.logger.error e.backtrace
+          error=true
+          break;
+        end
+      end
+      result+=']'
+    else # this is a single request
+      result=invoke_endpoint params[:act], params[:method].underscore, params[:data], params[:tid]
     end
+    render :text => result, :layout => false, :status => error ? 500 : 200
   end
 
-  private
+  # Action used by non-Ext.Direct (Touch) components
+  def dispatcher
+    endpoint_dispatch(params[:address])
+  end
+
+  protected
+
+    def invoke_endpoint component_name, action, data, tid
+      data=data[0] || {} # we get data as an array, extract the single argument if available
+
+      root_component_name, *sub_components = component_name.split('__')
+      root_component = Netzke::Base.instance_by_config Netzke::Core.session[:netzke_components][root_component_name.to_sym]
+      if sub_components.empty?
+        # we need to dispatch to root component, send it _#{action}_ep_wrapper
+        endpoint_action = "_#{action}_ep_wrapper"
+      else
+        # we need to dispatch to one or more sub_components, send subcomp__subsubcomp__endpoint to root component
+        endpoint_action = sub_components.join('__')+'__'+action
+      end
+      # send back JSON as specified in Ext.direct spec
+      #  => type: rpc
+      #  => tid, action, method as in the request, so that the client can mark the transaction and won't retry it
+      #  => result: JavaScript code from he endpoint result which gets applied to the client-side component instance
+      result = root_component.send(endpoint_action, data)
+
+      {:type => "rpc", :tid => tid, :action => component_name, :method => action, :result => result.present? && result.l || {}}.to_json
+    end
+
+    # Main dispatcher of old-style (Sencha Touch) HTTP requests. 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(method_name)
+      component_name, *action = method_name.to_s.split('__')
+      component_name = component_name.to_sym
+      action = !action.empty? && action.join("__").to_sym
+
+      if action
+        w_instance = Netzke::Base.instance_by_config(Netzke::Core.session[:netzke_components][component_name])
+        # only component's actions starting with "endpoint_" are accessible from outside (security)
+        endpoint_action = action.to_s.index('__') ? action : "_#{action}_ep_wrapper"
+        render :text => w_instance.send(endpoint_action, params), :layout => false
+      else
+        super
+      end
+    end
+
     # Generates initial javascript code that is dependent on Rails environement
     def initial_dynamic_javascript
       res = []
       res << %(Ext.Ajax.extraParams = {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.RelativeExtUrl = '#{ActionController::Base.config.relative_url_root}/extjs';}
+
+      # TODO: this will needs some DRYing
+      res << %{Netzke.core.directMaxRetries = '#{Netzke::Core.js_direct_max_retries}';}
+
       res.join("\n")
     end
 

data/features/actions.feature

@@ -9,5 +9,5 @@ Scenario: Pressing button should result in corresponding actions
   Then I should see "Disabled action"
   And button "Disabled action" should be disabled
 
-  When I press "Some action"
+  When I press "Some Cool Action"
   Then I should see "Some action was triggered"

data/features/component_loader.feature

@@ -14,11 +14,23 @@ Feature: Component loader
     Then I should see "Component loaded in window"
 
   @selenium
-  Scenario: Component loader should invoke a callback
+  Scenario: Component loader should invoke a callback in loadComponent
     Given I am on the ComponentLoader test page
     When I press "Load with feedback"
     Then I should see "Callback invoked!"
 
+  @selenium
+  Scenario: Component loader should invoke a generic endpoint callback
+    Given I am on the ComponentLoader test page
+    When I press "Load with generic callback"
+    Then I should see "Generic callback invoked!"
+
+  @selenium
+  Scenario: Component loader should invoke a generic endpoint callback
+    Given I am on the ComponentLoader test page
+    When I press "Load with generic callback and scope"
+    Then I should see "Fancy title set!"
+
   @selenium
   Scenario: Component loader should load a window component with another component in it
     Given I am on the ComponentLoader test page

data/features/ext.direct.feature

@@ -0,0 +1,32 @@
+Feature: Actions
+  In order to value
+  As a role
+  I want feature
+
+@javascript
+Scenario: Making seven consecutive endpoint calls within 10ms batches to one XHR
+  When I go to the ServerCounter test page
+  And I press "Count seven times"
+  Then total requests made should be 1
+
+@javascript
+Scenario: Doing two calls to different endpoints preserves the order in request and response
+  When I go to the ServerCounter test page
+  And I press "Do ordered"
+# "Second." is the indication that the result was applied to the client in the right order
+# "2" is the indication that the request were processed in the right order on the server side
+  Then I should see "Second. 2"
+
+@javascript
+Scenario: 2 out of 5 requests fail, but the retry mechanism should recover, and process them in order
+  Given I go to the ServerCounter test page
+  When I press "Fail two out of five"
+  Then I should see "1,2,3,4,5"
+
+@javascript
+Scenario: Updating 3 components (in one request)
+  Given I go to the ExtDirect::Composite test page
+  When I fill in "User:" with "Power User"
+  And I press "Update"
+  Then I should see "Details for user Power User"
+  And I should see "Statistics for user Power User"

data/features/i18n.feature

@@ -0,0 +1,32 @@
+Feature: I18n
+  In order to value
+  As a role
+  I want feature
+
+@javascript
+Scenario: LocalizedPanel should be available in 2 languages
+  When I go to the LocalizedPanel test page
+  Then I should see "Localized Panel"
+  And I should see "First property, Second property"
+  And I should see "First action"
+  And I should see "Second action"
+
+  When I go to the "es" version of the LocalizedPanel page
+  Then I should see "Panel Localizada"
+  And I should see "Primera propriedad, Segunda propriedad"
+  And I should see "Primera acción"
+  And I should see "Segunda acción"
+
+  When I go to the "es" version of the ExtendedLocalizedPanel page
+  Then I should see "Panel Localizada"
+  And I should see "Primera propriedad, Segunda propriedad"
+  And I should see "Action one"
+  And I should see "Segunda acción"
+
+  When I go to the "en" version of the ExtendedLocalizedPanel page
+  Then I should see "Localized Panel"
+  And I should see "First property, Second property"
+  And I should see "Action one"
+  And I should see "Second action"
+
+  # NOTE: make sure that the locale is restored to "en" in the end!

data/features/inheritance.feature

@@ -5,9 +5,9 @@ Feature: Inheritance
 
   @javascript
   Scenario: Inherited component should successfully call parent methods in Ruby and JavaScript
-    When I go to the ExtendedServerCaller test page
+    When I go to the "en" version of the ExtendedServerCaller page
     Then I should see "Extended Server Caller"
-    When I press "Call server"
+    When I press "Call server extensively"
     Then I should see "All quiet here on the server, shiny weather"
     And I should see "Added by extended Server Caller"
 

data/features/step_definitions/generic_steps.rb

@@ -6,10 +6,26 @@ When /^I execute "([^\"]*)"$/ do |script|
   page.driver.browser.execute_script(script)
 end
 
-Then /^button "([^\"]*)" should be disabled$/ do |arg1|
-  pending
+Then /^button "([^"]*)" should be enabled$/ do |arg1|
+  page.driver.browser.execute_script(<<-JS).should == true
+  var btn = Ext.ComponentMgr.all.filter('text', '#{arg1}').filter('type','button').first();
+  return typeof(btn)!='undefined' ? !btn.disabled : false
+  JS
 end
 
-When /^I sleep 1 second$/ do
-  sleep 1
-end
+Then /^button "([^"]*)" should be disabled$/ do |arg1|
+  page.driver.browser.execute_script(<<-JS).should == true
+  var btn = Ext.ComponentMgr.all.filter('text', '#{arg1}').filter('type','button').first();
+  return typeof(btn)!='undefined' ? btn.disabled : false
+  JS
+end
+
+When /^total requests made should be (\d+)$/ do |count|
+  page.driver.browser.execute_script(<<-JS).should == true
+    return Netzke.connectionCount == #{count};
+  JS
+end
+
+When /I sleep (\d+) seconds?/ do |arg1|
+  sleep arg1.to_i
+end

data/features/step_definitions/touch_steps.rb

@@ -0,0 +1,3 @@
+When /^I press button "([^"]*)"$/ do |action|
+  pending
+end

data/features/support/env.rb

@@ -27,6 +27,10 @@ require 'cucumber/rails/capybara_javascript_emulation' # Lets you click links wi
 # steps to use the XPath syntax.
 Capybara.default_selector = :css
 
+# Capybara.register_driver :selenium do |app|
+#   Capybara::Driver::Selenium.new(app, {:browser => :chrome } )
+# end
+
 # If you set this to false, any error raised from within your app will bubble
 # up to your step definition and out to cucumber unless you catch it somewhere
 # on the way. You can make Rails rescue errors and render error pages on a

data/features/support/paths.rb

@@ -32,6 +32,12 @@ module NavigationHelpers
     when /the (.*) test page/
       components_path(:component => $1)
 
+    when /the (.*) page for touch/
+      touch_components_path(:component => $1)
+
+    when /the "(.+)" version of the (.*) page/
+      components_path(:component => $2, :locale => $1)
+
     else
       begin
         page_name =~ /the (.*) page/

data/features/touch.feature

@@ -0,0 +1,10 @@
+Feature: Touch - to be run in Chrome only
+  In order to value
+  As a role
+  I want feature
+
+@javascript
+Scenario: Client-server communication
+  Given I am on the ServerCaller page for touch
+  When I press button "Bug server"
+  Then I should see "Hello from the server!"

data/javascripts/core.js

@@ -11,9 +11,9 @@ Ext.BLANK_IMAGE_URL = Netzke.RelativeExtUrl + "/resources/images/default/s.gif";
 Ext.ns('Ext.netzke'); // namespace for extensions that depend on Ext
 
 Netzke.isLoading=function () {
-  return Netzke.runningRequests!=0;
+  return Netzke.runningRequests != 0;
 }
-Netzke.runningRequests=0
+Netzke.runningRequests = 0;
 
 Netzke.deprecationWarning = function(msg){
   if (typeof console == 'undefined') {
@@ -108,17 +108,6 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
     // receiver.superclass.constructor.call(this, config);
   // },
 
-  /*
-  Dynamically creates methods for api points, so that we could later call them like: this.myEndpointMethod()
-  */
-  processEndpoints: function(){
-    var endpoints = this.endpoints || [];
-    endpoints.push('deliver_component'); // all Netzke components get this endpoint
-    Ext.each(endpoints, function(intp){
-      this[intp.camelize(true)] = function(args, callback, scope){ this.callServer(intp, args, callback, scope); }
-    }, this);
-  },
-
   /*
   Detects component placeholders in the passed object (typically, "items"),
   and merges them with the corresponding config from this.components.
@@ -217,8 +206,14 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
     return this.endpointUrl(endpoint);
   },
 
+  // endpointUrl: function(endpoint){
+  //   Netzke.deprecationWarning("endpointUrl() is deprecated. Use Ext.direct counterparts instead.\nFor example, specify a DirectProxy instead of HttpProxy ( proxy: new Ext.data.DirectProxy({directFn: Netzke.providers[this.id].endPoint}) ),\nor specify api instead of url config option for BasicForm ( api: { load: Netzke.providers[this.id].loadEndPoint, submit: Netzke.providers[this.id].submitEndPoint} )");
+  //   return Netzke.RelativeUrlRoot + "/netzke/" + this.id + "__" + endpoint;
+  // },
+
+  // Used by Touch components
   endpointUrl: function(endpoint){
-    return Netzke.RelativeUrlRoot + "/netzke/" + this.id + "__" + endpoint;
+    return Netzke.RelativeUrlRoot + "/netzke/dispatcher?address=" + this.id + "__" + endpoint;
   },
 
   // Does the call to the server and processes the response
@@ -239,10 +234,10 @@ Netzke.componentMixin = Ext.applyIf(Netzke.classes.Core.Mixin, {
             callback.apply(scope, [this.latestResult]);
           }
         }
+        Netzke.runningRequests--;
       },
       scope : this
     });
-    Netzke.runningRequests--;
   },
 
   setResult: function(result) {

data/javascripts/ext.js

@@ -15,6 +15,65 @@ Ext.state.Provider.prototype.set = function(){};
   }
 })();
 
+Netzke.classes.NetzkeRemotingProvider=Ext.extend(Ext.direct.RemotingProvider,{
+  getCallData: function(t){
+    return {
+      act: t.action, // rails doesn't really support having a parameter named "action"
+      method: t.method,
+      data: t.data,
+      type: 'rpc',
+      tid: t.tid
+    }
+  },
+
+  addAction: function(action, methods) {
+    var cls = this.namespace[action] || (this.namespace[action] = {});
+    for(var i = 0, len = methods.length; i < len; i++){
+        var m = methods[i];
+        cls[m.name] = this.createMethod(action, m);
+      }
+  },
+
+  // process response regardess of status
+  // i.e. in a batch request,
+  // - we request tids 1,2,3.
+  // - server is able to process 1 but not 2
+  // - server will stop and *not* process 3, because it could be dependant on 2 (this best possible approach to this
+  //   situation, as we don't have transactions)
+  // - server will respond with status 500, indicating a fault
+  // - in the response, server will respond with the result from tid 1
+  // - client marks tid 1 as success (deletes the transaction from pending), and will retry 2 and 3 - this is the
+  //   change in Ext.direct.RemotingProvider's default behaviour
+  onData: function(opt, success, xhr){
+    var events=this.getEvents(xhr);
+
+    for(var i = 0, len = events.length; i < len; i++){
+      var e = events[i],
+      t = this.getTransaction(e);
+      this.fireEvent('data', this, e);
+      if(t){
+        this.doCallback(t, e, true);
+        Ext.Direct.removeTransaction(t);
+      }
+    }
+
+    Netzke.classes.NetzkeRemotingProvider.superclass.onData.call(this, opt, success, xhr);
+  }
+
+});
+
+Netzke.directProvider = new Netzke.classes.NetzkeRemotingProvider({
+  "type": "remoting",       // create a Ext.direct.RemotingProvider
+  "url": Netzke.RelativeUrlRoot + "/netzke/direct/", // url to connect to the Ext.Direct server-side router.
+  "namespace": "Netzke.providers", // namespace to create the Remoting Provider in
+  "actions": {},
+  "maxRetries": Netzke.core.directMaxRetries,
+  "enableBuffer": true, // buffer/batch requests within 10ms timeframe
+  "timeout": 30000 // 30s timeout per request
+});
+
+Ext.Direct.addProvider(Netzke.directProvider);
+
 Ext.apply(Netzke.classes.Core.Mixin, {
   height: 400,
   border: false,
@@ -63,6 +122,38 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.initComponentWithoutNetzke();
   },
 
+  /*
+  Dynamically creates methods for endpoints, so that we could later call them like: this.myEndpointMethod() (using Ext.Direct)
+  */
+  processEndpoints: function(){
+    var endpoints = this.endpoints || [];
+    endpoints.push('deliver_component'); // all Netzke components get this endpoint
+    var directActions = [];
+    var that=this;
+
+    Ext.each(endpoints, function(intp){
+      directActions.push({"name":intp.camelize(true), "len":1});
+      //this[intp.camelize(true)] = function(args, callback, scope){ this.callServer(intp, args, callback, scope); }
+      this[intp.camelize(true)] = function(arg, callback, scope) {
+        Netzke.runningRequests++;
+        scope=scope || that;
+        Netzke.providers[this.id][intp.camelize(true)].call(typeof scope != 'undefined' ? scope : that, arg, function(result, remotingEvent) {
+          if(remotingEvent.message) {
+            console.error("RPC event indicates an error: ", remotingEvent);
+            throw new Error(remotingEvent.message);
+          }
+          that.bulkExecute(result); // invoke the endpoint result on the calling component
+          if(typeof callback == "function") {
+            callback.call(scope, that.latestResult); // invoke the callback on the provided scope, or on the calling component if no scope set. Pass latestResult to callback
+          }
+          Netzke.runningRequests--;
+        });
+      }
+    }, this);
+
+    Netzke.directProvider.addAction(this.id, directActions);
+  },
+
   normalizeTools: function() {
     if (this.tools) {
       var normTools = [];
@@ -87,7 +178,7 @@ Ext.apply(Netzke.classes.Core.Mixin, {
       this.addEvents(name+'click');
 
       // Configure the action
-      var actionConfig = this.actions[name];
+      var actionConfig = Ext.apply({}, this.actions[name]); // do not modify original this.actions
       actionConfig.customHandler = actionConfig.handler;
       actionConfig.handler = this.actionHandler.createDelegate(this); // handler common for all actions
       actionConfig.name = name;

data/javascripts/touch.js

@@ -15,6 +15,17 @@ Ext.apply(Netzke.classes.Core.Mixin, {
     this.initComponentWithoutNetzke();
   },
 
+  /*
+  Dynamically creates methods for api points, so that we could later call them like: this.myEndpointMethod()
+  */
+  processEndpoints: function(){
+    var endpoints = this.endpoints || [];
+    endpoints.push('deliver_component'); // all Netzke components get this endpoint
+    Ext.each(endpoints, function(intp){
+      this[intp.camelize(true)] = function(args, callback, scope){ this.callServer(intp, args, callback, scope); }
+    }, this);
+  },
+
   /*
   Detects action configs in the passed object, and replaces them with instances of Ext.Action created by normalizeActions().
   This detects action in arbitrary level of nesting, which means you can put any other components in your toolbar, and inside of them specify menus/items or even toolbars.

data/lib/netzke/actions.rb

@@ -85,16 +85,21 @@ module Netzke
     private
 
       def normalize_action_config(config)
-        if config[:icon].is_a?(Symbol)
-          config[:icon] = uri_to_icon(config[:icon])
-        end
+        config.tap do |c|
+          if c[:icon].is_a?(Symbol)
+            c[:icon] = uri_to_icon(c[:icon])
+          end
 
-        # Default text and tooltip
-        default_text = I18n.t(i18n_id + ".actions." + config[:name], :default => config[:name].humanize)
-        config[:text] ||= default_text
-        config[:tooltip] ||= I18n.t(i18n_id + ".actions." + config[:name] + "_tooltip", :default => default_text)
+          # Default text and tooltip
+          c[:text] ||= c[:name].humanize
+          c[:tooltip] ||= c[:name].humanize
 
-        config
+          # If we have an I18n for it, use it
+          default_text = I18n.t(i18n_id + ".actions." + c[:name], :default => "")
+          c[:text] = default_text if default_text.present?
+          default_tooltip = I18n.t(i18n_id + ".actions." + c[:name] + "_tooltip", :default => default_text)
+          c[:tooltip] = default_tooltip if default_tooltip.present?
+        end
       end
 
       def uri_to_icon(icon)

data/lib/netzke/base.rb

@@ -3,6 +3,7 @@ require 'active_support/memoizable'
 require 'netzke/core_ext'
 require 'netzke/javascript'
 require 'netzke/stylesheets'
+require 'netzke/inheritance'
 require 'netzke/services'
 require 'netzke/composition'
 require 'netzke/configuration'
@@ -15,29 +16,32 @@ module Netzke
   # The base for every Netzke component
   #
   # == Class-level configuration
-  # You can configure any component's class as follows:
-  #     # e.g. in the initializers/netzke.rb
-  #     MyComponent.setup do |config|
-  #       config.default_instance_config = { :some_option => true }
-  #     end
+  # You can configure component classes in Rails Application, e.g.:
+  #
+  #     config.netzke.basepack.grid_panel.column_filters_available = false
+  #
+  # Optionally, when used outside of Rails, you can also set the values directly on Netzke::Core.config (the Engine does it for you):
+  #
+  #     Netzke::Core.config.netzke.basepack.grid_panel.column_filters_available = false
+  #
+  # If both default and overriding values are hashes, the default value gets deep-merged with the overriding value.
   #
   # Netzke::Base provides the following class-level configuration options:
-  # * default_instance_config - a hash that will be used as default configuration for this component's instances
+  # * default_instance_config - a hash that will be used as default configuration for ALL of this component's instances.
   class Base
-
-    class_attribute :default_instance_config
-    self.default_instance_config = {}
-
     include Session
     include State
     include Configuration
     include Javascript
+    include Inheritance
     include Services
     include Composition
     include Stylesheets
     include Embedding
     include Actions
 
+    class_config_option :default_instance_config, {}
+
     # Parent component
     attr_reader :parent
 
@@ -73,42 +77,11 @@ module Netzke
         (config[:klass] || constantize_class_name(config[:class_name])).new(config)
       end
 
-      # All ancestor classes in the Netzke class hierarchy (i.e. up to Netzke::Base)
-      def class_ancestors
-        if self == Netzke::Base
-          []
-        else
-          superclass.class_ancestors + [self]
-        end
-      end
-
-      # Same as +read_inheritable_attribute+ returning a hash, but returns empty hash when it's equal to superclass's
-      def read_clean_inheritable_hash(attr_name)
-        res = read_inheritable_attribute(attr_name) || {}
-        # We don't want here any values from the superclass (which is the consequence of using inheritable attributes).
-        res == self.superclass.read_inheritable_attribute(attr_name) ? {} : res
-      end
-
-      # Same as +read_inheritable_attribute+ returning a hash, but returns empty hash when it's equal to superclass's
-      def read_clean_inheritable_array(attr_name)
-        res = read_inheritable_attribute(attr_name) || []
-        # We don't want here any values from the superclass (which is the consequence of using inheritable attributes).
-        res == self.superclass.read_inheritable_attribute(attr_name) ? [] : res
+      # 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 self.total_instances
-      @@instances || 0
-    end
-
-    def self.reset_total_instances
-      @@instances = 0
-    end
-
-    def self.increase_total_instances
-      @@instances ||= 0
-      @@instances += 1
     end
 
     # Instantiates a component instance. A parent can optionally be provided.
@@ -147,7 +120,21 @@ module Netzke
     end
 
     def i18n_id
-      self.class.name.split("::").map{|c| c.underscore}.join(".")
+      self.class.i18n_id
+    end
+
+    # Used for performance measurments
+    def self.total_instances
+      @@instances || 0
+    end
+
+    def self.reset_total_instances
+      @@instances = 0
+    end
+
+    def self.increase_total_instances
+      @@instances ||= 0
+      @@instances += 1
     end
 
     private