netzke-core 0.7.5 → 0.7.6

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+gemfile:
+  - test/core_test_app/gemfiles/rails3_1.gemfile
+  - test/core_test_app/gemfiles/rails3_2.gemfile
+before_script: 
+  - chmod 777 ./config/ci/before-travis.sh
+  - ./config/ci/before-travis.sh
+script:
+  - export DISPLAY=:99.0
+  - cd test/core_test_app
+  - bundle exec rake db:create db:migrate RAILS_ENV=test
+  - bundle exec rspec spec
+  - bundle exec cucumber features
+branches:
+  only:
+    - master

data/CHANGELOG.rdoc

@@ -1,3 +1,6 @@
+= v0.7.6 - 2012-07-27
+* Rails 3.2
+
 = v0.7.5 - 2012-03-05
 * API changes
   * The :class_name option must *always* include the full class name now. So, "Basepack::GridPanel" won't work, instead do "Netzke::Basepack::GridPanel"

data/README.md

@@ -1,6 +1,8 @@
 # Netzke Core
 
-Netzke Core is the bare bones of the [Netzke framework](https://github.com/skozlov/netzke). For pre-built full-featured components (like grids, forms, tab/accordion panels, applications, etc), see [netzke-basepack](http://github.com/skozlov/netzke-basepack) (Ext JS).
+[![Build Status](https://secure.travis-ci.org/skozlov/netzke-core.png?branch=master)](http://travis-ci.org/skozlov/netzke-core)
+
+Netzke Core is the bare bones of the [Netzke framework](https://github.com/nomadcoder/netzke). For pre-built full-featured components (like grids, forms, tab/accordion panels, applications, etc), see [netzke-basepack](http://github.com/nomadcoder/netzke-basepack) (Ext JS).
 
 Netzke Core takes the burden of implementing the following key aspects of the framework:
 
@@ -15,23 +17,29 @@ Netzke Core takes the burden of implementing the following key aspects of the fr
 
 All this provides for fast, low-traffic, robust, highly maintainable applications.
 
+## Requirements
+
+* Ruby >= 1.9.2 (1.8.7 may work, too)
+* Rails ~> 3.1.0
+* Ext JS = 4.0.2a
+
 ## Getting started
 
-* Follow the simple [installation](https://github.com/skozlov/netzke-core/wiki/Installation) steps.
-* Learn how to build the [Hello World!](https://github.com/skozlov/netzke-core/wiki/Hello-world-extjs) component.
-* Dive into the [documentation](https://github.com/skozlov/netzke/wiki).
+* Follow the simple [installation](https://github.com/nomadcoder/netzke-core/wiki/Installation) steps.
+* Learn how to build the [Hello World!](https://github.com/nomadcoder/netzke-core/wiki/Hello-world-extjs) component.
+* Dive into the [documentation](https://github.com/nomadcoder/netzke/wiki).
 * Get help on the [Google Groups](http://groups.google.com/group/netzke).
 
 ## Testing and playing with Netzke Core
 
-Netzke Core is bundled with Cucumber and RSpec tests. If you would like to contribute to the project, you may want to learn how to [run the tests](https://github.com/skozlov/netzke-core/wiki/Automated-testing).
+Netzke Core is bundled with Cucumber and RSpec tests. If you would like to contribute to the project, you may want to learn how to [run the tests](https://github.com/nomadcoder/netzke-core/wiki/Automated-testing).
 
-Besides, the bundled test application is a convenient [playground](https://github.com/skozlov/netzke-core/wiki/Playground) for those who search to experiment with the framework.
+Besides, the bundled test application is a convenient [playground](https://github.com/nomadcoder/netzke-core/wiki/Playground) for those who search to experiment with the framework.
 
 ## Useful links
 * [Project website](http://netzke.org)
-* [Documentation](https://github.com/skozlov/netzke/wiki)
-* [Live-demo](http://demo.netzke.org) (features [Netzke Basepack](https://github.com/skozlov/netzke-basepack), with sample code)
+* [Documentation](https://github.com/nomadcoder/netzke/wiki)
+* [Live-demo](http://demo.netzke.org) (features [Netzke Basepack](https://github.com/nomadcoder/netzke-basepack), with sample code)
 * [Twitter](http://twitter.com/netzke) - latest news about the framework
 * [Author's twitter](http://twitter.com/nomadcoder) - author's rambling about OS X, productivity, lifestyle, and what not
 
@@ -43,4 +51,4 @@ With Rails 2 (and Ext 3 only), use versions 0.5.x (*not maintained*)
 
 ---
 Copyright (c) 2008-2011 NomadCoder, released under the MIT license
-Note, that Ext JS itself is licensed [differently](http://www.sencha.com/products/extjs/license/)
+Note, that Ext JS itself is licensed [differently](http://www.sencha.com/products/extjs/license/)

data/Rakefile

@@ -39,7 +39,11 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-require 'rake/rdoctask'
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rake/rdoctask'
+end
 Rake::RDocTask.new do |rdoc|
   require './lib/netzke/core/version'
   version = Netzke::Core::Version::STRING
@@ -56,4 +60,4 @@ namespace :rdoc do
   task :publish => :rdoc do
     `scp -r rdoc/* fl:www/api.netzke.org/core`
   end
-end
+end

data/config/ci/before-travis.sh

@@ -0,0 +1,11 @@
+# Start xvfb in preparation for cucumber
+sh -e /etc/init.d/xvfb start
+
+# fetch extjs
+wget http://cdn.sencha.io/ext-4.0.7-gpl.zip
+unzip -q -d test/core_test_app/public/ -n ext-4.0.7-gpl.zip
+mv test/core_test_app/public/ext-4.0.7-gpl test/core_test_app/public/extjs
+
+# cp db configuration
+cp test/core_test_app/config/database.yml.travis  test/core_test_app/config/database.yml
+

data/lib/netzke/actions.rb

@@ -36,6 +36,10 @@ module Netzke
 
     included do
       alias_method_chain :js_config, :actions
+
+      # Returns registered actions
+      class_attribute :registered_actions
+      self.registered_actions = []
     end
 
     module ClassMethods
@@ -61,14 +65,7 @@ module Netzke
 
       # Register an action
       def register_action(name)
-        current_actions = read_inheritable_attribute(:actions) || []
-        current_actions << name
-        write_inheritable_attribute(:actions, current_actions.uniq)
-      end
-
-      # Returns registered actions
-      def registered_actions
-        read_inheritable_attribute(:actions) || []
+        self.registered_actions |= [name]
       end
 
     end

data/lib/netzke/base.rb

@@ -1,5 +1,4 @@
 require 'active_support/core_ext'
-require 'active_support/memoizable'
 require 'netzke/core_ext'
 require 'netzke/javascript'
 require 'netzke/stylesheets'
@@ -58,8 +57,6 @@ module Netzke
     attr_reader :global_id
 
     class << self
-      extend ActiveSupport::Memoizable
-
       # Component's short class name, e.g.:
       # "Netzke::Module::SomeComponent" => "Module::SomeComponent"
       def short_component_class_name
@@ -67,7 +64,6 @@ module Netzke
       end
 
       # Component's class, given its name.
-      # Note: this method will be memoized if Rails.configuration.cache_classes is true.
       def constantize_class_name(class_name)
         class_name.constantize # used to be more complex than this, but appeared to be difficult to debug
       end

data/lib/netzke/composition.rb

@@ -1,5 +1,3 @@
-# require 'active_support/core_ext/class/inheritable_attributes'
-
 module Netzke
   # This module takes care of components composition.
   #
@@ -25,7 +23,11 @@ module Netzke
 
     included do
 
-      # Loads a component on browser's request. Every Nettzke component gets this endpoint.
+      # Returns registered components
+      class_attribute :registered_components
+      self.registered_components = []
+
+      # 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
       # * <tt>:id</tt> - reference to the component
@@ -87,60 +89,53 @@ module Netzke
 
       # Register a component
       def register_component(name)
-        current_components = read_inheritable_attribute(:components) || []
-        current_components << name
-        write_inheritable_attribute(:components, current_components.uniq)
-      end
-
-      # Returns registered components
-      def registered_components
-        read_inheritable_attribute(:components) || []
+        self.registered_components |= [name]
       end
 
     end
 
-    module InstanceMethods
-      extend ActiveSupport::Memoizable
-
-      def items #:nodoc:
-        @items_with_normalized_components
-      end
+    def items #:nodoc:
+      @items_with_normalized_components
+    end
 
-      # DEPRECATED in favor of Base.component
-      def initial_components
-        {}
-      end
+    # DEPRECATED in favor of Base.component
+    def initial_components
+      {}
+    end
 
-      # All components for this instance, which includes components defined on class level, and components detected in :items
-      def components
-        @components ||= self.class.registered_components.inject({}){ |res, name| res.merge(name.to_sym => send(COMPONENT_METHOD_NAME % name)) }.merge(config[:components] || {})
-      end
+    # All components for this instance, which includes components defined on class level, and components detected in :items
+    def components
+      @components ||= self.class.registered_components.inject({}){ |res, name| res.merge(name.to_sym => send(COMPONENT_METHOD_NAME % name)) }.merge(config[:components] || {})
+    end
 
-      def eager_loaded_components
-        components.reject{|k,v| v[:lazy_loading]}
-      end
+    def eager_loaded_components
+      components.reject{|k,v| v[:lazy_loading]}
+    end
 
-      # DEPRECATED
-      def add_component(aggr)
-        components.merge!(aggr)
-      end
+    # DEPRECATED
+    def add_component(aggr)
+      components.merge!(aggr)
+    end
 
-      # DEPRECATED
-      def remove_component(aggr)
-        if config[:persistent_config]
-          persistence_manager_class.delete_all_for_component("#{global_id}__#{aggr}")
-        end
-        components[aggr] = nil
+    # DEPRECATED
+    def remove_component(aggr)
+      if config[:persistent_config]
+        persistence_manager_class.delete_all_for_component("#{global_id}__#{aggr}")
       end
+      components[aggr] = nil
+    end
 
-      # Called when the method_missing tries to processes a non-existing component
-      def component_missing(aggr)
-        flash :error => "Unknown component #{aggr} for component #{name}"
-        {:feedback => @flash}.to_nifty_json
-      end
+    # Called when the method_missing tries to processes a non-existing component
+    def component_missing(aggr)
+      flash :error => "Unknown component #{aggr} for component #{name}"
+      {:feedback => @flash}.to_nifty_json
+    end
 
-      # Recursively instantiates a 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"
-      def component_instance(name, strong_config = {})
+    # Recursively instantiates a 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"
+    # TODO: strong_config should probably be thrown away, and is not taken into account when caching the results
+    def component_instance(name, strong_config = {})
+      @component_instance_cache ||= {}
+      @component_instance_cache[name] ||= begin
         composite = self
         name.to_s.split('__').each do |cmp|
           cmp = cmp.to_sym
@@ -160,72 +155,70 @@ module Netzke
         end
         composite
       end
+    end
 
-      memoize :component_instance # for performance
-
-      # All components that we depend on (used to render all necessary JavaScript and stylesheets)
-      def dependency_classes
-        res = []
+    # All components that we depend on (used to render all necessary JavaScript and stylesheets)
+    def dependency_classes
+      res = []
 
-        eager_loaded_components.keys.each do |aggr|
-          res += component_instance(aggr).dependency_classes
-        end
+      eager_loaded_components.keys.each do |aggr|
+        res += component_instance(aggr).dependency_classes
+      end
 
-        res += self.class.class_ancestors
+      res += self.class.class_ancestors
 
-        res << self.class
-        res.uniq
-      end
+      res << self.class
+      res.uniq
+    end
 
-      # DEPRECATED
-      def js_component(*args)
-        self.class.js_component(*args)
-      end
+    # DEPRECATED
+    def js_component(*args)
+      self.class.js_component(*args)
+    end
 
-      # Returns global id of a component in the hierarchy, based on passed reference that follows
-      # the double-underscore notation. Referring to "parent" is allowed. If going to far up the hierarchy will
-      # result in <tt>nil</tt>, while referring to a non-existent component will simply provide an erroneous ID.
-      # Example:
-      # <tt>parent__parent__child__subchild</tt> will traverse the hierarchy 2 levels up, then going down to "child",
-      # and further to "subchild". If such a component exists in the hierarchy, its global id will be returned, otherwise
-      # <tt>nil</tt> will be returned.
-      def global_id_by_reference(ref)
-        ref = ref.to_s
-        return parent && parent.global_id if ref == "parent"
-        substr = ref.sub(/^parent__/, "")
-        if substr == ref # there's no "parent__" in the beginning
-          return global_id + "__" + ref
-        else
-          return parent.global_id_by_reference(substr)
-        end
+    # Returns global id of a component in the hierarchy, based on passed reference that follows
+    # the double-underscore notation. Referring to "parent" is allowed. If going to far up the hierarchy will
+    # result in <tt>nil</tt>, while referring to a non-existent component will simply provide an erroneous ID.
+    # Example:
+    # <tt>parent__parent__child__subchild</tt> will traverse the hierarchy 2 levels up, then going down to "child",
+    # and further to "subchild". If such a component exists in the hierarchy, its global id will be returned, otherwise
+    # <tt>nil</tt> will be returned.
+    def global_id_by_reference(ref)
+      ref = ref.to_s
+      return parent && parent.global_id if ref == "parent"
+      substr = ref.sub(/^parent__/, "")
+      if substr == ref # there's no "parent__" in the beginning
+        return global_id + "__" + ref
+      else
+        return parent.global_id_by_reference(substr)
       end
+    end
 
-      protected
-
-        def normalize_components(items) #:nodoc:
-          @component_index ||= 0
-          @items_with_normalized_components = items.each_with_index.map do |item, i|
-            if is_component_config?(item)
-              component_name = item[:name] || :"netzke_#{@component_index}" # default name/item_id for child components
-              @component_index += 1
-              self.class.component(component_name.to_sym, item)
-              component_name.to_sym.component # replace current item with a reference to component
-            elsif item.is_a?(Hash)
-              item[:items].is_a?(Array) ? item.merge(:items => normalize_components(item[:items])) : item
-            else
-              item
-            end
+    protected
+
+      def normalize_components(items) #:nodoc:
+        @component_index ||= 0
+        @items_with_normalized_components = items.each_with_index.map do |item, i|
+          if is_component_config?(item)
+            component_name = item[:name] || :"netzke_#{@component_index}" # default name/item_id for child components
+            @component_index += 1
+            self.class.component(component_name.to_sym, item)
+            component_name.to_sym.component # replace current item with a reference to component
+          elsif item.is_a?(Hash)
+            item[:items].is_a?(Array) ? item.merge(:items => normalize_components(item[:items])) : item
+          else
+            item
           end
         end
+      end
 
-        def normalize_components_in_items #:nodoc:
-          normalize_components(config[:items]) if config[:items]
-        end
+      def normalize_components_in_items #:nodoc:
+        normalize_components(config[:items]) if config[:items]
+      end
 
-        def is_component_config?(c) #:nodoc:
-          !!(c.is_a?(Hash) && c[:class_name])
-        end
-    end
+      def is_component_config?(c) #:nodoc:
+        !!(c.is_a?(Hash) && c[:class_name])
+      end
 
   end
 end

data/lib/netzke/config_to_dsl_delegator.rb

@@ -16,26 +16,28 @@ module Netzke
   module ConfigToDslDelegator
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :delegated_options
+      self.delegated_options = []
+    end
+
     module ClassMethods
       # Delegates specified configuration options to the class level. See ConfigToDslDelegator.
       def delegates_to_dsl(*option_names)
-        delegated_options = read_inheritable_attribute(:delegated_options) || []
-        delegated_options += option_names
-        write_inheritable_attribute(:delegated_options, delegated_options)
+        self.delegated_options |= option_names
       end
 
       def inherited(inherited_class) # :nodoc:
         super
 
-        properties = read_inheritable_attribute(:delegated_options) || []
-        properties.size.times do |i|
-          inherited_class.class.send(:define_method, properties[i], lambda { |value|
-            default_config = read_inheritable_attribute(:default_config) || {}
-            default_config.merge!(properties[i].to_sym => value)
-            write_inheritable_attribute(:default_config, default_config)
+        properties = self.delegated_options
+        properties.each do |property|
+          inherited_class.class.send(:define_method, property, lambda { |value|
+            default_config = self.default_config_attr.dup
+            self.default_config_attr = default_config.merge(property.to_sym => value)
           })
         end
       end
     end
   end
-end
+end

data/lib/netzke/configuration.rb

@@ -10,6 +10,10 @@ module Netzke
       CONFIGURATION_LEVELS.each do |level|
         define_method("weak_#{level}_options"){ {} }
       end
+
+      class_attribute :default_config_attr
+      self.default_config_attr = {}
+
     end
 
     module ClassMethods
@@ -90,104 +94,102 @@ module Netzke
 
     end
 
-    module InstanceMethods
-      # Default config - before applying any passed configuration
-      def default_config
-        @default_config ||= {}.merge(weak_default_options).merge(self.class.default_instance_config).merge(self.class.read_inheritable_attribute(:default_config) || {})
-      end
-
-      # Static, hardcoded config. Consists of default values merged with config that was passed during instantiation
-      def initial_config
-        @initial_config ||= default_config.merge(weak_initial_options).merge(@passed_config)
-      end
+    # Default config - before applying any passed configuration
+    def default_config
+      @default_config ||= {}.merge(weak_default_options).merge(self.class.default_instance_config).merge(self.default_config_attr)
+    end
 
-      # Config that is not overridden by parents and sessions
-      def independent_config
-        @independent_config ||= initial_config.merge(weak_independent_options).merge(initial_config[:persistence] ? persistent_options : {})
-      end
+    # Static, hardcoded config. Consists of default values merged with config that was passed during instantiation
+    def initial_config
+      @initial_config ||= default_config.merge(weak_initial_options).merge(@passed_config)
+    end
 
-      def session_config
-        @session_config ||= independent_config.merge(weak_session_options).merge(session_options)
-      end
+    # Config that is not overridden by parents and sessions
+    def independent_config
+      @independent_config ||= initial_config.merge(weak_independent_options).merge(initial_config[:persistence] ? persistent_options : {})
+    end
 
-      # Last level config, overridden only by ineritance
-      def final_config
-        @strong_config ||= session_config.merge(weak_final_options).merge(strong_parent_config)
-      end
+    def session_config
+      @session_config ||= independent_config.merge(weak_session_options).merge(session_options)
+    end
 
-      def configuration
-        final_config
-      end
+    # Last level config, overridden only by ineritance
+    def final_config
+      @strong_config ||= session_config.merge(weak_final_options).merge(strong_parent_config)
+    end
 
-      # Resulting config that takes into account all possible ways to configure a component. *Read only*.
-      # Translates into something like this:
-      #
-      #     default_config.
-      #     deep_merge(@passed_config).
-      #     deep_merge(persistent_options).
-      #     deep_merge(strong_parent_config).
-      #     deep_merge(strong_session_config)
-      #
-      # Moved out to a separate method in order to provide for easy caching.
-      # *Do not override this method*, use +Base.config+ instead.
-      def config
-        @config ||= configuration
-      end
+    def configuration
+      final_config
+    end
 
-      def flat_config(key = nil)
-        fc = config.flatten_with_type
-        key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
-      end
+    # Resulting config that takes into account all possible ways to configure a component. *Read only*.
+    # Translates into something like this:
+    #
+    #     default_config.
+    #     deep_merge(@passed_config).
+    #     deep_merge(persistent_options).
+    #     deep_merge(strong_parent_config).
+    #     deep_merge(strong_session_config)
+    #
+    # Moved out to a separate method in order to provide for easy caching.
+    # *Do not override this method*, use +Base.config+ instead.
+    def config
+      @config ||= configuration
+    end
 
-      def strong_parent_config
-        @strong_parent_config ||= parent.nil? ? {} : parent.strong_children_config
-      end
+    def flat_config(key = nil)
+      fc = config.flatten_with_type
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
 
-      def flat_independent_config(key = nil)
-        fc = independent_config.flatten_with_type
-        key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
-      end
+    def strong_parent_config
+      @strong_parent_config ||= parent.nil? ? {} : parent.strong_children_config
+    end
 
-      def flat_default_config(key = nil)
-        fc = default_config.flatten_with_type
-        key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
-      end
+    def flat_independent_config(key = nil)
+      fc = independent_config.flatten_with_type
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
 
-      def flat_initial_config(key = nil)
-        fc = initial_config.flatten_with_type
-        key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
-      end
+    def flat_default_config(key = nil)
+      fc = default_config.flatten_with_type
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
 
-      # Like normal config, but stored in session
-      # def weak_session_config
-      #   component_session[:weak_session_config] ||= {}
-      # end
-      #
-      # def strong_session_config
-      #   component_session[:strong_session_config] ||= {}
-      # end
+    def flat_initial_config(key = nil)
+      fc = initial_config.flatten_with_type
+      key.nil? ? fc : fc.select{ |c| c[:name] == key.to_sym }.first.try(:value)
+    end
 
+    # Like normal config, but stored in session
+    # def weak_session_config
+    #   component_session[:weak_session_config] ||= {}
+    # end
+    #
+    # def strong_session_config
+    #   component_session[:strong_session_config] ||= {}
+    # end
 
 
-      # configuration of all children will get deep_merge'd with strong_children_config
-      # def strong_children_config= (c)
-      #   @strong_children_config = c
-      # end
 
-      # This config will be picked up by all the descendants
-      def strong_children_config
-        @strong_children_config ||= parent.nil? ? {} : parent.strong_children_config
-      end
+    # configuration of all children will get deep_merge'd with strong_children_config
+    # def strong_children_config= (c)
+    #   @strong_children_config = c
+    # end
 
-      # configuration of all children will get reverse_deep_merge'd with weak_children_config
-      # def weak_children_config= (c)
-      #   @weak_children_config = c
-      # end
+    # This config will be picked up by all the descendants
+    def strong_children_config
+      @strong_children_config ||= parent.nil? ? {} : parent.strong_children_config
+    end
 
-      def weak_children_config
-        @weak_children_config ||= {}
-      end
+    # configuration of all children will get reverse_deep_merge'd with weak_children_config
+    # def weak_children_config= (c)
+    #   @weak_children_config = c
+    # end
 
+    def weak_children_config
+      @weak_children_config ||= {}
     end
+
   end
 end

data/lib/netzke/core/version.rb

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

data/lib/netzke/core_ext/symbol.rb

@@ -14,4 +14,8 @@ class Symbol
   def component(config = {})
     config.merge(:netzke_component => self)
   end
+
+  def to_cls_attr
+    "__#{self}__".to_sym
+  end
 end