netzke-basepack 0.6.3 → 0.6.4

data/lib/netzke/data_accessor.rb

@@ -1,113 +0,0 @@
-require 'netzke/active_record'
-
-module Netzke
-  # This module is included into such data-driven components as GridPanel, FormPanel, etc.
-  module DataAccessor
-
-    # Returns options for comboboxes in grids/forms
-    def combobox_options_for_column(column, method_options = {})
-      query = method_options[:query]
-
-      # First, check if we have options for this column defined in persistent storage
-      options = column[:combobox_options] && column[:combobox_options].split("\n")
-      if options
-        query ? options.select{ |o| o.index(/^#{query}/) }.map{ |el| [el] } : options
-      else
-        assoc, assoc_method = assoc_and_assoc_method_for_column(column)
-
-        if assoc
-          # Options for an asssociation attribute
-
-          relation = assoc.klass.scoped
-
-          relation = relation.extend_with(method_options[:scope]) if method_options[:scope]
-
-          if assoc.klass.column_names.include?(assoc_method)
-            # apply query
-            relation = relation.where(:"#{assoc_method}".like => "#{query}%") if query.present?
-            relation.all.map{ |r| [r.send(assoc_method)] }
-          else
-            relation.all.map{ |r| r.send(assoc_method) }.select{ |value| value =~ /^#{query}/  }.map{ |v| [v] }
-          end
-
-        else
-          # Options for a non-association attribute
-          res=data_class.netzke_combo_options_for(column[:name], method_options)
-
-          # ensure it is an array-in-array, as Ext will fail otherwise
-          raise RuntimeError, "netzke_combo_options_for should return an Array" unless res.kind_of? Array
-          return [[]] if res.empty?
-
-          unless res.first.kind_of? Array
-            res=res.map do |v|
-              [v]
-            end
-          end
-          return res
-
-
-        end
-      end
-    end
-
-    # Normalize array of attributes
-    # [:col1, "col2", {:name => :col3}] =>
-    #   [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
-    def normalize_attrs(attrs)
-      attrs.map{ |a| normalize_attr(a) }
-    end
-
-    # Normalize an attribute, e.g.:
-    # :first_name =>
-    #   {:name => "first_name"}
-    def normalize_attr(a)
-      a.is_a?(Symbol) || a.is_a?(String) ? {:name => a.to_s} : a.merge(:name => a[:name].to_s)
-    end
-
-    # 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
-
-    def association_attr?(name)
-      !!name.to_s.index("__")
-    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 = constantize_class_name("Netzke::ModelExtensions::#{config[:model]}For#{short_component_class_name}") || 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 && constantize_class_name(model_name)
-      end
-    end
-
-    # whether a column is bound to the primary_key
-    def primary_key_attr?(a)
-      data_class && a[:name].to_s == data_class.primary_key
-    end
-
-    # Mark an attribute as "virtual" by default, when it doesn't reflect a model column, or a model column of an association
-    def set_default_virtual(c)
-      if c[:virtual].nil? # sometimes at maybe handy to mark a column as non-virtual forcefully
-        assoc, assoc_method = get_assoc_and_method(c)
-        if assoc
-          c[:virtual] = true if !assoc.klass.column_names.map(&:to_sym).include?(assoc_method.to_sym)
-        else
-          c[:virtual] = true if !data_class.column_names.map(&:to_sym).include?(c[:name].to_sym)
-        end
-      end
-    end
-
-  end
-end

data/lib/netzke/ext.rb

@@ -1,7 +0,0 @@
-module Netzke
-  # Ext-related module. Some constants provide meta-information about the Ext.library.
-  module Ext
-    FORM_FIELD_XTYPES = %w{ textfield numberfield textarea combobox checkbox xdatetime }
-    COLUMN_XTYPES = %w{ gridcolumn booleancolumn numbercolumn datecolumn }
-  end
-end

data/lib/netzke/fields_configurator.rb

@@ -1,170 +0,0 @@
-module Netzke
-  # == FieldsConfigurator
-  # Provides dynamic configuring columns/fields for GridPanel and FormPanel.
-  # Configuration parameters:
-  # * <tt>:component</tt> - component to configure columns/fields for
-  class FieldsConfigurator < JsonArrayEditor
-    api :load_defaults
-
-    def default_config
-      super.deep_merge({
-        :name              => 'columns',
-        :ext_config        => {
-          :config_tool => false,
-          :header => false,
-          :enable_extended_search => false,
-          :enable_edit_in_form => false,
-          :enable_rows_reordering => GridPanel.rows_reordering_available,
-          :enable_pagination => false
-        }
-      })
-    end
-
-    action :defaults, {:text => 'Restore defaults', :icon => :wand}
-
-    def default_bbar
-      %w{ add edit apply del }.map(&:action) + "-" + [:defaults.action]
-    end
-
-    # Default columns for the configurator
-    def default_columns
-      [
-        {:name => "id", :attr_type => :integer, :meta => true},
-        {:name => "position", :attr_type => :integer, :meta => true},
-        {:name => "attr_type", :attr_type => :string, :meta => true},
-        *config[:owner].class.meta_columns.map { |c| c[:name] == "name" ? inject_combo_for_name_column(c) : c }
-      ]
-    end
-
-    def self.js_properties
-      {
-        :init_component => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            #{js_full_class_name}.superclass.initComponent.call(this);
-
-            // Automatically set the correct editor for the default_value column
-            this.on('beforeedit', function(e){
-              var column = this.getColumnModel().getColumnById(this.getColumnModel().getColumnId(e.column));
-              var record = this.getStore().getAt(e.row);
-
-              if (column.dataIndex === "default_value") {
-                if (record.get("name") === this.pri) {
-                  // Don't allow setting default value for the primary key
-                  column.setEditor(null);
-                } else {
-                  // Auto set the editor, dependent on the field type
-                  var attrType = record.get("attr_type");
-                  column.setEditor(Ext.create({xtype: this.attrTypeEditorMap[attrType] || "textfield"}));
-                }
-              }
-
-            }, this);
-
-          }
-        END_OF_JAVASCRIPT
-
-        :attr_type_editor_map => {
-          :integer  => "numberfield",
-          :boolean  => "checkbox",
-          :decimal  => "numberfield",
-          :datetime => "xdatetime",
-          :date     => "datefield",
-          :string   => "textfield"
-        },
-
-        # Disable the 'gear' tool for now
-        :on_gear => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            this.feedback("You can't configure configurator (yet)");
-          }
-        END_OF_JAVASCRIPT
-
-        # we need to provide this function so that the server-side commit would happen
-        :get_commit_data => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            return null; // because our commit data is already at the server
-          }
-        END_OF_JAVASCRIPT
-
-        :on_defaults => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
-              if (btn == 'yes') {
-                this.loadDefaults();
-              }
-            }, this);
-          }
-        END_OF_JAVASCRIPT
-      }
-    end
-
-    def load_defaults(params)
-      # Reload the temp table with default values
-      data_class.replace_data(default_owner_fields)
-
-      # ... and reflect it in the persistent storage
-      on_data_changed
-
-      # Update the grid
-      {:load_store_data => get_data}
-    end
-
-    # Never show the config tool
-    def config_tool_needed?
-      false
-    end
-
-    private
-
-      # An override
-      def process_data(data, operation)
-        if operation == :update
-          meta_attrs_to_update = data.inject({}) do |r,el|
-            r.merge({
-              data_class.find(el["id"]).name => el.reject{ |k,v| k == "id" }
-            })
-          end
-
-          res = super
-
-          NetzkeFieldList.update_fields(config[:owner].global_id, meta_attrs_to_update)
-
-          res
-        else
-          super
-        end
-      end
-
-      # An override
-      def store_data(data)
-        NetzkeFieldList.update_list_for_current_authority(config[:owner].global_id, data, config[:owner].data_class.name)
-      end
-
-      # An override
-      def initial_data
-        NetzkeFieldList.read_list(config[:owner].global_id) || default_owner_fields
-      end
-
-      # Set strict combo for the "name" column, with options of the attributes provided by the data_class
-      def inject_combo_for_name_column(c)
-        netzke_attrs = config[:owner].data_class.netzke_attributes.map{ |a| a[:name] }
-        c.merge(:editor => {:xtype => :combo, :store => netzke_attrs, :force_selection => true})
-      end
-
-      def default_owner_fields
-        config[:owner].initial_columns(false).map(&:deebeefy_values)
-      end
-
-      # This is an override of GridPanel#on_data_changed
-      def on_data_changed
-        # Default column settings taken from
-        defaults_hash = config[:owner].class.meta_columns.inject({}){ |r, c| r.merge!(c[:name] => c[:default_value]) }
-        stripped_columns = data_class.all_columns.map do |c|
-          # reject all keys that are 1) same as defaults
-          c.reject{ |k,v| defaults_hash[k.to_sym].to_s == v.to_s }
-        end
-        store_data(stripped_columns)
-      end
-
-  end
-end

