netzke-basepack 0.4.2 → 0.5.1

data/.autotest

@@ -0,0 +1 @@
+require 'autotest/redgreen'

data/.gitignore

@@ -0,0 +1,6 @@
+.DS_Store
+*.log
+pkg
+doc
+Manifest
+test/app_root/vendor/plugins/netzke-core

data/{CHANGELOG → CHANGELOG.rdoc}

@@ -1,3 +1,29 @@
+v0.5.1 - 2009-09-11
+Fix: crash when FormPanel has no data_class_name specified.
+New: DataAccessor widgets (Form/GridPanel) now let the underlying model know which widget (i.e. which instance) accesses its data. Can be useful in virtual attributes for generating widget-specific HTML.
+Fix: DataAccessor widgets (Form/GridPanel) now don't crash when calculating default columns/fields for the underlying model that has polymorphic columns.
+Fix: TabPanel was sending redundant "tabchange" event to server when initially instantiated.
+Fix: column filters were making GridPanel crash when the column editor was set to "textarea".
+Fix: dongling comma and "delete" object properties caused problems in IE and Safari.
+Fix: a stand-alone TabPanel would not render the active item.
+New: BasicApp: masquerading as "World". In this mode all the "touched" persistent preferences will be overwritten for all roles and users.
+Impr: configuration panel's header now shows the underlying model's name for convenience.
+Fix: MasqueradeSelector widget added.
+
+v0.5.0
+2009-09-06
+Major refactoring and code reorganization.
+Compatibility with netzke-core v0.4.0.
+New: GridPanel now supports adding/editing records in a form and extended configurable search.
+New: GridPanel now can be loaded along with initial data (saves a request to the server).
+New: context menu in GridPanel
+New: "scopes" configuration option added to GridPanel to specify the searchlogic-compatible scope for the data.
+New: "strong_default_attrs" config option added to GridPanel to specify the attributes that will be assigned to each record that is created or modified by the grid.
+Usability: GridPanel's actions now get enabled/disabled according to the current selection.
+Configuration panel for grids and forms now works more consistently.
+New: some smart defaults for column/fields in Grid/FormPanel.
+New: BasicApp supports masquerading and application-wide AJAX activity indicator.
+
 v0.4.2
 2009-05-07
 Fix: afterlayout event bind removed completely because of some tricky inconsistent behavior of Ext. BasicApp initializing code put directly into js_after_constructor.

data/README.rdoc

@@ -5,7 +5,7 @@ Note that if you would like to modify this code or experiment with it, you may b
 
 = Prerequisites
 1. Rails >= 2.2
-2. Ext JS >= 2.0: its root *must* be accessible as RAILS_ROOT/public/extjs. You may symlink your Ext JS library here like this (from your app folder): 
+2. Ext JS >= 2.0: its root *must* be accessible as RAILS_ROOT/public/extjs. You may symlink your Ext JS library here like this (from your app folder):
     cd public && ln -s ~/Developer/extjs/ext-2.2 extjs
 
 3. acts_as_list plugin must be installed: 
@@ -13,10 +13,10 @@ Note that if you would like to modify this code or experiment with it, you may b
 
 = Installation
 Install the gem:
-    gem install netzke-basepack
+    gem install skozlov-netzke-basepack
 
 Include it into environment.rb:
-    config.gem "netzke-basepack"
+    config.gem "skozlov-netzke-basepack"
 
 Include mapping for Netzke controller providing *.js and *.css (in routes.rb):
     map.netzke
@@ -24,14 +24,13 @@ Include mapping for Netzke controller providing *.js and *.css (in routes.rb):
 = Usage
 First, run the generators to have the necessary migrations:
     ./script/generate netzke_core
-    ./script/generate netzke_grid_panel
 
 Do the migrations:
     rake db:migrate
 
 The following example will provide you with a grid-based scaffold for ActiveRecord-model called Book. You may generate it like this:
     ./script/generate model Book title:string amount:integer
