RubyGems - skozlov-netzke-core - Versions diffs - 0.1.0 - Mend

skozlov-netzke-core 0.1.0

Files changed (38) hide show

data/CHANGELOG +3 -0
data/LICENSE +20 -0
data/Rakefile +15 -0
data/generators/netzke_core/USAGE +8 -0
data/generators/netzke_core/netzke_core_generator.rb +13 -0
data/generators/netzke_core/templates/create_netzke_layouts.rb +14 -0
data/generators/netzke_core/templates/create_netzke_preferences.rb +18 -0
data/generators/netzke_core/templates/netzke.html.erb +10 -0
data/init.rb +1 -0
data/install.rb +1 -0
data/javascripts/core.js +126 -0
data/lib/app/controllers/netzke_controller.rb +16 -0
data/lib/app/models/netzke_layout.rb +75 -0
data/lib/app/models/netzke_preference.rb +66 -0
data/lib/netzke/base.rb +198 -0
data/lib/netzke/controller_extensions.rb +87 -0
data/lib/netzke/core_ext.rb +77 -0
data/lib/netzke/js_class_builder.rb +125 -0
data/lib/netzke-core.rb +22 -0
data/lib/vendor/facets/hash/recursive_merge.rb +28 -0
data/netzke-core.gemspec +32 -0
data/tasks/netzke_core_tasks.rake +4 -0
data/test/app_root/app/controllers/application.rb +2 -0
data/test/app_root/config/boot.rb +114 -0
data/test/app_root/config/database.yml +21 -0
data/test/app_root/config/environment.rb +13 -0
data/test/app_root/config/environments/in_memory.rb +0 -0
data/test/app_root/config/environments/mysql.rb +0 -0
data/test/app_root/config/environments/postgresql.rb +0 -0
data/test/app_root/config/environments/sqlite.rb +0 -0
data/test/app_root/config/environments/sqlite3.rb +0 -0
data/test/app_root/config/routes.rb +4 -0
data/test/app_root/script/console +6 -0
data/test/core_ext_test.rb +35 -0
data/test/netzke_core_test.rb +136 -0
data/test/test_helper.rb +20 -0
data/uninstall.rb +1 -0
metadata +109 -0

data/CHANGELOG ADDED Viewed

@@ -0,0 +1,3 @@
+v0.1.0.1 Meta work: replacing underscore with dash in the name
+v0.1.0 Initial release

data/LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sergei Kozlov
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile ADDED Viewed

@@ -0,0 +1,15 @@
+require 'echoe'
+Echoe.new("netzke-core") do |p|
+  p.author = "Sergei Kozlov"
+  p.email = "sergei@writelesscode.com"
+  p.summary = "Build ExtJS/Rails widgets with minimum effort"
+  p.url = "http://writelesscode.com"
+  # p.runtime_dependencies = ["searchlogic >=1.6.2"]
+  p.development_dependencies = []
+  p.test_pattern = 'test/**/*_test.rb'
+  p.retain_gemspec = true
+  # fixing the problem with lib/*-* files being removed while doing manifest
+  p.clean_pattern = ["pkg", "doc", 'build/*', '**/coverage', '**/*.o', '**/*.so', '**/*.a', '**/*.log', "{ext,lib}/*.{bundle,so,obj,pdb,lib,def,exp}", "ext/Makefile", "{ext,lib}/**/*.{bundle,so,obj,pdb,lib,def,exp}", "ext/**/Makefile", "pkg", "*.gem", ".config"]
+end

data/generators/netzke_core/USAGE ADDED Viewed

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+Example:
+    ./script/generate netzke-core Thing
+    This will create:
+        what/will/it/create

data/generators/netzke_core/netzke_core_generator.rb ADDED Viewed