data/lib/netzke/json_array_editor.rb

@@ -1,67 +0,0 @@
-module Netzke
-  # Abstract GridPanel-based editor for a JSON array of homogenious objects.
-  # Inherit from it in order to override:
-  #   <tt>store_data</p> - passes the data to be saved (e.g. to the persistant storage)
-  #   <tt>initial_data</p> - should return initial data (e.g. from the persistant storage)
-  # For an example of an implementation, see Netzke::FieldsConfigurator.
-  class JsonArrayEditor < GridPanel
-    def initialize(*args)
-      super
-      data_class.configure(:owner => global_id, :columns => dynamic_fields, :initial_data => initial_data)
-    end
-
-    def data_class
-      NetzkePersistentArrayAutoModel
-    end
-
-    # Fields for NetzkePersistentArrayAutoModel (override it)
-    def dynamic_fields
-      default_columns.collect do |c|
-        {
-          :name => c[:name],
-          :type => c[:attr_type] == :json ? :text : c[:attr_type], # store :json columns as :text
-          :default => c[:default_value]
-        }
-      end
-    end
-
-    # Default predifined columns (override if needed)
-    def default_columns
-      [{
-        :name => :id,
-        :attr_type => :integer
-      },{
-        :name => :name,
-        :attr_type => :string
-      },{
-        :name => :position,
-        :attr_type => :integer
-      }]
-    end
-
-    # Don't show the config tool
-    # def config_tool_needed?
-    #   false
-    # end
-
-    def before_load
-      data_class.rebuild_table
-      super
-    end
-
-    private
-      # Override this
-      def store_data(data); end
-
-      # Override this
-      def initial_data
-        []
-      end
-
-      # This is an override of GridPanel#on_data_changed
-      def on_data_changed
-        store_data(data_class.all_columns)
-      end
-
-  end
-end

