netzke-basepack 0.5.12 → 0.5.13

data/CHANGELOG.rdoc

@@ -1,3 +1,16 @@
+= v0.5.13 - 2010-08-11
+* regression
+  * combobox options configuration again has effect
+  
+* bug fix
+  * when a TabPanel was used as a standalone widget, the first tab was rendered empty
+  * Grid/FormPanel: dynamically changing of columns doesn't erase those column settings that are not configurable via GUI, but which were specified in the code
+  
+* enhancements
+  * scopes can now be specified for an association combobox in Grid/FormPanels
+  * GridPanel: you can now configure add/edit/multi_edit/search panels (e.g. to override the fields) and corresponding windows (e.g. to override the title)
+  * minor refactoring GridPanel: moved static js out of grid_panel_js.rb
+
 = v0.5.12 - 2010-06-21
 * Fix: when used with Bundler, was crashing with the "uninitialized constant" exception
 

data/Rakefile

@@ -1,7 +1,7 @@
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.version = "0.5.12"
+    gemspec.version = "0.5.13"
     gemspec.name = "netzke-basepack"
     gemspec.summary = "Pre-built Rails + ExtJS widgets for your RIA"
     gemspec.description = "A set of full-featured extendible Netzke widgets (such as FormPanel, GridPanel, Window, BorderLayoutPanel, etc) which can be used as building block for your RIA"
@@ -9,7 +9,7 @@ begin
     gemspec.homepage = "http://github.com/skozlov/netzke-basepack"
     gemspec.rubyforge_project = "netzke-basepack"
     gemspec.authors = ["Sergei Kozlov"]
-    gemspec.add_dependency("netzke-core", ">=0.5.3")
+    gemspec.add_dependency("netzke-core", ">=0.5.4")
     gemspec.add_dependency("searchlogic", ">=2.0.0")
     gemspec.add_dependency("will_paginate", ">=2.0.0")
     gemspec.add_dependency("acts_as_list", ">=0.1.2")

data/TODO.rdoc

@@ -1,6 +1,10 @@
 == Priority
 * Add icons to buttons to actions (toolbars/menus)
 * On grid refresh, reset the dirty fields, so that the "Apply" button doesn't do anything
+* GridPanel's read_only vs editable (doesn't work now) options
+* Solve the confusion about columns being stored in the persistent config
+* Inclusion of css in a stand-alone widget
+* Rename the "l" method to something else
 
 == Foolproof
 * Should not be possible delete the "ID" field from grids/forms

data/lib/app/models/netzke_persistent_array_auto_model.rb

@@ -41,7 +41,7 @@ class NetzkePersistentArrayAutoModel < ActiveRecord::Base
     # only select those attributes that were provided to us as columns. The rest is ignored.
     column_names = config[:columns].map{ |c| c[:name] }
     clean_data = data.collect{ |c| c.reject{ |k,v| !column_names.include?(k.to_s) } } 
-    
+    Rails.logger.debug "!!! clean_data: #{clean_data.inspect}\n"
     self.delete_all
     self.create(clean_data)
   end

data/lib/netzke/active_record/attributes.rb

@@ -56,7 +56,7 @@ module Netzke::ActiveRecord::Attributes
           in_columns_hash = columns_hash[attr_name] && {:name => attr_name, :attr_type => columns_hash[attr_name].type, :default_value => columns_hash[attr_name].default} || {} # {:virtual => true} # if nothing found in columns, mark it as "virtual" or not?
           if in_columns_hash.empty?
             # If not among the model columns, it's either virtual, or an association
-            merged = association_attr?(attr_name) ? {:name => attr_name} : declared.merge(:virtual => true)
+            merged = association_attr?(attr_name) ? declared.merge!(:name => attr_name) : declared.merge(:virtual => true)
           else
             # .. otherwise merge with what's declared
             merged = in_columns_hash.merge(declared)

data/lib/netzke/active_record/combobox_options.rb

@@ -1,43 +1,13 @@
 module Netzke::ActiveRecord::ComboboxOptions
   module ClassMethods
-    # TODO: rename to netzke_options_for (to avoid polluting the namespace)
+    # TODO: rename to netzke_options_for (to avoid naming conflicts)
     def options_for(column, query = "")