@@ -0,0 +1,13 @@
+# class NetzkeCoreGenerator < Rails::Generator::NamedBase
+class NetzkeCoreGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory "public/javascripts/netzke"
+      # m.file 'netzke.js', "public/javascripts/netzke/netzke.js"
+      m.file 'netzke.html.erb', "app/views/layouts/netzke.html.erb"
+      m.migration_template 'create_netzke_preferences.rb', "db/migrate", {:migration_file_name => "create_netzke_preferences"}
+      # FIXME: how do we avoid getting the same migration IDs?
+      m.migration_template 'create_netzke_layouts.rb', "db/migrate", {:migration_file_name => "create_netzke_layouts"}
+    end
+  end
+end

data/generators/netzke_core/templates/create_netzke_layouts.rb ADDED Viewed

@@ -0,0 +1,14 @@
+class CreateNetzkeLayouts < ActiveRecord::Migration
+  def self.up
+    create_table :netzke_layouts do |t|
+      t.string  :widget_name
+      t.string  :items_class
+      t.integer :user_id
+      t.timestamps
+    end
+  end
+  def self.down
+    drop_table :netzke_layouts
+  end
+end

data/generators/netzke_core/templates/create_netzke_preferences.rb ADDED Viewed

@@ -0,0 +1,18 @@
+class CreateNetzkePreferences < ActiveRecord::Migration
+  def self.up
+    create_table :netzke_preferences do |t|
+      t.string :name
+      t.string :pref_type
+      t.string :value
+      t.integer :user_id
+      t.integer :role_id
+      t.string :custom_field
+      t.timestamps
+    end
+  end
+  def self.down
+    drop_table :netzke_preferences
+  end
+end

data/generators/netzke_core/templates/netzke.html.erb ADDED Viewed

@@ -0,0 +1,10 @@
+<head>
+	<meta http-equiv="Content-type" content="text/html; charset=utf-8">
+	<title>netzke widget</title>
+	<%= javascript_include_tag("/extjs/adapter/ext/ext-base.js", "/extjs/ext-all-debug.js") %>
+	<%= javascript_include_tag("netzke/netzke.js") %>
+	<%= stylesheet_link_tag("/extjs/resources/css/ext-all.css") %>
+</head>
+<body id="">
+<%= yield %>
+</body>

data/init.rb ADDED Viewed

	@@ -0,0 +1 @@
1	+ require 'netzke-core'

data/install.rb ADDED Viewed

	@@ -0,0 +1 @@
1	+ # Install hook code here

data/javascripts/core.js ADDED Viewed