data/lib/netzke/masquerade_selector.rb

@@ -1,53 +0,0 @@
-module Netzke
-  class MasqueradeSelector < TabPanel
-
-    def items
-      @items ||= [{
-          :name              => "roles",
-          :active            => true,
-          :class_name => "GridPanel",
-          :model   => 'Role',
-          :columns           => [:id, :name],
-          :ext_config => {
-            :header        => false,
-            :bbar => ['search']
-          }
-        },{
-          :name                 => "users",
-          :preloaded            => true,
-          :class_name    => "GridPanel",
-          :model      => 'User',
-          :ext_config           => {
-            :header        => false,
-            :rows_per_page => 10,
-            :bbar => ['search']
-          },
-          :columns => [:id, :login]
-      }]
-    end
-
-    def self.js_properties
-      {
-        :after_constructor => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            this.items.each(function(tab){
-              tab.on('add', function(ct, cmp){
-                cmp.on('rowclick', this.rowclickHandler, this);
-              }, this);
-            }, this);
-          }
-        END_OF_JAVASCRIPT
-
-        :rowclick_handler => <<-END_OF_JAVASCRIPT.l
-          function(grid, rowIndex, e){
-            var mode = grid.id.split("__").pop();
-            var normMode = mode === 'users' ? 'user' : 'role';
-            this.masquerade = {};
-            this.masquerade[normMode] = grid.store.getAt(rowIndex).get('id');
-          }
-        END_OF_JAVASCRIPT
-      }
-    end
-
-  end
-end

data/test/rails_app/app/components/some_search_panel.rb

@@ -1,34 +0,0 @@
-class SomeSearchPanel < Netzke::Basepack::FormPanel
-  def config
-    orig = super
-    {
-      :model => "User",
-      :title => "Some Search Panel",
-      :items => [{:name => :first_name.like}, {:name => :created_at.gt}]
-    }.deep_merge orig
-  end
-
-  def normalize_field(f)
-    f = if f.is_a?(Symbol) || f.is_a?(String)
-      {:name => f.to_s, :operator => default_operator}
-    else
-      search_condition = f[:name]
-      if search_condition.is_a?(MetaWhere::Column)
-        {:name => search_condition.column, :operator => search_condition.method}
-      else
-        {:name => search_condition.to_s, :operator => default_operator}
-      end
-    end
-
-    f[:disabled] = primary_key_attr?(f)
-
-    f = super(f)
-
-    f.merge(:name => [f[:name], "__", f[:operator]].join)
-  end
-
-  private
-    def default_operator
-      "gt"
-    end
-end