netzke-core 0.7.7 → 0.8.0

data/lib/netzke/core/railz.rb

@@ -0,0 +1,4 @@
+require 'netzke/core/railz/engine'
+require 'netzke/core/railz/routes'
+require 'netzke/core/railz/action_view_ext'
+require 'netzke/core/railz/controller_extensions'

data/lib/netzke/{railz → core/railz}/action_view_ext.rb

@@ -1,26 +1,30 @@
-require 'netzke/railz/action_view_ext/ext'
-require 'netzke/railz/action_view_ext/touch'
+require 'netzke/core/railz/action_view_ext/ext'
 module Netzke
   module Railz
     module ActionViewExt
       include Ext
-      include Touch
 
-      # A helper to initialize Netzke. Usually used in the layout.
+      # A helper to load Netzke and Ext JS files. Usually used in the layout.
       #
       # Params:
-      # * :platform - :ext or :touch, by default :ext
-      # * :theme - the name of theme to apply
-      # * :cache - enable Rails caching of assets
+      #
+      # * :theme - the name of theme to apply; follows simple convention of including css files named "ext-(theme)".
       #
       # E.g.:
-      #     <%= netzke_init :theme => :grey %>
       #
-      # For Sencha Touch:
-      #     <%= netzke_init :platform => :touch %>
-      def netzke_init(params = {})
+      #     <%= load_netzke theme: "neptune" %>
+      #
+      # Other theme options that may work (unless Sencha introduces some/other conventions):
+      #
+      # - all (standard)
+      # - all-gray
+      # - all-access
+      #
+      # * :minified - set to +true+ to load minified JS and CSS for Ext JS also in development env
+      def load_netzke(params = {})
         Netzke::Core.platform = params[:platform] || :ext
-        theme = params[:theme] || params[:ext_theme]
+        params[:minified] = !Rails.env.development? if params[:minified].nil?
+        params[:theme] ||= :all
 
         raw([netzke_css_include(params), netzke_css(params), netzke_js_include(params), netzke_js(params)].join("\n"))
       end
@@ -40,11 +44,11 @@ module Netzke
 
         config[:name] = name
 
-        # Register the component in session
-        Netzke::Core.reg_component(config)
-
         cmp = Netzke::Base.instance_by_config(config)
-        cmp.before_load # inform the component about initial load
+
+        # Register the component in session
+        session[:netzke_components] ||= {}
+        session[:netzke_components][cmp.js_id.to_sym] = config
 
         content_for :netzke_js_classes, raw(cmp.js_missing_code(@rendered_classes))
 
@@ -53,7 +57,7 @@ module Netzke
         content_for :netzke_on_ready, raw("#{cmp.js_component_instance}\n\n#{cmp.js_component_render}")
 
         # Now mark all this component's dependency classes (including self) as rendered (by storing their xtypes), so that we only generate a class once per view
-        @rendered_classes = (@rendered_classes + cmp.dependency_classes.map(&:js_xtype)).uniq
+        @rendered_classes = (@rendered_classes + cmp.dependency_classes.map{|k| k.js_config.xtype}).uniq
 
         # Return the html for this component
         raw(cmp.js_component_html)
@@ -79,7 +83,7 @@ module Netzke
           send :"netzke_#{Netzke::Core.platform}_js_include", params
         end
 
-        # Inline JavaScript for all Netzke classes on the page, as well as Ext.onReady (Ext.setup in case of Touch) which renders Netzke components in this view after the page is loaded
+        # Inline JavaScript for all Netzke classes on the page, as well as Ext.onReady, which renders Netzke components in this view after the page is loaded
         def netzke_js(params = {})
           send :"netzke_#{Netzke::Core.platform}_js", params
         end

data/lib/netzke/core/railz/action_view_ext/ext.rb