@@ -0,0 +1,126 @@
+Ext.BLANK_IMAGE_URL = "/extjs/resources/images/default/s.gif";
+Ext.componentCache = {};
+Ext.namespace('Ext.netzke');
+// helper method to do multiple Ext.apply's
+Ext.chainApply = function(objectArray){
+	var res = {};
+	Ext.each(objectArray, function(obj){Ext.apply(res, obj)});
+	return res;
+}
+// implementation of totalProperty, successProperty and root configuration options for ArrayReader
+Ext.data.ArrayReader = Ext.extend(Ext.data.JsonReader, {
+    readRecords : function(o){
+     	var sid = this.meta ? this.meta.id : null;
+    	var recordType = this.recordType, fields = recordType.prototype.fields;
+    	var records = [];
+			// console.info(this.meta);
+    	var root = o[this.meta.root] || o, totalRecords = o[this.meta.totalProperty], success = o[this.meta.successProperty];
+	    for(var i = 0; i < root.length; i++){
+		    var n = root[i];
+	        var values = {};
+	        var id = ((sid || sid === 0) && n[sid] !== undefined && n[sid] !== "" ? n[sid] : null);
+	        for(var j = 0, jlen = fields.length; j < jlen; j++){
+                var f = fields.items[j];
+                var k = f.mapping !== undefined && f.mapping !== null ? f.mapping : j;
+                var v = n[k] !== undefined ? n[k] : f.defaultValue;
+                v = f.convert(v, n);
+                values[f.name] = v;
+            }
+	        var record = new recordType(values, id);
+	        record.json = n;
+	        records[records.length] = record;
+	    }
+	    return {
+	        records : records,
+	        totalRecords : totalRecords,
+					success : success
+	    };
+    }
+});
+// Methods common to all widget classes
+Ext.widgetMixIn = {
+	widgetInit:function(config){
+    this.app = Ext.getCmp('application');
+    if (config.tools) Ext.each(config.tools, function(i){i.on.click = this[i.on.click].createDelegate(this)}, this);
+    if (config.actions) Ext.each(config.actions, function(i){i.handler = this[i.handler].createDelegate(this);}, this);
+	},
+	setEvents: function(){
+		this.on('beforedestroy', function(){
+			// clean-up menus
+			if (this.app && !!this.app.unhostMenus) {
+				// alert('beforedestroy');
+				this.app.unhostMenus(this)
+			}
+		}, this);
+		this.on('render', this.onWidgetLoad, this);
+	},
+	feedback:function(msg){
+		if (this.app && !!this.app.showFeedback) {
+			this.app.showFeedback(msg)
+		} else {
+			// there's no application to show the feedback - so, we do it ourselves
+			if (typeof msg == 'string'){
+				alert(msg)
+			} else {
+				var compoundResponse = ""
+				Ext.each(msg, function(m){
+          compoundResponse += m.msg + "\n"
+        })
+				if (compoundResponse != "") alert(compoundResponse);
+			}
+		};
+	},
+	addMenus:function(menus){
+		if (this.app && !!this.app.hostMenu) {
+			Ext.each(menus, function(menu){this.app.hostMenu(menu, this)}, this)
+		}
+	},
+	onWidgetLoad:Ext.emptyFn // gets overridden
+}
+// Make Panel with layout 'fit' capable to dynamically load widgets
+Ext.override(Ext.Panel, {
+	getWidget: function(){
+		return this.items.get(0)
+	},
+	loadWidget: function(url, params){
+		if (!params) params = {}
+		this.remove(this.getWidget()); // first delete previous widget
+		// we will let the server know which components we have cached
+		var cachedComponentNames = [];
+		for (name in Ext.componentCache) {
+			cachedComponentNames.push(name);
+		}
+		this.disable(); // to visually emphasize loading
+		Ext.Ajax.request(
+			{url:url, params:Ext.apply(params, {components_cache:Ext.encode(cachedComponentNames)}), script:false, callback:function(panel, success, response){
+				var response = Ext.decode(response.responseText);
+				if (response['classDefinition']) eval(response['classDefinition']); // evaluate widget's class if it was sent
+				response.config.parent = this // we might want to know the parent panel in advance (e.g. to know its size)
+				var instance = new Ext.componentCache[response.config.widgetClassName](response.config)
+				this.add(instance);
+				this.doLayout();
+				this.enable();
+			}, scope:this}
+		)
+	}
+})

data/lib/app/controllers/netzke_controller.rb ADDED Viewed

@@ -0,0 +1,16 @@
+class NetzkeController < ActionController::Base
+  # collect javascripts from all plugins that registered it in Netzke::Base.config[:javascripts]
+  def netzke
+    respond_to do |format|
+      format.js {
+        res = ""
+        Netzke::Base.config[:javascripts].each do |path|
+          f = File.new(path)
+          res << f.read
+        end
+        render :text => res
+      }
+    end
+  end
+end

data/lib/app/models/netzke_layout.rb ADDED Viewed