-(don't forget to run the migrations after it)
+(don't forget to re-run the migrations after it)
 
 In the controller declare the widget:
 
@@ -39,10 +38,10 @@ In the controller declare the widget:
       netzke :books, :widget_class_name => 'GridPanel', :data_class_name => 'Book'
     end
 
-After a widget is declared in the controller, it can be accessed in 3 different ways: 1) loaded by means of an automatically created controller action which will produce a basic HTML-page with the widget (handy for testing), 2) embedded directly into a view (by means of helpers), 3) dynamically loaded by other widgets (usually by the widget of class 'Application', if you want a desktop-like, AJAX-driven web-app).
+After a widget is declared in the controller, it can be accessed in 3 different ways: 1) loaded by means of an automatically created controller action which will produce a basic HTML-page with the widget (handy for testing), 2) embedded directly into a view (by means of helpers), 3) dynamically loaded by other widgets (like BasicApp-derived, if you want a desktop-like, AJAX-driven web-app).
 
 == Using automatically created controller action
-Without writing any more code, you can access the widget by http://localhost:3000/welcome/books_test. That is to say, you simply append _test to your widget's name (as declared in the controller) to get the action name.
+Without writing any more code, you can access the widget by http://localhost:3000/welcome/books_test. That is to say, you simply append _test to your widget's name (as declared in the controller) to get the action's name.
 
 == Embedding a widget into a view
 netzke-core plugin provides the following 2 helpers to put inside your head-tag (use it in your layout):
@@ -52,8 +51,9 @@ netzke-core plugin provides the following 2 helpers to put inside your head-tag
 
 Declaring a widget in the controller provides you with a couple of helpers that can be used in the view:
 
-1. books_class_definition will contain the javascript code defining the code for the JS class.
-2. books_widget_instance will declare a local javascript variable called book.
+1. books_class_definition will contain the JavaScript code defining the code for the JS class.
+2. books_widget_instance will declare a local JavaScript variable called 'book'.
+3. books_widget_render will provide the JavaScript code that calls the "render" method on the variable declared by books_widget_instance.
 
 Use these helpers inside of the script-tag like the following (in the view):
 	
@@ -61,7 +61,7 @@ Use these helpers inside of the script-tag like the following (in the view):
     <%= books_class_definition %>
     Ext.onReady(function(){
     	<%= books_widget_instance %>
-    	books.render("books");
+    	<%= books_widget_render %>
     })
     </script>
     <div id="books">the widget will be rendered in this div</div>
@@ -84,4 +84,4 @@ TODO: this part will be covered later
 = Credentials
 Testing done with the help of http://github.com/pluginaweek/plugin_test_helper
 
-Copyright (c) 2008-2009 Sergei Kozlov, released under the LGPL 3.0
+Copyright (c) 2008-2009 Sergei Kozlov, released under the MIT license

data/Rakefile

@@ -1,14 +1,40 @@
-require 'echoe'
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "netzke-basepack"
+    gemspec.summary = "Pre-built Netzke widgets for your RIA"
+    gemspec.description = "Pre-built Netzke widgets for your RIA"
+    gemspec.email = "sergei@playcode.nl"
+    gemspec.homepage = "http://github.com/skozlov/netzke-basepack"
+    gemspec.rubyforge_project = "netzke-basepack"
+    gemspec.authors = ["Sergei Kozlov"]
+    gemspec.add_dependency "netzke-core"
+    gemspec.add_dependency "searchlogic"
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
 
-Echoe.new("netzke-basepack") do |p|
-  p.author = "Sergei Kozlov"
-  p.email = "sergei@writelesscode.com"
-  p.summary = "Base Netzke widgets - grid, form, tree, and more"
-  p.url = "http://writelesscode.com"
-  p.runtime_dependencies = ["searchlogic >=1.6.2", "netzke-core >= 0.3.1"]
-  p.development_dependencies = []
-  p.test_pattern = 'test/**/*_test.rb'
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "netzke-basepack #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
 
-  # 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"]
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
 end

data/TODO.rdoc

@@ -0,0 +1,8 @@
+== Priority
+* Make column/fields configuration fool-proof
+* Introduce three-state checkbox for SearchPanel
+* Add icons to buttons to actions (toolbars/menus)
+
+== One day
+* Add status bar to BasicApp
+* Replace xcheckbox with checkbox in FormPanel

data/VERSION

@@ -0,0 +1 @@
+0.5.1

data/javascripts/basepack.js