@@ -0,0 +1,49 @@
+module Netzke
+  module Railz
+    module ActionViewExt
+      # Implementation of Ext-specific Netzke helpers
+      module Ext
+
+      private
+
+        def netzke_ext_css_include(params)
+          # ExtJS base
+          res = ["#{Netzke::Core.ext_uri}/resources/css/ext-#{params[:theme]}"]
+
+          # Netzke-related dynamic css
+          res << netzke_path(:ext)
+
+          res += Netzke::Core.external_ext_css
+
+          stylesheet_link_tag(*res)
+        end
+
+        def netzke_ext_js_include(params)
+          res = []
+
+          # ExtJS
+          res << (params[:minified] ? "#{Netzke::Core.ext_uri}/ext-all" : "#{Netzke::Core.ext_uri}/ext-all-debug")
+
+          # Ext I18n
+          res << "#{Netzke::Core.ext_uri}/locale/ext-lang-#{I18n.locale}" if I18n.locale != :en
+
+          # Netzke-related dynamic JavaScript
+          res << netzke_path(:ext)
+
+          javascript_include_tag(*res)
+        end
+
+        def netzke_ext_js(params)
+          res = []
+          res << content_for(:netzke_js_classes)
+
+          res << "Ext.onReady(function(){"
+          res << content_for(:netzke_on_ready)
+          res << "});"
+
+          javascript_tag(res.join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/netzke/core/railz/controller_extensions.rb

@@ -0,0 +1,17 @@
+module Netzke
+  module Railz
+    # Before each request, Netzke::Base.controller and Netzke::Base.session are set, to be accessible from components.
+    module ControllerExtensions
+      def self.included(base)
+        base.send(:before_filter, :set_controller_and_session)
+      end
+
+      protected
+
+      def set_controller_and_session
+        Netzke::Base.controller = self
+        Netzke::Base.session = session
+      end
+    end
+  end
+end

data/lib/netzke/core/railz/engine.rb

@@ -0,0 +1,16 @@
+module Netzke
+  module Railz
+    class Engine < Rails::Engine
+      initializer "netzke.core" do |app|
+        app.config.eager_load_paths -= ["#{app.config.root}/app/components"]
+        app.config.autoload_paths += ["#{app.config.root}/app/components"]
+      end
+
+      # before loading initializers
+      config.before_initialize do |app|
+        Netzke::Core.ext_path = Rails.root.join('public', Netzke::Core.ext_uri[1..-1])
+        Netzke::Core.with_icons = File.exists?("#{::Rails.root}/public#{Netzke::Core.icons_uri}") if Netzke::Core.with_icons.nil?
+      end
+    end
+  end
+end

data/lib/netzke/core/railz/routes.rb

@@ -0,0 +1,10 @@
+module ActionDispatch::Routing
+  class Mapper
+    # Enable routes for Netzke assets and endpoint calls. By default the URL is "/netzke", but this can be changed by providing an argument:
+    #
+    #     netzke "/some/path/netzke"
+    def netzke(prefix = "/netzke")
+      match "#{prefix}/:action(.:format)", to: "netzke", as: 'netzke'
+    end
+  end
+end

data/lib/netzke/core/ruby_ext.rb

@@ -0,0 +1,5 @@
+require "netzke/core/ruby_ext/array"
+require "netzke/core/ruby_ext/hash"
+require "netzke/core/ruby_ext/string"
+require "netzke/core/ruby_ext/symbol"
+require "netzke/core/ruby_ext/time_with_zone"

data/lib/netzke/core/ruby_ext/array.rb

@@ -0,0 +1,23 @@
+class Array
+  def deep_map(&block)
+    self.map{ |el| el.respond_to?(:deep_map) ? block.call(el.deep_map(&block)) : block.call(el) }.compact
+  end
+
+  def jsonify
+    self.map{ |el| el.is_a?(Array) || el.is_a?(Hash) ? el.jsonify : el }
+  end
+
+  # Camelizes the keys of hashes and converts them to JSON
+  def to_nifty_json
+    self.jsonify.to_json
+  end
+
+  def deep_each_pair(&block)
+    self.each{ |el| el.respond_to?('deep_each_pair') && el.deep_each_pair(&block) }
+  end
+
+  def deep_freeze
+    each { |j| j.deep_freeze if j.respond_to? :deep_freeze }
+    freeze
+  end
+end

data/lib/netzke/core/ruby_ext/hash.rb

@@ -0,0 +1,47 @@
+class Hash
+  def deep_map(&block)
+    self.dup.tap do |h|
+      h.each_pair do |k,v|
+        h[k] = v.deep_map(&block) if v.respond_to?('deep_map')
+      end
+    end
+  end
+
+  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
+
+  def jsonify
+    self.inject({}) do |h,(k,v)|
+      new_key = (k.is_a?(String) || k.is_a?(Symbol)) && !k.is_a?(ActiveSupport::JSON::Variable) ? k.jsonify : k
+      new_value = v.is_a?(Array) || v.is_a?(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.jsonify.to_json
+  end
+
+  def deep_freeze
+    each { |k,v| v.deep_freeze if v.respond_to? :deep_freeze }
+    freeze
+  end
+
+  # From http://rubyworks.github.com/facets
+  def update_keys #:yield:
+    if block_given?
+      keys.each { |old_key| store(yield(old_key), delete(old_key)) }
+    else
+      to_enum(:update_keys)
+    end
+  end
+
+  def literalize_keys
+    update_keys{ |k| k.to_s.l }
+    self
+  end
+end

data/lib/netzke/{core_ext → core/ruby_ext}/string.rb

@@ -1,14 +1,10 @@
 class String
   def jsonify
-    if self.index('_') == 0
-      # '_some_string' should become '_someString' and not 'SomeString'
-      '_' + self[1..-1].camelize(:lower)
-    else
-      self.camelize(:lower)  
-    end
+    self.camelize(:lower)
   end
 
   # Converts self to "literal JSON"-string - one that doesn't get quotes appended when being sent "to_json" method
+  # TODO: get rid of it
   def l
     ActiveSupport::JSON::Variable.new(self)
   end
@@ -27,5 +23,4 @@ class String
   def to_b
     self != "false"
   end
-
 end

data/lib/netzke/core/ruby_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 to_cls_attr
+    "__#{self}__".to_sym
+  end
+end

data/lib/netzke/core/services.rb

@@ -0,0 +1,130 @@
+module Netzke::Core
+  # The client-server communication between the JavaScript and Ruby side of a component is provided by means of "endpoints".
+  #
+  # == Defining an endpoint
+  #
+  # An endpoint is defined through the +endpoint+ class method on the Ruby class:
+  #
+  #     endpoint :do_something do |params, this|
+  #       # ...
+  #     end
+  #
+  # The first block argument will contain the hash of arguments provided at the moment of calling the endpoint from the JavaScript side (see "Calling an endpoint from JavaScript").
+  # The second block argument is used for "calling" JavaScript methods as a response from the server (see "Envoking JavaScript methods from the server").
+  #
+  # == Calling an endpoint from JavaScript
+  #
+  # By defining the endpoint on the Ruby class, the client side automatically gets an equally named (but camelcased) method that is used to call the endpoint at the server. In the previous example, that would be +doSomething+. Its signature goes as follows:
+  #
+  #     this.doSomething(argsObject, callbackFunction, scope);
+  #
+  # * +argsObject+ is what the server side will receive as the +params+ argument
+  # * +callbackFunction+ (optional) will be called after the server successfully processes the request
+  # * +scope+ (optional) the scope in which +callbackFunction+ will be called
+  #
+  # The callback function can optionally receive an argument set by the endpoint at the server (see "Providing the argument to the callback function").
+  #
+  # == Envoking JavaScript methods from the server
+  #
+  # An endpoint, after doing some useful job at the server, is able to instruct the client side of the component to call multiple methods (preserving the call order) with provided arguments. It's done by using the second parameter of the endpoint block (which is illustratively called 'this'):
+  #
+  #     endpoint :do_something do |params, this|
+  #       # ... do the thing
+  #       this.set_title("New title")
+  #       this.add_class("some-extra-css")
+  #     end
+  #
+  # This will result in successive calling the +setTitle+ and +addClass+ methods on the JavaScript instance of our component.
+  #
+  # Besides "calling" methods on the current component itself, it's also possible to address its instantiated children at any level of the hierarchy:
+  #
+  #     endpoint :do_something do |params, this|
+  #       # ... do the thing
+  #       this.east_panel_component.set_title("New east panel title")
+  #       this.east_panel_component.deep_nested_component.do_something_very_special("With", "some", "arguments")
+  #     end
+  #
+  # == Providing arguments to the callback function
+  #
+  # The callback function provided at the moment of calling an endpoint may receive an argument set by the endpoint by "calling" the special +netzke_set_result+ method. :
+  #
+  #     endpoint :do_something do |params, this|
+  #       # ... do the thing
+  #       this.netzke_set_result(42)
+  #     end
+  #
+  # By calling the endpoint from the client side like this:
+  #
+  #     this.doSomething({}, function(result){ console.debug(result); });
+  #
+  # ... the value of +result+ after the execution of the endpoint will be set to 42. Using this mechanism can be seen as doing an asyncronous call to a function at the server, which returns a value.
+  #
+  # == Overriding an endpoint
+  #
+  # When overriding an endpoint, you can call the original endpoint by using +super+ and explicitely providing the block parameters to it:
+  #
+  #     endpoint :do_something do |params, this|
+  #       super(params, this)
+  #       this.doMore
+  #     end
+  #
+  # If you want to reuse the original arguments set in +super+, you can access them from the +this+ object. Provided we are overriding the +do_something+ endpoint from the example in "Envoking JavaScript methods from the server", we will have:
+  #
+  #     endpoint :do_something do |params, this|
+  #       super(params, this)
+  #       original_arguments_for_set_title = this.set_title # => ["New title"]
+  #       original_arguments_for_add_class = this.add_class # => ["some-extra-css"]
+  #     end
+  module Services
+    extend ActiveSupport::Concern
+
+    included do
+       # Returns all endpoints as a hash
+      class_attribute :endpoints
+      self.endpoints = {}
+    end
+
+    module ClassMethods
+      def endpoint(name, options = {}, &block)
+        register_endpoint(name)
+        define_method("#{name}_endpoint", &block)
+      end
+
+    protected
+
+      # Registers an endpoint at the class level
+      def register_endpoint(ep)
+        self.endpoints = self.endpoints.dup if self.superclass.respond_to?(:endpoints) && self.endpoints == self.superclass.endpoints #  only dup for the first endpoint declaration
+        self.endpoints[ep.to_sym] = true
+      end
+    end
+
+    # Invokes an endpoint call
+    # +endpoint+ may contain the path to the endpoint in a component down the hierarchy, e.g.:
+    #
+    #     invoke_endpoint(:users__center__get_data, params)
+    def invoke_endpoint(endpoint, params)
+      if self.class.endpoints[endpoint.to_sym]
+        endpoint_response = Netzke::Core::EndpointResponse.new
+        send("#{endpoint}_endpoint", params, endpoint_response)
+
+        endpoint_response
+      else
+        # Let's try to find it recursively in a component down the hierarchy
+        child_component, *action = endpoint.to_s.split('__')
+        child_component = child_component.to_sym
+        action = !action.empty? && action.join("__").to_sym
+
+        raise RuntimeError, "Component '#{self.class.name}' does not have endpoint '#{endpoint}'" if !action
+
+        if components[child_component]
+          component_instance(child_component).invoke_endpoint(action, params)
+        else
+          # component_missing can be overridden if necessary
+          component_missing(child_component)
+        end
+      end
+    end
+
+  end
+end

data/lib/netzke/core/session.rb

@@ -1,25 +1,21 @@
-module Netzke
-  module Core
-    module Session
-      # Should be called by session controller at the moment of successfull login
-      def login
-        session[:_netzke_next_request_is_first_after_login] = true
+module Netzke::Core
+  # Implements component-specific session manupulation.
+  module Session
+    # Instance of this class is returned through component_session, and allows writing/reading to/from the session part reserved for a specific component (specified by component's js_id).
+    class ComponentSessionProxy < Object
+      def initialize(component_id)
+        @session = Netzke::Base.session.nil? ? {} : Netzke::Base.session[component_id] ||= {}
       end
 
-      # Should be called by session controller at the moment of logout
-      def logout
-        session[:_netzke_next_request_is_first_after_logout] = true
-      end
-
-      def current_user
-        Netzke::Core.controller.respond_to?(Netzke::Core.current_user_method) && Netzke::Core.controller.send(Netzke::Core.current_user_method) || nil
+      # Delegate everything to session
+      def method_missing(method, *args)
+        @session.send(method, *args)
       end
+    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
+    # Component-specific session.
+    def component_session
+      @component_session_proxy ||= ComponentSessionProxy.new(js_id)
     end
   end
-end
+end