netzke-core 0.12.3 → 1.0.0.0.pre

data/javascripts/core.js

@@ -0,0 +1,62 @@
+/*
+ * This file gets loaded along with the rest of Ext library at the initial load
+ * At this time the following constants have been set by Rails:
+ *
+ *   * Netzke.RelativeUrlRoot - set to ActionController::Base.config.relative_url_root
+ *   * Netzke.RelativeExtUrl - URL to ext files
+ *   * Netzke.ControllerUrl - NetzkeController URL
+*/
+
+Ext.ns('Ext.netzke'); // namespace for extensions that depend on Ext JS
+Ext.ns('Netzke.page'); // namespace for all component instances on the page
+Ext.ns('Netzke.classes'); // namespace for component classes
+
+Netzke.warning = function(msg){
+  if (typeof console != 'undefined') {
+    console.info("Netzke: " + msg);
+  }
+};
+
+Netzke.deprecationWarning = Netzke.warning;
+
+Netzke.exception = function(msg) {
+  throw("Netzke: " + msg);
+};
+
+// Check Ext JS version: both major and minor versions must be the same
+(function(){
+  var requiredVersionMajor = 5,
+      requiredVersionMinor = 1,
+      extVersion = Ext.getVersion('extjs'),
+      currentVersionMajor = extVersion.getMajor(),
+      currentVersionMinor = extVersion.getMinor(),
+      requiredString = "" + requiredVersionMajor + "." + requiredVersionMinor + ".x";
+
+  if (requiredVersionMajor != currentVersionMajor || requiredVersionMinor != currentVersionMinor) {
+    Netzke.warning("Ext JS " + requiredString + " required (you have " + extVersion.toString() + ").");
+  }
+})();
+
+// Netzke global event emitter
+Ext.define('Netzke.GlobalEvents', {
+    extend: 'Ext.mixin.Observable',
+    singleton: true
+});
+
+// xtypes of cached Netzke classes
+Netzke.cache = [];
+
+// Because of Netzke's double-underscore notation, Ext.TabPanel should have a different id-delimiter (yes, this must be in netzke-core)
+Ext.TabPanel.prototype.idDelimiter = "___";
+
+// Enable quick tips
+Ext.QuickTips.init();
+
+// Used in testing
+if( Netzke._pendingRequests == undefined ){
+  Netzke._pendingRequests=0;
+  Ext.Ajax.on('beforerequest',    function(conn, opt) { Netzke._pendingRequests += 1; });
+  Ext.Ajax.on('requestcomplete',  function(conn, opt) { Netzke._pendingRequests -= 1; });
+  Ext.Ajax.on('requestexception', function(conn, opt) { Netzke._pendingRequests -= 1; });
+  Netzke.ajaxIsLoading = function() { return Netzke._pendingRequests > 0; };
+}

data/javascripts/notifications.js

@@ -0,0 +1,43 @@
+/**
+ * Class creating simple notifications. Borrowed from http://dev.sencha.com/extjs/5.1.0/examples/shared/examples.js
+ * @class Netzke.Notifier
+ */
+Ext.define('Netzke.Notifier', function(){
+  var msgCt;
+
+  function createBox(t, s){
+    return t ?
+      '<div class="msg ' + Ext.baseCSSPrefix + 'border-box"><h3>' + t + '</h3><p>' + s + '</p></div>'
+    :
+      '<div class="msg ' + Ext.baseCSSPrefix + 'border-box"><p>' + s + '</p></div>';
+  }
+
+
+  return {
+    /**
+     * Shows notification on the screen.
+     * @method msg
+     * @param {String} msg Notification body HTML
+     * @param {Object} options May contain the following keys:
+     *
+     *   * **title** - title of notification
+     *   * **delay** (ms) - time notification should stay on the screen
+     */
+    msg: function(msg, options){
+      if (options == undefined) options = {};
+
+      if (Ext.isArray(msg)) {
+        msg = msg.join("<br>")
+      }
+
+      if (msgCt) {
+        document.body.appendChild(msgCt.dom);
+      } else {
+        msgCt = Ext.DomHelper.append(document.body, {id:'msg-div'}, true);
+      }
+      var m = Ext.DomHelper.append(msgCt, createBox(options.title, msg), true);
+      m.hide();
+      m.slideIn('t').ghost("t", { delay: options.delay || Netzke.Core.NotificationDelay, remove: true});
+    }
+  };
+});