@@ -8,24 +8,28 @@ Ext.reg('passfield', Ext.netzke.PassField);
 
 // Combobox that knows to talk to the server side (used in both grids and panels)
 Ext.netzke.ComboBox = Ext.extend(Ext.form.ComboBox, {
-  mode          : 'remote',
   displayField  : 'id',
   valueField    : 'id',
   triggerAction : 'all',
   typeAhead     : true,
-  selectOnFocus : true,
   
   initComponent : function(){
-    var row = Ext.data.Record.create([{name:'id'}]);
-    // console.info(this.parentWidget);
-    var store = new Ext.data.Store({
-      proxy         : new Ext.data.HttpProxy({url:this.parentConfig.interface.getCbChoices, jsonData:{column:this.fieldConfig.name}}),
-      reader        : new Ext.data.ArrayReader({root:'data', id:0}, row)
-    });
+    if (this.options) {
+      Ext.apply(this, {
+        store : this.options,
+        mode : "local"
+      });
+    } else {
+      var row = Ext.data.Record.create([{name:'id'}]);
+      var store = new Ext.data.Store({
+        proxy         : new Ext.data.HttpProxy({url:this.parentId+"__get_combobox_options", jsonData:{column:this.name}}),
+        reader        : new Ext.data.ArrayReader({root:'data', id:0}, row)
+      });
     
-    Ext.apply(this, {
-      store : store
-    });
+      Ext.apply(this, {
+        store : store
+      });
+    }
     
     Ext.netzke.ComboBox.superclass.initComponent.apply(this, arguments);
     
@@ -38,38 +42,58 @@ Ext.netzke.ComboBox = Ext.extend(Ext.form.ComboBox, {
     });
   }
 });
+
 Ext.reg('combobox', Ext.netzke.ComboBox);
 