@@ -0,0 +1,75 @@
+class NetzkeLayout < ActiveRecord::Base
+  # has_many :layout_items#, :class_name => "ExtWidget::LayoutItem", :order => :position
+  # has_many :objects, :class_name => "Objects", :foreign_key => "class_name_id"
+  # belongs_to :role
+  # belongs_to :user
+  UNRELATED_ATTRS = %w(created_at updated_at position layout_id)
+  def self.user_id
+    @@user_id ||= nil
+  end
+  def layout_items
+    items_class.constantize.find_all_by_layout_id(id, :order => 'position')
+  end
+  #
+  # def self.user_id=(user_id)
+  #   @@user_id = user_id
+  # end
+  #
+  # def self.layout_items(widget_name)
+  #   layout = self.layout(widget_name)
+  #   layout.nil? ? nil : layout.layout_items.map(&:attributes).map{|item| item.delete_if{|k,v| UNRELATED_ATTRS.include?(k)}}
+  # end
+  #
+  def self.by_widget(widget_name)
+    self.find(:first, :conditions => {:widget_name => widget_name, :user_id => self.user_id})
+  end
+  def move_item(old_index, new_index)
+    layout_item = layout_items[old_index]
+    layout_item.remove_from_list
+    layout_item.insert_at(new_index + 1)
+  end
+  # def self.layout_items(widget_name)
+  #   layout = self.by_widget(widget_name)
+  #   if layout
+  #     layout.layout_items
+  #   else
+  #     # create new layout and fill it out with default values
+  #     layout = Layout.create({:widget_name => widget_name, :user_id => self.user_id})
+  #   end
+  # end
+  def items_hash
+    layout_items.map(&:attributes).map{|item| item.delete_if{|k,v| UNRELATED_ATTRS.include?(k)}}.map{ |i| i.convert_keys{ |k| k.to_sym } }
+  end
+  # if layout items are provided, use them instead of defaults (exsposed) layout items, but merge their configs with the default
+  # def self.create_layout_for_widget(widget_name, data_class_name, layout_item_class_name, items = nil)
+  #   layout = self.create(:widget_name => widget_name, :items_class => layout_item_class_name, :user_id => self.user_id)
+  #   data_class = data_class_name.constantize
+  #   layout_item_class = layout_item_class_name.constantize
+  #
+  #
+  #   if items.nil?
+  #     complete_items = data_class.exposed_columns
+  #   else
+  #     # normalize columns
+  #     columns = columns.
+  #     default_columns = data_class.exposed_columns.map{|c| c.is_a?(Symbol) ? {:name => c} : c}
+  #     columns.each
+  #
+  #   complete_columns = columns.nil? ?  : columns
+  #   complete_columns.each do |c|
+  #     config = c.is_a?(Hash) ? c : {:name => c}
+  #     # we have to merge layout_id in order to have :position set up properly
+  #     item = layout_item_class.create_with_defaults(config.merge({:layout_id => layout.id}), data_class)
+  #   end
+  #   layout
+  # end
+end

data/lib/app/models/netzke_preference.rb ADDED Viewed

@@ -0,0 +1,66 @@
+class NetzkePreference < ActiveRecord::Base
+  CONVERTION_METHODS= {'Fixnum' => 'to_i', 'String' => 'to_s', 'Float' => 'to_f', 'Symbol' => 'to_sym'}
+  def self.user=(user)
+    @@user = user
+  end
+  def self.user
+    @@user ||= nil
+  end
+  def self.custom_field=(value)
+    @@custom_field = value
+  end
+  def self.custom_field
+    @@custom_field ||= nil
+  end
+  def normalized_value
+    klass = read_attribute(:pref_type)
+    norm_value = read_attribute(:value)
+    if klass.nil?
+      # do not cast
+      r = norm_value
+    elsif klass == 'Boolean'
+      r = norm_value == 'false' ? false : (norm_value == 'true' || norm_value)
+    elsif klass == 'NilClass'
+      r = nil
+    elsif klass == 'Array'
+      r = JSON.parse(norm_value)
+    else
+      r = norm_value.send(CONVERTION_METHODS[klass])
+    end
+    r
+  end
+  def normalized_value=(new_value)
+    # norm_value = (new_value.to_s if new_value == true or new_value == false) || new_value
+    case new_value.class.to_s
+    when "Array"
+      write_attribute(:value, new_value.to_json)
+    else
+      write_attribute(:value, new_value.to_s)
+    end
+    write_attribute(:pref_type, [TrueClass, FalseClass].include?(new_value.class) ? 'Boolean' : new_value.class.to_s)
+  end
+  def self.[](pref_name)
+    pref_name = pref_name.to_s
+    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
+    pref = self.find(:first, :conditions => conditions)
+    # pref = @@user.nil? ? self.find_by_name(pref_name) : self.find_by_name_and_user_id(pref_name, @@user.id)
+    pref && pref.normalized_value
+  end
+  def self.[]=(pref_name, new_value)
+    pref_name = pref_name.to_s
+    conditions = {:name => pref_name, :user_id => self.user, :custom_field => self.custom_field}
+    pref = self.find(:first, :conditions => conditions) || self.create(conditions)
+    # pref = self.user.nil? ? self.find_or_create_by_name(pref_name) : self.find_or_create_by_name_and_user_id(pref_name, self.user.id)
+    pref.normalized_value = new_value
+    pref.save!
+  end
+end