data/javascripts/remoting_provider.js

@@ -0,0 +1,29 @@
+Ext.define('Netzke.NetzkeRemotingProvider', {
+
+  extend: 'Ext.direct.RemotingProvider',
+  url: Netzke.ControllerUrl + "direct/", // url to connect to the Ext.Direct server-side router.
+  namespace: "Netzke.remotingMethods", // will have a key per Netzke component, each mapped to a hash with a RemotingMethod per endpoint
+  maxRetries: Netzke.Core.directMaxRetries,
+  enableBuffer: true, // buffer/batch requests within 10ms timeframe
+  timeout: 30000, // 30s timeout per request
+
+  getPayload: function(t){
+    return {
+      path: t.action,
+      endpoint: t.method,
+      data: t.data[0],
+      tid: t.id,
+      type: 'rpc'
+    }
+  },
+
+  // Adds remoting method to component
+  addRemotingMethodToComponent: function(componentConfig, methodName) {
+    var cls = this.namespace[componentConfig.id] || (this.namespace[componentConfig.id] = {});
+    var method = Ext.create('Ext.direct.RemotingMethod', {name: methodName, len: 1});
+    cls[methodName] = this.createHandler(componentConfig.path, method);
+  }
+});
+
+Netzke.directProvider = Ext.create(Netzke.NetzkeRemotingProvider);
+Ext.Direct.addProvider(Netzke.directProvider);

data/javascripts/routing.js

@@ -0,0 +1,63 @@
+/**
+ * Routing override for Netzke.Base.
+ * @class Netzke.Core.Routing
+ */
+Ext.define('Netzke.Core.Routing', {
+  override: 'Netzke.Base',
+
+  netzkeAfterInitComponent: function(){
+    if (this.netzkeRoutes) {
+      var routes = this.netzkeGetRoutes();
+      this.netzkeRouter = Ext.create('Ext.app.Controller', { routes: this.netzkeGetRoutes() });
+      this.on('beforedestroy', this.netzkeCleanRoutes, this);
+
+      this.on('render', function(){
+        this.netzkeTriggerInitialRoute();
+      });
+    }
+
+    this.callParent();
+  },
+
+  /**
+   * Navigate to new hash route.
+   * @method netzkeNavigateTo
+   * @param route {String} Route
+   * @param {Object} [options] Options:
+   *   * **append** {Boolean} append to the current route
+   *
+   * @example
+   *
+   *     this.netzkeNavigateTo('user/1', {append: true})
+   */
+  netzkeNavigateTo: function(route, options){
+    options = options || {};
+    var newRoute = route;
+    if (options.append) {
+      newRoute = Ext.util.History.getToken() + "/" + newRoute;
+    }
+    Ext.util.History.add(newRoute);
+  },
+
+  // private
+
+  netzkeCleanRoutes: function(){
+    this.netzkeRouter.destroy();
+  },
+
+  netzkeTriggerInitialRoute: function(){
+    var initToken = Ext.util.History.getToken();
+    if (initToken) this.netzkeRouter.redirectTo(initToken, true);
+  },
+
+  netzkeGetRoutes: function(){
+    var out = {};
+    for (var route in this.netzkeRoutes) {
+      var handlerName = this.netzkeRoutes[route],
+          handler = this[handlerName];
+      if (!handler) Netzke.exception("Route handler " + handlerName + " is not defined");
+      out[route] = handler.bind(this);
+    }
+    return out;
+  }
+});

data/lib/netzke/base.rb

@@ -1,7 +1,6 @@
 require 'active_support/core_ext'
 require 'netzke/core/ruby_ext'
