netzke-core 0.5.5 → 0.6.0

data/lib/netzke/composition.rb

@@ -0,0 +1,251 @@
+# require 'active_support/core_ext/class/inheritable_attributes'
+
+module Netzke
+  module Composition
+    extend ActiveSupport::Concern
+    
+    included do
+      
+      # Loads a component on browser's request. Every Nettzke 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].gsub(".", "::").split(",") # array of cached class names (in Ruby)
+        component_name = params.delete(: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
+          {:feedback => "Couldn't load component '#{component_name}'"}
+        end
+      end
+      
+    end # included
+    
+    module ClassMethods
+      
+      # Defines a nested component.
+      # For example:
+      # 
+      #     component :users, :data_class => "GridPanel", :model => "User"
+      # 
+      # It can also accept a block (receiving as parameter the eventual definition from super class):
+      # 
+      #     component :books do |orig|
+      #       {:data_class => "Book", :title => orig[:title] + ", extended"}
+      #     end
+      def component(name, config = {}, &block)
+        config = config.dup
+        config[:class_name] ||= name.to_s.camelize
+        config[:name] = name.to_s
+        method_name = "_#{name}_component"
+        
+        if block_given?
+          define_method(method_name, &block)
+        else
+          define_method(method_name) do
+            config
+          end
+        end
+      end
+      
+      # Component's js config used when embedding components as Container's items 
+      # (see some_composite.rb for an example)
+      def js_component(name, config = {})
+        config.merge(:component => name)
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def items
+        @items_with_normalized_components
+      end
+      
+      def initial_components
+        {}
+      end
+      
+      # All components for this instance, which includes components defined on class level, and components detected in :items
+      def components
+        # items if @components.nil? # simply trigger collecting @components from items
+        # self.class.components.merge(@components || {})
+        
+        @components ||= begin
+          method_regexp = /^_(.+)_component$/
+          self.class.instance_methods.grep(method_regexp).inject({}) do |r, m|
+            m.match(method_regexp)
+            r.merge($1.to_sym => send(m))
+          end
+        end
+      end
+
+      def non_late_components
+        components.reject{|k,v| v[:lazy_loading]}
+      end
+
+      def add_component(aggr)
+        components.merge!(aggr)
+      end
+
+      def remove_component(aggr)
+        if config[:persistent_config]
+          persistence_manager_class.delete_all_for_component("#{global_id}__#{aggr}")
+        end
+        components[aggr] = nil
+      end
+
+      # The difference between components and late components is the following: the former gets instantiated together with its composite and is normally *instantly* visible as a part of it (for example, the component in the initially expanded panel in an Accordion). A late component doesn't get instantiated along with its composite. Until it gets requested from the server, it doesn't take any part in its composite's life. An example of late component could be a component that is loaded dynamically into a previously collapsed panel of an Accordion, or a preferences window (late component) for a component (composite) that only gets shown when user wants to edit component's preferences.
+      def initial_late_components
+        {}
+      end
+
+      def add_late_component(aggr)
+        components.merge!(aggr.merge(:lazy_loading => true))
+      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 an component based on its "path": e.g. if we have an component :aggr1 which in its turn has an component :aggr10, the path to the latter would be "aggr1__aggr10"
+      def component_instance(name, strong_config = {})
+        @cached_component_instances ||= {}
+        @cached_component_instances[name] ||= begin
+          composite = self
+          name.to_s.split('__').each do |aggr|
+            aggr = aggr.to_sym
+            component_config = composite.components[aggr]
+            raise ArgumentError, "No component '#{aggr}' defined for component '#{composite.global_id}'" if component_config.nil?
+            short_component_class_name = component_config[:class_name]
+            raise ArgumentError, "No class_name specified for component #{aggr} of #{composite.global_id}" if short_component_class_name.nil?
+            component_class = constantize_class_name(short_component_class_name)
+
+            conf = weak_children_config.
+              deep_merge(component_config).
+              deep_merge(strong_config). # we may want to reconfigure the component at the moment of instantiation
+              merge(:name => aggr)
+
+            composite = component_class.new(conf, composite) # params: config, parent
+            # composite.weak_children_config = weak_children_config
+            # composite.strong_children_config = strong_children_config
+          end
+          composite
+        end
+      end
+      
+      def dependency_classes
+        res = []
+        
+        non_late_components.keys.each do |aggr|
+          res += component_instance(aggr).dependency_classes
+        end
+        
+        res += self.class.class_ancestors
+        
+        res << self.class
+        res.uniq
+      end
+
+      ## Dependencies
+      # def dependencies
+      #   @dependencies ||= begin
+      #     non_late_components_component_classes = non_late_components.values.map{|v| v[:class_name]}
+      #     (initial_dependencies + non_late_components_component_classes << self.class.short_component_class_name).uniq
+      #   end
+      # end
+
+      # override this method if you need some extra dependencies, which are not the components
+      def initial_dependencies
+        []
+      end
+
+      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
+
+      # Method dispatcher - instantiates an component and calls the method on it
+      # E.g.: 
+      #   users__center__get_data
+      #     instantiates component "users", and calls "center__get_data" on it
+      #   books__move_column
+      #     instantiates component "books", and calls "endpoint_move_column" on it
+      def method_missing(method_name, params = {})
+        component, *action = method_name.to_s.split('__')
+        component = component.to_sym
+        action = !action.empty? && action.join("__").to_sym
+
+        if action
+          if components[component]
+            # only actions starting with "endpoint_" are accessible
+            endpoint_action = action.to_s.index('__') ? action : "endpoint_#{action}"
+            component_instance(component).send(endpoint_action, params)
+          else
+            component_missing(component)
+          end
+        else
+          super
+        end
+      end
+      
+      private
+        
+        def normalize_components(items)
+          @component_index ||= 0
+          @items_with_normalized_components = items.each_with_index.map do |item, i|
+            if is_component_config?(item)
+              component_name = item[:name] || :"#{item[:class_name].underscore.split("/").last}#{@component_index}"
+              @component_index += 1
+              self.class.component(component_name.to_sym, item)
+              js_component(component_name) # 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
+          normalize_components(config[:items]) if config[:items]
+        end
+        
+        def is_component_config?(c)
+          !!(c.is_a?(Hash) && c[:class_name])
+        end
+    end
+    
+  end
+end

data/lib/netzke/configuration.rb

@@ -0,0 +1,134 @@
+module Netzke
+  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
+    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]
+      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
+  
+    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)
+      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(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
+
+      # 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 ||= 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
+
+      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
+end

data/lib/netzke/core/masquerading.rb

@@ -0,0 +1,34 @@
+module Netzke
+  module Core
+    module Masquerading
+      # Example:
+      #   masquarade_as(:role, 2)
+      #   masquarade_as(:user, 4)
+      #   masquarade_as(:world)
+      def masquerade_as(authority_level, authority_id = true)
+        reset_masquerading
+        session.merge!(:"masq_#{authority_level}" => authority_id)
+      end
+  
+      def reset_masquerading
+        session[:masq_world] = session[:masq_role] = session[:masq_user] = nil
+      end
+  
+      # Who are we acting as?
+      def authority_level
+        if session[:masq_world]
+          :world
+        elsif session[:masq_role]
+          [:role, session[:masq_role]]
+        elsif session[:masq_user]
+          [:user, session[:masq_user]]
+        elsif session[:netzke_user_id]
+          [:self, session[:netzke_user_id]]
+        else
+          :none # or nil ?
+        end
+      end
+    
+    end
+  end
+end

data/lib/netzke/core/session.rb

@@ -0,0 +1,30 @@
+module Netzke
+  module Core
+    module Session
+      # Access to controller sessions
+      def session
+        @@session ||= {}
+      end
+
+      def session=(s)
+        @@session = s
+      end
+
+      # Should be called by session controller at the moment of successfull login
+      def login
+        session[:_netzke_next_request_is_first_after_login] = true
+      end
+  
+      # Should be called by session controller at the moment of logout
+      def logout
+        session[:_netzke_next_request_is_first_after_logout] = true
+      end
+
+      # Register the configuration for the component in the session, and also remember that the code for it has been rendered
+      def reg_component(config)
+        session[:netzke_components] ||= {}
+        session[:netzke_components][config[:name]] = config
+      end
+    end
+  end
+end

data/lib/netzke/core/version.rb

@@ -0,0 +1,11 @@
+module Netzke
+  module Core
+    module Version
+      MAJOR = 0
+      MINOR = 6
+      PATCH = 0
+
+      STRING = [MAJOR, MINOR, PATCH].compact.join('.')
+    end
+  end
+end

data/lib/netzke/core.rb

@@ -0,0 +1,53 @@
+require 'active_support/core_ext'
+require 'netzke/core/version'
+require 'netzke/core/session'
+require 'netzke/core/masquerading'
+
+module Netzke
+  # You can configure Netzke::Core like this:
+  # 
+  #     Netzke::Core.setup do |config|
+  #       config.ext_location = "/home/netzke/ext-3.3.0"
+  #       config.icons_uri = "/images/famfamfam/icons"
+  #       # ...
+  #     end
+  # 
+  # The following configuration options are available:
+  # * ext_location - absolute path to your Ext code root
+  # * icons_uri - relative URI to the icons
+  # * javascript_on_main_page (true/false, defaults to false) - if you want the JS classes to be inserted into the code of the page,
+  # rather than into netzke.js (setting to true can be handy for debugging)
+  module Core
+    extend Session
+    extend Masquerading
+    
+    mattr_accessor :controller
+
+    mattr_accessor :javascripts
+    @@javascripts = ["#{File.dirname(__FILE__)}/../../javascripts/core.js"]
+
+    mattr_accessor :stylesheets
+    @@stylesheets = ["#{File.dirname(__FILE__)}/../../stylesheets/core.css"]
+    
+    mattr_accessor :external_css
+    @@external_css = []
+
+    mattr_accessor :ext_location
+    
+    mattr_accessor :with_icons
+    
+    mattr_accessor :icons_uri
+    @@icons_uri = "/images/icons"
+    
+    mattr_accessor :javascript_on_main_page
+    @@javascript_on_main_page = false
+    
+    def self.setup
+      yield self
+    end
+    
+    def self.reset_components_in_session
+      Netzke::Core.session[:netzke_components].try(:clear)
+    end
+  end
+end

data/lib/netzke/core_ext/array.rb

@@ -0,0 +1,30 @@
+class Array
+  def jsonify
+    self.map{ |el| el.instance_of?(Array) || el.instance_of?(Hash) ? el.jsonify : el }
+  end
+  
+  # Camelizes the keys of hashes and converts them to JSON
+  def to_nifty_json
+    self.recursive_delete_if_nil.jsonify.to_json
+  end
+  
+  # Applies deep_convert_keys to each element which responds to deep_convert_keys
+  def deep_convert_keys(&block)
+    block_given? ? self.map do |i|
+      i.respond_to?('deep_convert_keys') ? i.deep_convert_keys(&block) : i
+    end : self
+  end
+  
+  def deep_each_pair(&block)
+    self.each{ |el| el.respond_to?('deep_each_pair') && el.deep_each_pair(&block) }
+  end
+  
+  def recursive_delete_if_nil
+    self.map{|el| el.respond_to?('recursive_delete_if_nil') ? el.recursive_delete_if_nil : el}
+  end
+  
+  def deep_freeze
+    each { |j| j.deep_freeze if j.respond_to? :deep_freeze }
+    freeze
+  end
+end

data/lib/netzke/core_ext/hash.rb

@@ -0,0 +1,84 @@
+class Hash
+  def deep_each_pair(&block)
+    self.each_pair do |k,v|
+      v.respond_to?('deep_each_pair') ? v.deep_each_pair(&block) : yield(k,v)
+    end
+  end
+
+  # Recursively convert the keys. Example:
+  # {:bla_bla => 1, "wow_now" => {:look_ma => true}}.deep_convert_keys{|k| k.to_s.camelize.to_sym} 
+  #   => {:BlaBla => 1, "WowNow" => {:LookMa => true}}
+  def deep_convert_keys(&block)
+    block_given? ? self.inject({}) do |h,(k,v)|
+      h[yield(k)] = v.respond_to?('deep_convert_keys') ? v.deep_convert_keys(&block) : v
+      h
+    end : self
+  end
+
+  def jsonify
+    self.inject({}) do |h,(k,v)|
+      new_key = k.instance_of?(String) || k.instance_of?(Symbol) ? k.jsonify : k
+      new_value = v.instance_of?(Array) || v.instance_of?(Hash) ? v.jsonify : v
+      h.merge(new_key => new_value)
+    end
+  end
+  
+  # First camelizes the keys, then convert the whole hash to JSON
+  def to_nifty_json
+    self.recursive_delete_if_nil.jsonify.to_json
+  end
+  
+  # Converts values of a Hash in such a way that they can be easily stored in the database: hashes and arrays are jsonified, symbols - stringified
+  def deebeefy_values
+    inject({}) do |options, (k, v)|
+      options[k] = v.is_a?(Symbol) ? v.to_s : (v.is_a?(Hash) || v.is_a?(Array)) ? v.to_json : v
+      options
+    end
+  end
+
+  # We don't need to pass null values in JSON, they are null by simply being absent
+  def recursive_delete_if_nil
+    self.inject({}) do |h,(k,v)|
+      if !v.nil?
+        h[k] = v.respond_to?('recursive_delete_if_nil') ? v.recursive_delete_if_nil : v
+      end
+      h
+    end
+  end
+  
+  # add flatten_with_type method to Hash
+  def flatten_with_type(preffix = "")
+    res = []
+    self.each_pair do |k,v|
+      name = ((preffix.to_s.empty? ? "" : preffix.to_s + "__") + k.to_s).to_sym
+      if v.is_a?(Hash)
+        res += v.flatten_with_type(name)
+      else
+        res << {
+          :name => name, 
+          :value => v,
+          :type => (["TrueClass", "FalseClass"].include?(v.class.name) ? 'Boolean' : v.class.name).to_sym
+        }
+      end
+    end
+    res
+  end
+
+  def deep_freeze
+    each { |k,v| v.deep_freeze if v.respond_to? :deep_freeze }
+    freeze
+  end
+
+  # Javascrit-like access to Hash values
+  def method_missing(method, *args)
+    if method.to_s =~ /=$/ 
+      method_base = method.to_s.sub(/=$/,'').to_sym
+      key = self[method_base.to_s].nil? ? method_base : method_base.to_s
+      self[key] = args.first
+    else
+      key = self[method.to_s].nil? ? method : method.to_s
+      self[key]
+    end
+  end
+  
+end

data/lib/netzke/core_ext/string.rb

@@ -0,0 +1,26 @@
+class String
+  def jsonify
+    self.camelize(:lower)
+  end
+  
+  # Converts self to "literal JSON"-string - one that doesn't get quotes appended when being sent "to_json" method
+  def l
+    ActiveSupport::JSON::Variable.new(self)
+  end
+  
+  # removes JS-comments (both single- and multi-line) from the string
+  def strip_js_comments
+    regexp = /\/\/.*$|(?m:\/\*.*?\*\/)/
+    self.gsub!(regexp, '')
+
+    # also remove empty lines
+    regexp = /^\s*\n/
+    self.gsub!(regexp, '')
+  end
+  
+  # "false" => false, "whatever_else" => true
+  def to_b
+    self != "false"
+  end
+  
+end

data/lib/netzke/core_ext/symbol.rb

@@ -0,0 +1,13 @@
+class Symbol
+  def jsonify
+    self.to_s.camelize(:lower).to_sym
+  end
+  
+  def l
+    ActiveSupport::JSON::Variable.new(self.to_s)
+  end
+  
+  def action(config = {})
+    config.merge(:action => self.to_s)
+  end
+end

data/lib/netzke/core_ext/time_with_zone.rb

@@ -0,0 +1,7 @@
+module ActiveSupport
+  class TimeWithZone
+    def to_json(options = {})
+      self.to_s(:db).to_json
+    end
+  end
+end