-// TODO: rethink
-Ext.netzke.renderer = function(renderer, c, config){
-  res = null; // null-renderer means "no renderer"
+/* 
+  Accepts a string which either contains:
+  Ext.util.Format method (e.g. 'usMoney'), 
+  or 
+  JSON-encoded array, where the first element is Ext.util.Format method (e.g. 'ellipsis'), 
+  and the rest of the elements - configuration parameters that should be passed to this method besids
+  the value to be rendered (e.g. '2');
+  
+  Example of the latter: ["defaultValue", "MyDefaultValue"]
+*/
+Ext.netzke.normalizedRenderer = function(config) {
+  res = null;
   
-  if (renderer){
-    switch (renderer) {
-
-      // more renderers can be later added like this:
-      case 'my_renderer':
-        res = function(value){ return "My renderer: " + value };
-      break
-
-      // falls back to Ext.util.Format renderers
-      default:
-        res = Ext.util.Format[renderer] ? Ext.util.Format[renderer] : function(value){return "Unknown renderer"}
-      break
+  if (config) {
+    try{
+      config = Ext.decode(config); // it's an array consisting of renderer's name *and* eventual options
+    } catch(e) {
+      // leave config as is - it's supposed to be the renderer's name
+    }
+
+    if (Ext.isArray(config)) {
+      res = function(v){
+        var formatMethod = config[0];
+        var valueAndOptions = config.slice(1);
+        valueAndOptions.unshift(v);
+        // call the Format function with the argument *and* configuration
+        return Ext.util.Format[formatMethod] ? Ext.util.Format[formatMethod].apply(this, valueAndOptions) : "Unknown renderer";
+      }
+    } else {
+      res = Ext.util.Format[config] ? Ext.util.Format[config] : function(v){return "Unknown renderer"}
     }
   }
+    
+  return res;
+};
 
-  return res
+Ext.util.Format.mask = function(v){
+  return "********";
 };
 
 // Mapping of editor field to grid filters
 Ext.netzke.filterMap = {
   numberfield:'Numeric',
   textfield:'String',
+  textarea:'String',
   xdatetime:'String',
   checkbox:'Boolean',
   combobox:'String',
-  date:'Date'
+  datefield:'Date'
 };
 
 Ext.override(Ext.StatusBar, {
@@ -109,6 +133,24 @@ Ext.data.RecordArrayReader = Ext.extend(Ext.data.JsonReader, {
   }
 });
 
+Ext.netzke.JsonField = Ext.extend(Ext.form.TextField, {
+  validator: function(value) {
+    try{
+      var d = Ext.decode(value);
+      return true;
+    } catch(e) {
+      return "Invalid JSON"
+    }
+  }
+  
+  ,setValue: function(value) {
+    this.setRawValue(Ext.encode(value));
+  }
+  
+});
+
+Ext.reg('jsonfield', Ext.netzke.JsonField);
+
 /**
  * @class Ext.ux.form.DateTime
  * @extends Ext.form.Field
@@ -742,3 +784,4 @@ Ext.ux.form.DateTime = Ext.extend(Ext.form.Field, {
 Ext.reg('xdatetime', Ext.ux.form.DateTime);
 
 // eof
+

data/lib/app/models/netzke_auto_column.rb

@@ -0,0 +1,56 @@
+require 'acts_as_list'
+class NetzkeAutoColumn < ActiveRecord::Base
+  
+  acts_as_list
+  default_scope :order => "position"
+
+  # Returns an array of column configuration hashes (without the "id" attribute)
+  def self.all_columns
+    self.all.map do |c|
+      column_hash = c.attributes.reject{ |k,v| k == 'id' }
+      column_hash.each_pair do |k,v|
+        # try to detect JSON format
+        begin
+          normalized_value = v.is_a?(String) ? ActiveSupport::JSON.decode(v) : v
+        rescue ActiveSupport::JSON::ParseError
+          normalized_value = v
+        end
+        column_hash[k] = normalized_value
+      end
+      column_hash
+    end
+  end
+
+  # Build the table with columns for this widget
+  def self.rebuild_table
+    connection.drop_table('netzke_auto_columns') if table_exists?
+  
+    normalized_config_columns = []
+    
+    @@widget.class.config_columns.each do |mc|
+      column_hash = mc.is_a?(Symbol) ? {:name => mc} : mc
+      column_hash[:type] ||= :string
+      normalized_config_columns << column_hash
+    end
+    
+    # create the table with the fields
+    self.connection.create_table('netzke_auto_columns') do |t|
+      normalized_config_columns.each do |mc|
+        t.column mc[:name], mc[:type], :default => mc[:default]
+      end
+      t.column :position, :integer
+    end
+
+    # populate the table with data
+    NetzkeAutoColumn.create @@widget.normalized_columns.map(&:deebeefy_values)
+    
+  end
+
+  def self.widget=(widget)
+    @@widget = widget
+    if Netzke::Base.session["netzke_auto_column_last_widget"] != @@widget.id_name
+      rebuild_table
+      Netzke::Base.session["netzke_auto_column_last_widget"] = @@widget.id_name
+    end
+  end
+end

data/lib/netzke-basepack.rb

@@ -1,8 +1,10 @@
 # External dependencies
 require 'netzke-core'
 require 'searchlogic'
+require 'will_paginate'
 
-require 'netzke/ar_ext'
+require 'netzke/active_record/basepack'
+require 'netzke/ext'
 
 %w{ models }.each do |dir|
   path = File.join(File.dirname(__FILE__), 'app', dir)
@@ -11,10 +13,10 @@ require 'netzke/ar_ext'
   ActiveSupport::Dependencies.load_once_paths.delete(path)
 end
 
-# Make this plugin reloadable for easier development
+# Make this plugin reloadable at app restart for easier development
 ActiveSupport::Dependencies.load_once_paths.delete(File.join(File.dirname(__FILE__)))
 
 # Include javascript & styles required by all basepack widgets. 
 # These files will get loaded at the initial load of the framework (along with Ext and Netzke-core).
 Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/basepack.js"
-Netzke::Base.config[:stylesheets] << "#{File.dirname(__FILE__)}/../stylesheets/basepack.css"
+Netzke::Base.config[:stylesheets] << "#{File.dirname(__FILE__)}/../stylesheets/basepack.css"

data/lib/netzke/accordion_panel.rb

@@ -1,111 +1,113 @@
 module Netzke
-  #
-  # AccordionPanel
+  # == AccordionPanel
   # 
-  # Features:
+  # == Features:
   # * Dynamically loads widgets for the panels that get expanded for the first time
   # * Is loaded along with the active widget - saves a request to the server
   #
-  # TODO:
+  # Future features:
   # * Stores the last active panel in persistent_config
-  # 
   class AccordionPanel < Base
-    #
-    # JS-class generation
-    #
-    module ClassMethods
-
-      def js_default_config
-        super.merge({
-          :layout => 'accordion',
-          :defaults => {:layout => 'fit'}, # Container's items will be of type Panel with layout 'fit' ("fit-panels")
-          :listeners => {
-            # every item gets an expand event set, which dynamically loads a widget into this item 
-            :add => {
-              :fn => <<-JS.l
-              function(self, comp){
-                comp.on('expand', this.loadItemWidget, self)
-              }
-              JS
-            }
-          }
-        })
-      end
+    
+    # JavaScript part
+    def self.js_extend_properties
+      {
+        :layout => 'accordion',
+        :defaults => {:layout => 'fit'},
+        :init_component => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            Ext.netzke.cache.#{short_widget_class_name}.superclass.initComponent.call(this);
 
-      def js_extend_properties
-        {
-          # loads widget into the panel if it wasn't loaded yet
-          :load_item_widget => <<-JS.l,
-            function(panel) {
-              if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.widget + "__get_widget");
-            }
-          JS
-          
-          :on_widget_load => <<-JS.l
-            function(){
-              // immediately instantiate the active panel
-              var activePanel = this.findById(this.id + "_active");
+            // Set events
+            this.items.each(function(i){
+              // Set the expand event
+              i.on('expand', this.loadItemWidget, this);
               
-              var activeItemConfig = this.initialConfig[this.initialConfig.expandedItem+"Config"];
-              if (activeItemConfig) {
-                activePanel.add(new Ext.netzke.cache[activeItemConfig.widgetClassName](activeItemConfig));
+              // If not collapsed, add the active aggregatee (item) into it
+              if (!i.collapsed) {
+                var preloadedItemConfig = this[i.widget.camelize(true) + "Config"];
+                i.add(new Ext.netzke.cache[preloadedItemConfig.widgetClassName](preloadedItemConfig));
+                i.doLayout(); // always needed after adding a component
               }
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        # Loads widget into the panel if it wasn't loaded yet
+        :load_item_widget => <<-END_OF_JAVASCRIPT.l,
+          function(panel) {
+            // if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.widget + "__get_widget");
+            var preloadedItemConfig = this[panel.widget.camelize(true) + "Config"];
+            
+            if (preloadedItemConfig){
+              // preloaded widget only needs to be instantiated, as its class and configuration have already been loaded
+              panel.add(new Ext.netzke.cache[preloadedItemConfig.widgetClassName](preloadedItemConfig));
+              panel.doLayout(); // always needed after adding a component
+            } else {
+              // load the widget from the server
+              this.loadAggregatee({id:panel.widget, container:panel.id});
             }
-          JS
-        }
-      end
+            
+          }
+        END_OF_JAVASCRIPT
+      }
     end
-    extend ClassMethods
-    
-    # some configuration normalization
+
+    # Some normalization of config
     def initialize(*args)
       super
 
       seen_active = false
-
+      
       config[:items].each_with_index do |item, i|
         # if some items are provided without names, give them generated names
         item[:name] ||= "item#{i}"
-
+      
         # remove duplucated :active configuration
         if item[:active]
           item[:active] = nil if seen_active
-          seen_active = true
+          seen_active ||= true
         end
       end
     end
+    
+    # Returns items configs
+    def items
+      @items ||= config[:items]
+    end
 
+    # Provides configs for fit panels (which will effectively be accordion panels)
     def js_config
-      expanded_widget_config = config[:items].detect{|i| i[:active]}
       super.merge({
-        :items => fit_panels,
-        :expanded_item => expanded_widget_config && expanded_widget_config[:name]
+        # these "items" are not related to the "items" of the config, rather these are the items required by the the accordion panel
+        :items => fit_panels
       })
     end
 
-    # the items are late aggregatees, besides the ones that are marked "active"
-    def initial_aggregatees
-      res = {}
-      config[:items].each_with_index do |item, i|
-        item[:late_aggregation] = !item[:active]
-        res.merge!(item[:name].to_sym => item)
-      end
-      res
-    end
-
-    # fit-panels - panels of layout 'fit' that will contain the widgets (items)
+    # "Fit-panels" - panels of layout 'fit' (effectively the accordion panels) that will contain the widgets ("items")
     def fit_panels
       res = []
       config[:items].each_with_index do |item, i|
         res << {
-          :id => item[:active] && id_name + '_active', # to mark the fit-panel which will contain the active widget
-          :title => item[:title] || (item[:name] && item[:name].humanize),
+          # :id => item[:active] && id_name + '_active', # to mark the fit-panel which will contain the active widget
+          :title => item[:title] || (item[:name] && item[:name].to_s.humanize),
           :widget => item[:name], # to know which fit panel will load which widget
           :collapsed => !(item[:active] || false)
         }
       end
       res
     end
+
+    # All items become *late* aggregatees, besides the ones that are marked "active"
+    def initial_aggregatees
+      res = {}
+      config[:items].each_with_index do |item, i|
+        item[:late_aggregation] = !item[:active]
+        res.merge!(item[:name].to_sym => item)
+      end
+      res
+    end
+
     
   end
 end