netzke-core 0.7.7 → 0.8.0

data/lib/netzke/composition.rb

@@ -1,224 +0,0 @@
-module Netzke
-  # This module takes care of components composition.
-  #
-  # You can define a nested component by calling the +component+ class method:
-  #
-  #     component :users, :data_class => "GridPanel", :model => "User"
-  #
-  # The method also accepts a block in case you want access to the component's instance:
-  #
-  #     component :books do
-  #       {:data_class => "Book", :title => build_title}
-  #     end
-  #
-  # To override a component, define a method {component_name}_component, e.g.:
-  #
-  #     def books_component
-  #       super.merge(:title => "Modified Title")
-  #     end
-  module Composition
-    extend ActiveSupport::Concern
-
-    COMPONENT_METHOD_NAME = "%s_component"
-
-    included do
-
-      # 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
-      # * <tt>:container</tt> - Ext id of the container where in which the component will be rendered
-      endpoint :deliver_component do |params|
-        cache = params[:cache].split(",") # array of cached xtypes
-        component_name = params[:name].underscore.to_sym
-        component = components[component_name] && component_instance(component_name)
-
-        if component
-          # inform the component that it's being loaded
-          component.before_load
-
-          [{
-            :eval_js => component.js_missing_code(cache),
-            :eval_css => component.css_missing_code(cache)
-          }, {
-            :component_delivered => component.js_config
-          }]
-        else
-          {:component_delivery_failed => {:component_name => component_name, :msg => "Couldn't load component '#{component_name}'"}}
-        end
-      end
-
-    end # included
-
-    module ClassMethods
-
-      # Defines a nested component.
-      def component(name, config = {}, &block)
-        register_component(name)
-        config = config.dup
-        config[:class_name] ||= name.to_s.camelize
-        config[:name] = name.to_s
-        method_name = COMPONENT_METHOD_NAME % name
-
-        if block_given?
-          define_method(method_name, &block)
-        else
-          if superclass.instance_methods.map(&:to_s).include?(method_name)
-            define_method(method_name) do
-              super().merge(config)
-            end
-          else
-            define_method(method_name) do
-              config
-            end
-          end
-        end
-      end
-
-      # DEPRECATED in favor of Symbol#component
-      # Component's js config used when embedding components as Container's items
-      # (see some_composite.rb for an example)
-      def js_component(name, config = {})
-        ::ActiveSupport::Deprecation.warn("Using js_component is deprecated. Use Symbol#component instead", caller)
-        config.merge(:component => name)
-      end
-
-      # Register a component
-      def register_component(name)
-        self.registered_components |= [name]
-      end
-
-    end
-
-    def items #:nodoc:
-      @items_with_normalized_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
-
-    def eager_loaded_components
-      components.reject{|k,v| v[:lazy_loading]}
-    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
-    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"
-    # 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
-
-          component_config = composite.components[cmp]
-          raise ArgumentError, "No child component '#{cmp}' defined for component '#{composite.global_id}'" if component_config.nil?
-
-          component_class_name = component_config[:class_name]
-          raise ArgumentError, "No class_name specified for component #{cmp} of #{composite.global_id}" if component_class_name.nil?
-
-          component_class = constantize_class_name(component_class_name)
-          raise ArgumentError, "Unknown constant #{component_class_name}" if component_class.nil?
-
-          instance_config = weak_children_config.merge(component_config).merge(strong_config).merge(:name => cmp)
-
-          composite = component_class.new(instance_config, composite) # params: config, parent
-        end
-        composite
-      end
-    end
-
-    # 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
-
-      res += self.class.class_ancestors
-
-      res << self.class
-      res.uniq
-    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
-    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 is_component_config?(c) #:nodoc:
-        !!(c.is_a?(Hash) && c[:class_name])
-      end
-
-  end
-end

data/lib/netzke/config_to_dsl_delegator.rb

