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

skozlov-netzke-core 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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