-require 'netzke/core/dsl_support'
-require 'netzke/core/javascript'
+require 'netzke/core/client_code'
 require 'netzke/core/stylesheets'
 require 'netzke/core/services'
 require 'netzke/core/composition'
@@ -11,17 +10,20 @@ require 'netzke/core/state'
 require 'netzke/core/embedding'
 require 'netzke/core/actions'
 require 'netzke/core/session'
-require 'netzke/core/html' if Module.const_defined?(:Haml)
+require 'netzke/core/core_i18n'
+require 'netzke/core/inheritance'
 
 module Netzke
   # The base class for every Netzke component. Its main responsibilities include:
-  # * JavaScript class generation and inheritance (using Ext JS class system) which reflects the Ruby class inheritance (see {Netzke::Core::Javascript})
+  # * Client class generation and inheritance (using Ext JS class system) which reflects the Ruby class inheritance (see {Netzke::Core::ClientCode})
   # * Nesting and dynamic loading of child components (see {Netzke::Core::Composition})
   # * Ruby-side action declaration (see {Netzke::Actions})
   # * I18n
   # * Client-server communication (see {Netzke::Core::Services})
   # * Session-based persistence (see {Netzke::Core::State})
   #
+  # Client-side methods are documented [here](http://api.netzke.org/client/classes/Netzke.Base.html).
+  #
   # == Referring to JavaScript configuration methods from Ruby
   #
   # Netzke allows use Ruby symbols for referring to pre-defined pieces of configuration. Let's say for example, that a toolbar needs to nest a control more complex than a button (say, a date field), and a component should still make it possible to make it's presence and position in the toolbar configurable. We can implement it like this:
@@ -33,7 +35,7 @@ module Netzke
   #       c.tbar = [:do_something, :date_selector]
   #     end
   #
-  # While :do_something here is referring to a usual Netzke action, :date_selector is not declared in actions. If our JavaScript mixin file contains a method called `dateSelectorConfig`, it will be executed at the moment of configuring `tbar` at client side, and it's result, a config object, will substitute `date_selector`:
+  # While :do_something here is referring to a usual Netzke action, :date_selector is not declared in actions. If our JavaScript include file contains a method called `dateSelectorConfig`, it will be executed at the moment of configuring `tbar` at client side, and it's result, a config object, will substitute `date_selector`:
   #
   #     {
   #       dateSelectorConfig: function(config){
@@ -45,73 +47,23 @@ module Netzke
   #
   # This doesn't necessarily have to be used in toolbars, but also in other places in config (i.e. layouts).
   class Base
-    include Core::DslSupport
     include Core::Session
     include Core::State
     include Core::Configuration
-    include Core::Javascript
+    include Core::ClientCode
     include Core::Services
     include Core::Composition
     include Core::Plugins
     include Core::Stylesheets
     include Core::Embedding
     include Core::Actions
-    include Core::Html if const_defined? :Haml
-
-    # TODO: get rid of it
-    class_attribute :default_instance_config
-    self.default_instance_config = {}
-
-    # set during initializations
-    mattr_accessor :session
-    mattr_accessor :controller
-    mattr_accessor :logger
-
-    # Parent component
-    attr_reader :parent
-
-    # Name that the parent can reference us by
-    attr_reader :name
-
-    # Global id in the component tree, following the double-underscore notation, e.g. +books__config_panel__form+
-    attr_reader :js_id
-
-    # JS id in the context of the parent
-    attr_reader :item_id
-
-    # Component's path in the component tree
-    attr_reader :path
-
-    class << self
-      # Instance of component by config
-      def instance_by_config(config)
-        klass = config[:klass] || config[:class_name].constantize
-        klass.new(config)
-      end
-
-      # The ID used to locate this component's block in locale files
-      def i18n_id
-        name.split("::").map{|c| c.underscore}.join(".")
-      end
+    include Core::CoreI18n
+    include Core::Inheritance
 