@@ -1,43 +0,0 @@
-module Netzke
-  # This module allows delegating the configuration options for a component into the level of the component's class.
-  # As an example, let's take the :title option understood by any Ext.panel.Panel-derived component. Netzke::Base calls:
-  #
-  #     delegates_to_dsl :title
-  #
-  # which provides any child class with a DSL method `title` which can be used like this:
-  #
-  #     class MyComponent < Netzke::Base
-  #       title "My cool component"
-  #     end
-  #
-  # This will provide for :title => "My cool component" being a default option for MyComponent's instances.
-  #
-  # This is very handy when a frequently-inherited class implements some common option. Another example would be the :model option in Basepack::Grid/FormPanel. This way the child class will not need to mess up with the `default_config` method if all it needs is specify that default option.
-  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)
-        self.delegated_options |= option_names
-      end
-
-      def inherited(inherited_class) # :nodoc:
-        super
-
-        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

data/lib/netzke/configuration.rb

@@ -1,195 +0,0 @@
-module Netzke
-  # Handles all the intricate matters of component configuration.
-  # TODO: simplify!
-  module Configuration
-    extend ActiveSupport::Concern
-
-    CONFIGURATION_LEVELS = [:default, :initial, :independent, :session, :final]
-
-    included do
-      CONFIGURATION_LEVELS.each do |level|
-        define_method("weak_#{level}_options"){ {} }
-      end
-
-      class_attribute :default_config_attr
-      self.default_config_attr = {}
-
-    end
-
-    module ClassMethods
-      def setup
-        yield self
-      end
-
-      # Config options that should not go to the client side
-      def server_side_config_options
-        [:lazy_loading, :class_name, :components]
-      end
-
-      def config(*args, &block)
-        level = args.first.is_a?(Symbol) ? args.first : :final
-        config_hash = args.last.is_a?(Hash) && args.last
-        raise ArgumentError, "Config hash or block required" if !block_given? && !config_hash
-        if block_given?
-          define_method(:"weak_#{level}_options", &block)
-        else
-          define_method(:"weak_#{level}_options") do
-            config_hash
-          end
-        end
-      end
-
-      # Used to define class-level configuration options for a component, e.g.:
-      #
-      #     class Netzke::Basepack::GridPanel < Netzke::Base
-      #       class_config_option :rows_reordering_available, true
-      #       ...
-      #     end
-      #
-      # This can later be set in the application configuration:
-      #
-      #     module RailsApp
-      #       class Application < Rails::Application
-      #         config.netzke.basepack.grid_panel.rows_reordering_available = false
-      #         ...
-      #       end
-      #     end
-      #
-      # Configuration options can be accessed as class attributes:
-      #
-      #     Netzke::Basepack::GridPanel.rows_reordering_available # => false
-      def class_config_option(name, default_value)
-        value = if app_level_config.has_key?(name.to_sym)
-          if app_level_config[name.to_sym].is_a?(Hash) && default_value.is_a?(Hash)
-            default_value.deep_merge(app_level_config[name.to_sym])
-          else
-            app_level_config[name.to_sym]
-          end
-        else
-          default_value
-        end
-
-        class_attribute(name.to_sym)
-        self.send("#{name}=", value)
-      end
-
-      protected
-
-        def app_level_config
-          @app_level_config ||= class_ancestors.inject({}) do |r,klass|
-            r.deep_merge(klass.app_level_config_excluding_parents)
-          end
-        end
-
-        def app_level_config_excluding_parents
-          path_parts = name.split("::").map(&:underscore)[1..-1]
-          if path_parts.present?
-            path_parts.inject(Netzke::Core.config) do |r,part|
-              r.send(part)
-            end
-          else
-            {}
-          end
-        end
-
-    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
-
-    # 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
-
-    # 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
-
-    def session_config
-      @session_config ||= independent_config.merge(weak_session_options).merge(session_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 configuration
-      final_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 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 strong_parent_config
-      @strong_parent_config ||= parent.nil? ? {} : parent.strong_children_config
-    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_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_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 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