data/lib/netzke/base.rb ADDED Viewed

@@ -0,0 +1,198 @@
+require 'json'
+module Netzke
+  class Base
+    # Global Netzke configuration
+    def self.config
+      @@config ||= {
+        :javascripts => ["#{File.dirname(__FILE__)}/../../javascripts/core.js"] # locations of javascript files (which automatically will be collected into one file and sent as netzke.js)
+      }
+    end
+    # Helper class to read/write from/to widget's persistent preferences. TODO: rework it.
+    class Config
+      def initialize(widget_name)
+        @widget_name = widget_name
+      end
+      def []=(k,v)
+        NetzkePreference.custom_field = @widget_name
+        NetzkePreference[k] = v
+      end
+      def [](k)
+        NetzkePreference.custom_field = @widget_name
+        NetzkePreference[k]
+      end
+    end
+    # client-side code (generates JS-classes of the widgets)
+    include Netzke::JsClassBuilder
+    attr_accessor :config, :server_confg, :parent, :logger, :id_name, :permissions
+    attr_reader :pref
+    def initialize(config = {}, parent = nil)
+      @logger = Logger.new("debug.log")
+      @config = initial_config.recursive_merge(config)
+      @parent = parent
+      @id_name = parent.nil? ? config[:name].to_s : "#{parent.id_name}__#{config[:name]}"
+      @flash = []
+      @pref = Config.new(@id_name)
+      @config[:ext_config] ||= {} # configuration used to instantiate JS class
+      process_permissions_config
+    end
+    def initial_config
+      {}
+    end
+    # 'Netzke::Grid' => 'Grid'
+    def short_widget_class_name
+      self.class.short_widget_class_name
+    end
+    def self.short_widget_class_name
+      name.split("::").last
+    end
+    #
+    # Use this class-method to declare connection points between client side of a widget and its server side. A method in a widget class with the same name will be (magically) called by the client-side of the widget. See Grid widget for an example
+    #
+    def self.interface(*interface_points)
+      interfacep = read_inheritable_attribute(:interface_points) || []
+      interface_points.each{|p| interfacep << p}
+      write_inheritable_attribute(:interface_points, interfacep)
+      interface_points.each do |interfacep|
+        module_eval <<-END, __FILE__, __LINE__
+        def interface_#{interfacep}(*args)
+          #{interfacep}(*args).to_js
+        end
+        # FIXME: commented out because otherwise ColumnOperations stop working
+        # def #{interfacep}(*args)
+        #   flash :warning => "API point '#{interfacep}' is not implemented for widget '#{short_widget_class_name}'"
+        #   {:flash => @flash}
+        # end
+        END
+      end
+    end
+    def self.interface_points
+      read_inheritable_attribute(:interface_points)
+    end
+    def interface_points
+      self.class.interface_points
+    end
+    interface :get_widget # default
+    ## Dependencies
+    def dependencies
+      @dependencies ||= initial_dependencies
+    end
+    def initial_dependencies
+      config[:dependencies] || []
+    end
+    ### Aggregation
+    def initial_aggregatees
+      {}
+    end
+    def aggregatees
+      @aggregatees ||= initial_aggregatees.merge(initial_late_aggregatees.each_pair{|k,v| v.merge!(:late_aggregation => true)})
+    end
+    def add_aggregatee(aggr)
+      aggregatees.merge!(aggr)
+    end
+    # The difference between aggregatees and late aggregatees is the following: the former gets instantiated together with its aggregator and is normally instantly visible as a part of it. While a late aggregatee doesn't get instantiated along with its aggregator. Until it gets requested, it doesn't take any part in its aggregator's lifecycle. An example of late aggregatee could be a widget that is loaded by an application widget on user's request, or a preferences window that only gets instantiated when user wants to edit widget's preferences. An example of a normal aggregatee is any widget (like a grid) within a BorderLayout-based widget (i.e. aggregator) - it should get instantiated and shown along with its aggregator.
+    def initial_late_aggregatees
+      {}
+    end
+    def add_late_aggregatee(aggr)
+      aggregatees.merge!(aggr.merge(:late_aggregation => true))
+    end
+    # recursively instantiates an aggregatee based on its "path": e.g. if we have an aggregatee :aggr1 which in its turn has an aggregatee :aggr10, the path to the latter would be "aggr1__aggr10"
+    def aggregatee_instance(name)
+      aggregator = self
+      name.to_s.split('__').each do |aggr|
+        aggr = aggr.to_sym
+        # TODO: should we put all the classes under Netzke::-scope?
+        # widget_class = full_widget_class_name(aggregator.aggregatees[aggr][:widget_class_name]).constantize
+        widget_class = "Netzke::#{aggregator.aggregatees[aggr][:widget_class_name]}".constantize
+        aggregator = widget_class.new(aggregator.aggregatees[aggr].merge(:name => aggr), aggregator)
+      end
+      aggregator
+    end
+    def full_widget_class_name(short_name)
+      "Netzke::#{short_name}"
+    end
+    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]}
+    end
+    def widget_action(action_name)
+      "#{@id_name}__#{action_name}"
+    end
+    # permissions
+    def available_permissions
+      []
+    end
+    def process_permissions_config
+      if !available_permissions.empty?
+        # First, process permissions from the config
+        @permissions = available_permissions.inject({}){|h,p| h.merge(p.to_sym => true)} # by default anything is allowed
+        config[:prohibit] = available_permissions if config[:prohibit] == :all # short-cut for all permissions
+        config[:prohibit] = [config[:prohibit]] if config[:prohibit].is_a?(Symbol) # so that config[:prohibit] => :write works
+        config[:prohibit] && config[:prohibit].each{|p| @permissions.merge!(p.to_sym => false)} # prohibit
+        config[:allow] = [config[:allow]] if config[:allow].is_a?(Symbol) # so that config[:allow] => :write works
+        config[:allow] && config[:allow].each{|p| @permissions.merge!(p.to_sym => true)} # allow
+        # ... and then merge it with NetzkePreferences
+        available_permissions.each do |p|
+          @permissions[p.to_sym] = @pref["permissions.#{p}"] if !@pref["permissions.#{p}"].nil?
+        end
+      end
+    end
+    ## method dispatcher - sends method to the proper aggregatee
+    def method_missing(method_name, params = {})
+      widget, *action = method_name.to_s.split('__')
+      widget = widget.to_sym
+      action = !action.empty? && action.join("__").to_sym
+      if action && aggregatees[widget]
+        # only actions starting with "interface_" are accessible
+        interface_action = action.to_s.index('__') ? action : "interface_#{action}"
+        aggregatee_instance(widget).send(interface_action, params)
+      else
+        super
+      end
+    end
+    #### API section
+    def get_widget(params = {})
+      # if browser does not have our component class cached (and all dependencies), send it to him
+      components_cache = (JSON.parse(params[:components_cache]) if params[:components_cache]) || []
+      {:config => js_config, :class_definition => js_missing_code(components_cache)}
+    end
+  end
+end