-      # Do class-level config of a component, e.g.:
-      #
-      #   Netzke::Basepack::GridPanel.setup do |c|
-      #     c.rows_reordering_available = false
-      #   end
-      def self.setup
-        yield self
-      end
+    # These are set during initialization
+    mattr_accessor :session, :controller, :logger
 
-      # Ancestor classes in the Netzke class hierarchy up to (and excluding) +Netzke::Base+, including self; in comparison to Ruby's own Class.ancestors, the order is reversed.
-      def netzke_ancestors
-        if self == Netzke::Base
-          []
-        else
-          superclass.netzke_ancestors + [self]
-        end
-      end
-    end
+    attr_reader :parent, :name, :item_id, :path
 
     # Instantiates a component instance. A parent can optionally be provided.
     def initialize(conf = {}, parent = nil)
@@ -130,37 +82,18 @@ module Netzke
       # Full JS id will be built using these along the +@path+
       @item_id = conf[:item_id] || @name
 
-      # JS full ID. Similar to +path+, but composed of item_id's. Differs from @path when multiple instances are being loaded.
-      @js_id = conf[:js_id]
-      @js_id ||= parent.nil? ? @item_id : [parent.js_id, @item_id].join("__")
-
-      # TODO: get rid of this in 0.9
-      @flash = []
-
       # Make +client_config+ accessible in +configure+ before calling +super+
       config.client_config = (conf.delete(:client_config) || {}).symbolize_keys
 
       # Build complete component configuration
       configure(config)
 
-      normalize_config
-
-      # Check whether the config is valid
+      # Check whether the config is valid (as specified in a custom override)
       validate_config(config)
-    end
-
-    def i18n_id
-      self.class.i18n_id
-    end
 
-  private
+      normalize_config
 
-    # TODO: get rid of this in 0.9
-    def flash(flash_hash)
-      level = flash_hash.keys.first
-      raise "Unknown message level for flash" unless %(notice warning error).include?(level.to_s)
-      @flash << {:level => level, :msg => flash_hash[level]}
+      config.deep_freeze
     end
-
   end
 end

data/lib/netzke/core/action_config.rb

@@ -22,12 +22,8 @@ module Netzke::Core
       self.icon = @icon.to_sym if @icon.present?
     end
 
-    def icon=(path)
-      self[:icon] = path.is_a?(Symbol) ? Netzke::Base.uri_to_icon(path) : path
-    end
-
-    # later
     def set_defaults!
+      self[:icon] = icon.is_a?(Symbol) ? Netzke::Base.uri_to_icon(icon) : icon
     end
 
   private

data/lib/netzke/core/actions.rb

@@ -1,5 +1,5 @@
 module Netzke::Core
-  # Netzke components allow specifying Ext actions (see http://docs.sencha.com/ext-js/4-1/#!/api/Ext.Action) in Ruby code.
+  # Netzke components provide for convenient configuration of Ext JS actions from the Ruby class.
   #
   # == Defining actions
   #
@@ -9,21 +9,26 @@ module Netzke::Core
   #       c.text = "Destroy!"
   #       c.tooltip = "Destroying it all"
   #       c.icon = :delete
-  #       c.handler = :destroy_something # destroySomething will be called on JavaScript side
+  #       c.handler = :destroy_something # `this.destroySomething` will be called on client side
   #     end
   #
   # All config settings for an action are optional. When omitted, the locale files will be consulted first (see "I18n of actions"), falling back to the defaults.
   #
-  # [+text+]
-  #   The text of the action (defaults to humanized action name)
-  # [+icon+]
-  #   Can be set to either a String (which will be interpreted as a full URI to the icon file), or as a Symbol, which will be expanded to +Netzke::Core.icons_uri+ + "/(icon).png". Defaults to nil (no icon)
-  # [+tooltip+]
-  #   The tooltip of the action (defaults to humanized action name)
-  # [+disabled+]
+  # [text]
+  #   The text of the action (defaults to localized action text, see on I18n below)
+  #
+  # [icon]
+  #   Can be set to either a String (which will be interpreted as a full URI to the icon file), or as a Symbol, which will be expanded to +Netzke::Core.icons_uri+ + "/(icon).png". Defaults to localized action icon (see on I18n below) or nil (no icon)
+  #
+  # [tooltip]
+  #   The tooltip of the action (defaults to localized action tooltip, see on I18n below)
+  #
+  # [disabled]
   #   When set to +true+, renders this action as disabled