-      # First, check if we have options for this class and column defined in persistent storage
-      # NetzkePreference.widget_name = self.name
-      # options = NetzkePreference[:combobox_options] || {}
-      # if options[column]
-      #   options[column].select{ |o| o.index(/^#{query}/) }
-      if respond_to?("#{column}_combobox_options")
-        # AR model provides the choices itself
-        send("#{column}_combobox_options", query)
-      else
-        # Returns all unique values for a column, filtered with <tt>query</tt>
-        if (assoc_name, *assoc_method = column.split('__')).size > 1
-          # column is an association column
-          assoc_method = assoc_method.join('__') # in case we get something like country__continent__name
-          association = reflect_on_association(assoc_name.to_sym) || raise(NameError, "Association #{assoc_name} not known for class #{name}")
-          association.klass.options_for(assoc_method, query)
-        else
-          column = assoc_name
-          if self.column_names.include?(column)
-            # it's simply a column in the table
-            records = query.empty? ? find_by_sql("select distinct #{column} from #{table_name}") : find_by_sql("select distinct #{column} from #{table_name} where #{column} like '#{query}%'")
-            records.map{|r| r.send(column)}
-          else
-            # it's a "virtual" column - the least effective search
-            records = self.find(:all).map{|r| r.send(column)}.uniq
-            query.empty? ? records : records.select{|r| r.index(/^#{query}/)}
-          end
-        end
-      end
+      records = query.empty? ? find_by_sql("select distinct #{column} from #{table_name}") : find_by_sql("select distinct #{column} from #{table_name} where #{column} like '#{query}%'")
+      records.map{|r| r.send(column)}
     end
   end
   
-  module InstanceMethods
-  end
-  
   def self.included(receiver)
     receiver.extend         ClassMethods
-    receiver.send :include, InstanceMethods
   end
 end

data/lib/netzke/data_accessor.rb

@@ -1,15 +1,10 @@
 require "netzke/active_record/data_accessor"
+require "searchlogic"
 
 module Netzke
-  # This module is included into such data-driven widgets as GridPanel, FormPanel, etc. It provides for
-  # flexible pre-configuration of (virtual) attributes.
-  #
-  # TODO: show examples of how to create the helpers
+  # This module is included into such data-driven widgets as GridPanel, FormPanel, etc.
   module DataAccessor
-    
-    # This method should be called from the constructor of the widget. It dynamically includes:
-    # 1) helpers into the data model for this widget; those may contain instance methods used as virtual attributes
-    # 2) generic (used by all "data accessor" widgets) extensions into the data model for this widget
+    # This method should be called from the constructor of the widget.
     def apply_helpers
       # Generic extensions to the data model
       if data_class # because some widgets, like FormPanel, may have it optional
@@ -17,6 +12,41 @@ module Netzke
       end
     end
     
+    # Returns options for comboboxes in grids/forms
+    def combobox_options_for_column(column, method_options = {})
+      # First, check if we have options for this column defined in persistent storage
+      options = column[:combobox_options] && column[:combobox_options].split("\n")
+      if options
+        (method_options[:query].nil? ? options : options.select{ |o| o.index(/^#{method_options[:query]}/) }).map{ |el| [el] }
+      else      
+        assoc, assoc_method = assoc_and_assoc_method_for_column(column)
+      
+        if assoc
+          # Options for an asssociation attribute
+        
+          search = assoc.klass.searchlogic
+      
+          # apply scopes
+          method_options[:scopes] && method_options[:scopes].each do |s|
+            if s.is_a?(Array)
+              scope_name, *args = s
+              search.send(scope_name, *args)
+            else
+              search.send(s, true)
+            end
+          end
+        
+          # apply query
+          search.send("#{assoc_method}_like", "#{method_options[:query]}%") if method_options[:query]
+        
+          search.all.map{ |r| [r.send(assoc_method)] }
+        else
+          # Options for a non-association attribute
+          data_class.options_for(column[:name], method_options[:query]).map{|s| [s]}
+        end
+      end
+    end
+    
     # [:col1, "col2", {:name => :col3}] =>
     #   [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
     def normalize_attr_config(cols)
@@ -24,26 +54,16 @@ module Netzke
         c.is_a?(Symbol) || c.is_a?(String) ? {:name => c.to_s} : c.merge(:name => c[:name].to_s)
       end
     end
-
-    # Make sure we have keys as symbols, not strings
-    def normalize_array_of_columns(arry)
-      arry.map do |f| 
-        if f.is_a?(Hash)
-          f.symbolize_keys
-        else
-          f.to_sym
-        end
-      end
-    end
     
-    # From symbol to config hash
-    def normalize_column(field)
-      field.is_a?(Symbol) ? {:name => field.to_s} : field
+    # Returns association and association method for a column
+    def assoc_and_assoc_method_for_column(c)
+      assoc_name, assoc_method = c[:name].split('__')
+      assoc = data_class.reflect_on_association(assoc_name.to_sym) if assoc_method
+      [assoc, assoc_method]
     end
-    
-    # From symbols to config hashes
-    def normalize_columns(items)
-      items.map{|c| normalize_column(c)}
+   
+    def association_attr?(name)
+      !!name.to_s.index("__")
     end
     
   end

data/lib/netzke/form_panel.rb

@@ -65,15 +65,21 @@ module Netzke
       apply_helpers
     end
     
+    # Model class
     # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
     def data_class
       @data_class ||= begin
         klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_widget_class_name}".constantize rescue nil
-        klass || begin
-          ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-          model_name = config[:model] || config[:data_class_name]
-          model_name && model_name.constantize
-        end
+        klass || original_data_class
+      end
+    end
+    
+    # Model class before model extensions are taken into account
+    def original_data_class
+      @original_data_class ||= begin
+        ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+        model_name = config[:model] || config[:data_class_name]
+        model_name && model_name.constantize
       end
     end
     

data/lib/netzke/form_panel/form_panel_api.rb

@@ -59,8 +59,12 @@ module Netzke
       def get_combobox_options(params)
         column = params[:column]
         query = params[:query]
+        
+        column = fields.detect{ |c| c[:name] == params[:column] }.try(:to_options!)
+        scopes = column.to_options[:scopes]
+        query = params[:query]
 
-        {:data => data_class.options_for(column, query).map{|s| [s]}}
+        {:data => combobox_options_for_column(column, :query => query, :scopes => scopes)}
       end
   
       def configuration_panel__fields__get_combobox_options(params)

data/lib/netzke/form_panel/form_panel_fields.rb

@@ -14,71 +14,70 @@ module Netzke
         end
       end
       
-      module InstanceMethods
-        def fields
-          @fields ||= begin
-            flds = load_fields
-            flds ||= initial_fields
-            
-            flds.map! do |c|
-              value = record.send(c[:name])
-              value.nil? ? c : c.merge(:value => value)
-            end if record
-            
-            flds
-          end
+      def fields
+        @fields ||= begin
+          flds = load_fields
+          reverse_merge_equally_named_fields(flds, initial_fields) if flds
+          flds ||= initial_fields
+          
+          flds.map! do |c|
+            value = record.send(c[:name])
+            value.nil? ? c : c.merge(:value => value)
+          end if record
+          
+          flds
         end
+      end
 
-        def default_fields
-          @default_fields ||= load_model_level_attrs || (data_class && data_class.netzke_attributes) || []
-        end
+      def default_fields
+        @default_fields ||= load_model_level_attrs || (data_class && data_class.netzke_attributes) || []
+      end
 
-        def initial_fields(only_included = true)
-          ::ActiveSupport::Deprecation.warn("The :columns option for FormPanel is deprecated. Use :fields instead", caller) if config[:columns]
-          
-          # Normalize here, as from the config we can get symbols (names) instead of hashes
-          fields_from_config = (config[:columns] || config[:fields]) && normalize_attr_config(config[:columns] || config[:fields])
+      def initial_fields(only_included = true)
+        ::ActiveSupport::Deprecation.warn("The :columns option for FormPanel is deprecated. Use :fields instead", caller) if config[:columns]
+        
+        # Normalize here, as from the config we can get symbols (names) instead of hashes
+        fields_from_config = (config[:columns] || config[:fields]) && normalize_attr_config(config[:columns] || config[:fields])
 
-          if fields_from_config
-            # reverse-merge each column hash from config with each column hash from exposed_attributes (fields from config have higher priority)
-            for c in fields_from_config
-              corresponding_exposed_column = default_fields.find{ |k| k[:name] == c[:name] }
-              c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
-            end
-            fields_for_create = fields_from_config
-          elsif default_fields
-            # we didn't have fields configured in widget's config, so, use the fields from the data class
-            fields_for_create = default_fields
-          else
-            raise ArgumentError, "No fields specified for widget '#{global_id}'"
+        if fields_from_config
+          # reverse-merge each column hash from config with each column hash from exposed_attributes (fields from config have higher priority)
+          for c in fields_from_config
+            corresponding_exposed_column = default_fields.find{ |k| k[:name] == c[:name] }
+            c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
           end
-          
-          fields_for_create.reject!{ |c| c[:included] == false }
-          
-          fields_for_create.map! do |c|
-            if data_class
-
-              detect_association_with_method(c)
-              
-              # detect association column (e.g. :category_id)
-              if assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
-                c[:xtype] ||= xtype_for_association
-                assoc_method = %w{name title label id}.detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
-                c[:name] = "#{assoc.name}__#{assoc_method}"
-              end
+          fields_for_create = fields_from_config
+        elsif default_fields
+          # we didn't have fields configured in widget's config, so, use the fields from the data class
+          fields_for_create = default_fields
+        else
+          raise ArgumentError, "No fields specified for widget '#{global_id}'"
+        end
+        
+        fields_for_create.reject!{ |c| c[:included] == false }
+        
+        fields_for_create.map! do |c|
+          if data_class
 
-              c[:hidden] = true if c[:name] == data_class.primary_key && c[:hidden].nil? # hide ID column by default
+            detect_association_with_method(c)
+            
+            # detect association column (e.g. :category_id)
+            if assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
+              c[:xtype] ||= xtype_for_association
+              assoc_method = %w{name title label id}.detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
+              c[:name] = "#{assoc.name}__#{assoc_method}"
             end
 
-            set_default_field_label(c)
-            
-            c[:xtype] ||= xtype_for_attr_type(c[:attr_type]) # unless xtype_map[type].nil?
-            c
+            c[:hidden] = true if c[:name] == data_class.primary_key && c[:hidden].nil? # hide ID column by default
           end
 
-          fields_for_create
-
+          set_default_field_label(c)
+          
+          c[:xtype] ||= xtype_for_attr_type(c[:attr_type]) # unless xtype_map[type].nil?
+          c
         end
+
+        fields_for_create
+
       end
       
       private
@@ -130,13 +129,16 @@ module Netzke
               end
             end
           end
-          
         end
 
+        # Receives 2 arrays of columns. Merges the missing config from the +source+ into +dest+, matching columns by name
+        def reverse_merge_equally_named_fields(dest, source)
+          dest.each{ |dc| dc.reverse_merge!(source.detect{ |sc| sc[:name] == dc[:name] }) }
+        end
+        
       
       def self.included(receiver)
         receiver.extend         ClassMethods
-        receiver.send :include, InstanceMethods
 
         receiver.class_eval do
           alias :initial_columns :initial_fields

data/lib/netzke/grid_panel.rb

@@ -44,7 +44,7 @@ module Netzke
   # * <tt>:strong_default_attrs</tt> - a hash of attributes to be merged atop of every created/updated record.
   # * <tt>:scopes</tt> - an array of named scopes to filter grid data, e.g.:
   #     
-  #     [["user_id_not", 100], ["name_like", "Peter"]]
+  #     [["user_id_not", 100], ["name_like", "Peter"], :recent]
   # 
   # In the <tt>:ext_config</tt> hash (see Netzke::Base) the following GridPanel specific options are available:
   # 
@@ -57,10 +57,12 @@ module Netzke
   # * <tt>:rows_per_page</tt> - number of rows per page (ignored when <tt>:enable_pagination</tt> is set to <tt>false</tt>)
   # * <tt>:load_inline_data</tt> - load initial data into the grid right after its instantiation (saves a request to server); defaults to <tt>true</tt>
   # * <tt>:mode</tt> - when set to <tt>:config</tt>, GridPanel loads in configuration mode
+  # * <tt>:add/edit/multi_edit/search_form_config</tt> - additional configuration for add/edit/multi_edit/search form panel
+  # * <tt>:add/edit/multi_edit_form_window_config</tt> - additional configuration for the window that wrapps up add/edit/multi_edit form panel
   # 
   # Additionally supports Netzke::Base config options.
   # 
-  # == Column
+  # == Columns
   # Here's how the GridPanel decides which columns in which sequence and with which configuration to display.
   # First, the column configs are aquired from this GridPanel's persistent storage, as an array of hashes, each 
   # representing a column configuration, such as:
@@ -75,7 +77,7 @@ module Netzke
   # ... which in its turn overrides the defaults provided by persistent storage managed by the AttributesConfigurator
   # that provides *model-level* (as opposed to a widget-level) configuration of a database model 
   # (which is used by both grids and forms in Netzke).
-  # And lastly, the defaults for AttributesConfigurator are calculated from the database model itself, powered by Netzke.
+  # And lastly, the defaults for AttributesConfigurator are calculated from the database model itself (extended by Netzke).
   # For example, in the model you can specify virtual attributes and their types that will be picked up by Netzke, the default
   # order of columns, or excluded columns. For details see <tt>Netzke::ActiveRecord::Attributes</tt>.
   # 
@@ -97,7 +99,6 @@ module Netzke
     
     # Code shared between GridPanel, FormPanel, and other widgets that serve as interface to database tables
     include Netzke::DataAccessor
-    
 
     def self.enforce_config_consistency
       config[:default_config][:ext_config][:enable_edit_in_form]    &&= config[:edit_in_form_available]
@@ -139,7 +140,13 @@ module Netzke
 
     # Include extra javascript that we depend on
     def self.include_js
-      res = []
+      res = ["#{File.dirname(__FILE__)}/grid_panel/javascripts/grid_panel_pre.js"]
+      
+      # Optional edit in form functionality
+      res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/edit_in_form.js" if config[:edit_in_form_available]
+      
+      # Optional extended search functionality
+      res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/advanced_search.js" if config[:extended_search_available]
       
       # Checkcolumn
       ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
@@ -173,53 +180,42 @@ module Netzke
     # Edit in form
     api :create_new_record if config[:edit_in_form_available]
 
+    # Model class
     # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
     def data_class
       @data_class ||= begin
         klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_widget_class_name}".constantize rescue nil
-        klass || begin
-          ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-          model_name = config[:model] || config[:data_class_name]
-          model_name.nil? ? raise(ArgumentError, "No model specified for widget #{global_id}") : model_name.constantize
-        end
+        klass || original_data_class
       end
     end
     
+    # Model class before model extensions are taken into account
+    def original_data_class
+      @original_data_class ||= begin
+        ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+        model_name = config[:model] || config[:data_class_name]
+        model_name.nil? ? raise(ArgumentError, "No model specified for widget #{global_id}") : model_name.constantize
+      end
+    end
+
     def initialize(config = {}, parent = nil)
       super
-
       apply_helpers
     end
 
-    # def data_class
-    #   klass = "Netzke::ModelExtensions::#{data_class.name}#{short_widget_class_name}Ext".constantize rescue nil
-    #   klass || data_class
-    # end
-    
     # Fields to be displayed in the "General" tab of the configuration panel
     def self.property_fields
-      res = [
+      [
         {:name => :ext_config__title,               :type => :string},
         {:name => :ext_config__header,              :type => :boolean, :default => true},
         {:name => :ext_config__enable_context_menu, :type => :boolean, :default => true},
-        # {:name => :ext_config__context_menu,        :type => :json},
         {:name => :ext_config__enable_pagination,   :type => :boolean, :default => true},
         {:name => :ext_config__rows_per_page,       :type => :integer},
-        # {:name => :ext_config__bbar,                :type => :json},
         {:name => :ext_config__prohibit_create,     :type => :boolean},
         {:name => :ext_config__prohibit_update,     :type => :boolean},
         {:name => :ext_config__prohibit_delete,     :type => :boolean},
         {:name => :ext_config__prohibit_read,       :type => :boolean}
       ]
-      
-      # res << {:name => :ext_config__enable_extended_search, :type => :boolean} if config[:extended_search_available]
-      # res << {:name => :ext_config__enable_edit_in_form, :type => :boolean} if config[:edit_in_form_available]
-      
-      # TODO: a buggy thing
-      # res << {:name => :layout__columns,                 :type => :json}
-      
-      res
-      
     end
     
     def default_config
@@ -298,7 +294,7 @@ module Netzke
         :add_form => {
           :class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :title => "Add #{data_class.name.humanize}",
+            :title => "Add #{data_class.table_name.singularize.humanize}",
             :button_align => "right"
           },
           :item => {
@@ -314,13 +310,13 @@ module Netzke
               :mode => ext_config[:mode]
             },
             :record => data_class.new
-          }
-        },
+          }.deep_merge(config[:add_form_config] || {})
+        }.deep_merge(config[:add_form_window_config] || {}),
         
         :edit_form => {
           :class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :title => "Edit #{data_class.name.humanize}",
+            :title => "Edit #{data_class.table_name.singularize.humanize}",
             :button_align => "right"
           },
           :item => {
@@ -333,13 +329,13 @@ module Netzke
               :header => false,
               :mode => ext_config[:mode]
             }
-          },
-        },
+          }.deep_merge(config[:edit_form_config] || {})
+        }.deep_merge(config[:edit_form_window_config] || {}),
         
         :multi_edit_form => {
           :class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :title => "Edit #{data_class.name.humanize}",
+            :title => "Edit #{data_class.table_name.humanize}",
             :button_align => "right"
           },
           :item => {
@@ -352,8 +348,8 @@ module Netzke
               :header => false,
               :mode => ext_config[:mode]
             }
-          }
-        }
+          }.deep_merge(config[:multi_edit_form_config] || {})
+        }.deep_merge(config[:multi_edit_form_window_config] || {})
       }) if ext_config[:enable_edit_in_form]
       
       # Extended search
@@ -368,7 +364,7 @@ module Netzke
             :bbar => false, 
             :mode => ext_config[:mode]
           },
-        }
+        }.deep_merge(config[:search_form_config] || {})
       }) if ext_config[:enable_extended_search]
       
       res