-  # [+handler+]
-  #   A symbol that represents the JavaScript public method (snake-case), which will be called in the scope of the component instance. Defaults to +on_(action_name)+, which on JavaScript side will result in a call to +on(CamelCaseActionName)+
+  #
+  # [handler]
+  #   A symbol that represents the JavaScript public method (snake-cased), which will be called in the scope of the component instance. Defaults to +netzke_on_{action_name}+, which on JavaScript side will result in a call to +netzkeOn{ActionName}+
+  #
   # [+excluded+]
   #   When set to true, gets the action excluded from menus and toolbars
   #
@@ -95,24 +100,53 @@ module Netzke::Core
   #
   # == Interfering with action events in client class
   #
-  # For each action Netzke creates an event on the level of the parent component following the convention '<action_name>click'. The handler receives the component itself as a parameter. If the handler returns +false+, the action event is not further propagated.
+  # For each action Netzke creates an event on the level of the parent component following the convention `<action_name>click`. The handler receives the component itself as a parameter. If the handler returns +false+, the action event is not further propagated.
+  #
+  # == Preventing name clashing with child components
+  #
+  # If a component has an action and a child component defined with the same name, referring to them by symbols in the
+  # configuration will result in a name clash. See {Core::Composition} on how to address that.
   module Actions
     extend ActiveSupport::Concern
 
     included do
-      # Declares Base.action, for declaring actions, and Base#actions, which returns a [Hash] of all action configs by name
-      declare_dsl_for :actions, config_class: Netzke::Core::ActionConfig
+      class_attribute :_declared_actions
+      self._declared_actions = []
     end
 
     module ClassMethods
-      # Must stay public, used from ActionConfig
+      # Declares an action
+      def action(*args, &block)
+        args.each{|name| action(name)} if args.length > 1
+
+        name = args.first
+
+        define_method :"#{name}_action", &(block || ->(c){c})
+        # NOTE: "<<" won't work here as this will mutate the array shared between classes
+        self._declared_actions += [name]
+      end
+
       # @return [String|nil] full URI to an icon file by its name (provided we have a controller)
+      # NOTE: must stay public, used from ActionConfig
       def uri_to_icon(icon)
         Netzke::Core.with_icons ? [(controller && controller.config.relative_url_root), Netzke::Core.icons_uri, '/', icon.to_s, ".png"].join : nil
       end
     end
 
-    def js_configure(c)
+    def actions
+      return @actions if @actions
+
+      @actions = {}.tap do |res|
+        self.class._declared_actions.each do |name|
+          cfg = Netzke::Core::ActionConfig.new(name, self)
+          send("#{name}_action", cfg)
+          cfg.set_defaults!
+          res[name.to_sym] = cfg.excluded ? {excluded: true} : cfg
+        end
+      end
+    end
+
+    def configure_client(c)
       super
       c.actions = actions
     end
@@ -125,19 +159,23 @@ module Netzke::Core
 
     def detect_and_normalize_action(item)
       item = {action: item} if item.is_a?(Symbol) && actions[item]
-      if item.is_a?(Hash) && action_name = item[:action]
-        cfg = actions[action_name]
-        cfg.merge!(item)
-        if cfg[:excluded]
+
+      if action_name = action_name_if_action(item)
+        action_config = actions[action_name]
+        if action_config[:excluded]
           {excluded: true}
         else
-          item.merge(netzke_action: cfg[:action])
+          {action: action_name.to_s.camelize(:lower)}
         end
       else
         item
       end
     end
 
+    def action_name_if_action(item)
+      item.is_a?(Hash) && item[:action]
+    end
+
     def uri_to_icon(icon)
       self.class.uri_to_icon(icon)
     end