netzke-basepack 0.12.0 → 0.12.1

data/Gemfile

@@ -7,6 +7,8 @@ gem 'sqlite3'
 gem 'yard'
 gem 'rake'
 
+gem 'awesome_nested_set'
+
 group :test do
   gem 'rspec'
   gem 'rspec-rails'
@@ -21,5 +23,6 @@ group :development, :test do
   gem 'web-console', '~> 2.0'
   # gem 'spring' # troubles...
   gem 'pry-rails'
-  gem 'netzke-testing'
+  gem 'netzke-core', github: 'netzke/netzke-core'
+  gem 'netzke-testing', github: 'netzke/netzke-testing'
 end

data/README.md

@@ -14,6 +14,7 @@ A pack of pre-built [Netzke](http://netzke.org) components that can be used as b
 Basepack includes the following components:
 
 * [Grid](http://rdoc.info/github/netzke/netzke-basepack/Netzke/Basepack/Grid) - a grid panel with a thick bag of features
+* [Tree](http://rdoc.info/github/netzke/netzke-basepack/Netzke/Basepack/Tree) - a tree panel with features similar to the Grid
 * [Form](http://rdoc.info/github/netzke/netzke-basepack/Netzke/Basepack/Form) - a form panel with automatic binding of fields
 * [TabPanel](http://rdoc.info/github/netzke/netzke-basepack/Netzke/Basepack/TabPanel) - a tab panel with support for lazy loading of nested components
 * [Accordion](http://rdoc.info/github/netzke/netzke-basepack/Netzke/Basepack/Accordion) - an accordion panel with support for lazy loading of nested components
@@ -28,7 +29,7 @@ enhancing any grid with live search functionality
 
 ## Requirements
 
-* Ruby > 2.0.0
+* Ruby > 1.9.3
 * Rails ~> 4.2.0
 * Ext JS = 5.1.0
 

data/javascripts/basepack.js

@@ -1,5 +1,4 @@
-Ext.ns("Netzke.pre");
-Ext.ns("Netzke.pre.Basepack");
+Ext.ns("Netzke.mixins.Basepack");
 Ext.ns("Ext.ux.grid");
 
 Ext.util.Format.mask = function(v){
@@ -34,3 +33,11 @@ Netzke.isModelDefined = function(name) {
 Netzke.modelName = function(name){
   return "Netzke.models." + name;
 };
+
+// Fix 2-digit precision in the numeric filter
+Ext.define('Ext.grid.filters.filter.Number', {
+  override: 'Ext.grid.filters.filter.Number',
+  getItemDefaults: function() {
+    return Ext.apply(this.itemDefaults, { decimalPrecision: 10 });
+  }
+});

data/javascripts/columns.js

@@ -0,0 +1,224 @@
+/* Shared column-related functionality, used in Tree and Grid */
+Ext.define("Netzke.mixins.Basepack.Columns", {
+  netzkeBuildModel: function(modelClass) {
+    if (!Netzke.isModelDefined(this.id)) {
+      Ext.define(Netzke.modelName(this.id), {
+        extend: modelClass,
+        idProperty: this.pri, // Primary key
+        fields: this.fields
+      });
+    }
+    delete this.pri;
+  },
+
+  netzkeProcessColumns: function() {
+    this.fields = [];
+
+    // Run through columns and set up different configuration for each
+    Ext.each(this.columns, function(c, i){
+
+      this.netzkeNormalizeRenderer(c);
+
+      // Build the field configuration for this column
+      var fieldConfig = {name: c.name, defaultValue: c.defaultValue, allowNull: true};
+
+      if (c.name !== 'meta') fieldConfig.type = this.netzkeFieldTypeForAttrType(c.attrType); // field type (grid editors need this to function well)
+
+      if (c.attrType == 'datetime') {
+        fieldConfig.dateFormat = 'Y-m-d H:i:s'; // set the format in which we receive datetime from the server (so that the model can parse it)
+
+        // While for 'date' columns the renderer is set up automatically (through using column's xtype), there's no appropriate xtype for our custom datetime column.
+        // Thus, we need to set the renderer manually.
+        // NOTE: for Ext there's no distinction b/w date and datetime; date fields can include time.
+        if (!c.renderer) {
+          // format in which the data will be rendered; if c.format is nil, Ext.Date.defaultFormat extended with time will be used
+          c.renderer = Ext.util.Format.dateRenderer(c.format || Ext.Date.defaultFormat + " H:i:s");
+        }
+      };
+
+      if (c.attrType == 'date') {
+        // If no dateFormat given for date attrType, Timezone translation can subtract zone offset from 00:00:00 causing previous day.
+        fieldConfig.dateFormat = 'Y-m-d';
+      };
+
+      // because checkcolumn doesn't care about editor (not) being set, we need to explicitely set readOnly here
+      if (c.xtype == 'checkcolumn' && !c.editor) {
+        c.readOnly = true;
+      }
+
+      this.fields.push(fieldConfig);
+
+      // We will not use meta columns as actual columns (not even hidden) - only to create the records
+      if (c.meta) {
+        this.metaColumn = c;
+        return;
+      }
+
+      // Set rendeder for association columns (the one displaying associations by the specified method instead of id)
+      if (c.assoc) {
+        // Editor for association column
+        if (c.editor) c.editor = Ext.apply({ name: c.name }, c.editor);
+
+        // Renderer for association column
+        this.netzkeNormalizeAssociationRenderer(c);
+      }
+
+      if (c.editor) {
+        Ext.applyIf(c.editor, {selectOnFocus: true, netzkeParent: this});
+      }
+
+      // Setting the default filter type
+      if (c.filterable != false && !c.filter) {
+        c.filter = {type: this.netzkeFilterTypeForAttrType(c.attrType)};
+      }
+
+      // setting dataIndex
+      c.dataIndex = c.name;
+
+    }, this);
+
+    // Now reorder columns as specified in this.columnsOrder
+    this.orderColumns();
+  },
+
+  // Build column model config with columns in the correct order; columns out of order go to the end.
+  orderColumns: function(){
+    var colModelConfig = [];
+
+    Ext.each(this.columnsOrder, function(c) {
+      var mainColConfig;
+
+      Ext.each(this.columns, function(oc) {
+        if (c.name === oc.name) {
+          mainColConfig = Ext.apply({}, oc);
+          return false;
+        }
+      });
+
+      colModelConfig.push(Ext.apply(mainColConfig, c));
+    }, this);
+
+    // We don't need original columns any longer
+    delete this.columns;
+
+    // ... instead, define own column model
+    this.columns = colModelConfig;
+  },
+
+  // Normalizes the renderer for a column.
+  // Renderer may be:
+  // 1) a string that contains the name of the function to be used as renderer.
+  // 2) an array, where the first element is the function name, and the rest - the arguments
+  // that will be passed to that function along with the value to be rendered.
+  // The function is searched in the following objects: 1) Ext.util.Format, 2) this.
+  // If not found, it is simply evaluated. Handy, when as renderer we receive an inline JS function,
+  // or reference to a function in some other scope.
+  // So, these will work:
+  // * "uppercase"
+  // * ["ellipsis", 10]
+  // * ["substr", 3, 5]
+  // * "myRenderer" (if this.myRenderer is a function)
+  // * ["Some.scope.Format.customRenderer", 10, 20, 30] (if Some.scope.Format.customRenderer is a function)
+  // * "function(v){ return 'Value: ' + v; }"
+  netzkeNormalizeRenderer: function(c) {
+    if (!c.renderer) return;
+
+    var name, args = [];
+
+    if ('string' === typeof c.renderer) {
+      name = c.renderer.camelize(true);
+    } else {
+      name = c.renderer[0];
+      args = c.renderer.slice(1);
+    }
+
+    // First check whether Ext.util.Format has it
+    if (Ext.isFunction(Ext.util.Format[name])) {
+      c.renderer = Ext.Function.bind(Ext.util.Format[name], this, args, 1);
+    } else if (Ext.isFunction(this[name])) {
+      // ... then if our own class has it
+      c.renderer = Ext.Function.bind(this[name], this, args, 1);
+    } else {
+      // ... and, as last resort, evaluate it (allows passing inline javascript function as renderer)
+      eval("c.renderer = " + c.renderer + ";");
+    }
+  },
+
+  /*
+  Set a renderer that displayes association values instead of association record ID.
+  The association values are passed in the meta-column under associationValues hash.
+  */
+  netzkeNormalizeAssociationRenderer: function(c) {
+    var passedRenderer = c.renderer, // renderer we got from netzkeNormalizeRenderer
+        metaData, assocValue;
+    c.scope = this;
+    c.renderer = function(value, a, r, ri, ci, store, view){
+      var column = view.headerCt.items.getAt(ci),
+          editor = column.getEditor && column.getEditor(),
+          recordFromStore = editor && editor.isXType('combobox') && editor.getStore().findRecord('value', value),
+          renderedValue;
+
+      if (recordFromStore) {
+        renderedValue = recordFromStore.get('text');
+      } else if (metaData = r.get('meta')) {
+        assocValue = metaData.associationValues[c.name];
+        renderedValue = (assocValue == undefined) ? c.emptyText : assocValue;
+      } else {
+        renderedValue = value;
+      }
+
+      return passedRenderer ? passedRenderer.call(this, renderedValue) : renderedValue;
+    };
+  },
+
+  netzkeSaveColumns: function(){
+    var cols = [];
+    this.getView().getHeaderCt().items.each(function(c){
+      cols.push({name: c.name, width: c.width, hidden: c.hidden});
+    });
+
+    this.serverSaveColumns(cols);
+  },
+
+  // Tries editing the first editable (i.e. not hidden, not read-only) sell
+  netzkeTryStartEditing: function(r){
+    var editableIndex = 0;
+    Ext.each(this.initialConfig.columns, function(c){
+      // skip columns that cannot be edited
+      if (!(c.hidden == true || !c.editor || c.attrType == 'boolean')) {
+        return false;
+      }
+      editableIndex++;
+    });
+
+    if (editableIndex < this.initialConfig.columns.length) {this.getPlugin('celleditor').startEdit(r, this.columns[editableIndex]);}
+  },
+
+  netzkeFilterTypeForAttrType: function(attrType){
+    var map = {
+      integer   : 'number',
+      decimal   : 'number',
+      float     : 'number',
+      datetime  : 'date',
+      date      : 'date',
+      string    : 'string',
+      text      : 'string',
+      'boolean' : 'boolean'
+    };
+    return map[attrType] || 'string';
+  },
+
+  netzkeFieldTypeForAttrType: function(attrType){
+    var map = {
+      integer   : 'int',
+      decimal   : 'float',
+      float     : 'float',
+      datetime  : 'date',
+      date      : 'date',
+      string    : 'string',
+      text      : 'string',
+      'boolean' : 'boolean'
+    };
+    return map[attrType] || 'string';
+  }
+});

data/{lib/netzke/basepack/grid/javascripts/event_handling.js → javascripts/mixins/grid_event_handlers.js}

@@ -1,6 +1,6 @@
-{
+Ext.define("Netzke.mixins.Basepack.GridEventHandlers", {
   // Handler for the 'add' button
-  onAddInline: function(){
+  onAddRecord: function(){
     if (this.enableEditInForm && !this.enableEditInline) {
       this.onAddInForm();
     } else {
@@ -18,12 +18,11 @@
   onDel: function() {
     Ext.Msg.confirm(this.i18n.confirmation, this.i18n.areYouSure, function(btn){
       if (btn == 'yes') {
-        var ids = [], records = [];
-        this.getSelectionModel().selected.each(function(r){
-          this.store.remove(r);
-        }, this);
-
-        this.store.sync();
+        var toDelete = this.getSelectionModel().getSelection();
+        store = this.getStore();
+        store.remove(toDelete);
+        store.removedNodes = toDelete; // HACK
+        store.sync();
       }
     }, this);
   },
@@ -86,5 +85,55 @@
     if (this.searchWindow) {
       this.searchWindow.destroy();
     }
+  },
+
+  onEditInForm: function(){
+    var selModel = this.getSelectionModel();
+    if (selModel.getCount() > 1) {
+      var recordId = selModel.selected.first().getId();
+      this.netzkeLoadComponent("multi_edit_window", {
+        params: {record_id: recordId},
+        callback: function(w){
+          w.show();
+          var form = w.items.first();
+          form.on('apply', function(){
+            var ids = [];
+            selModel.selected.each(function(r){
+              ids.push(r.getId());
+            });
+            if (!form.baseParams) form.baseParams = {};
+            form.baseParams.ids = Ext.encode(ids);
+          }, this);
+
+          w.on('close', function(){
+            if (w.closeRes === "ok") {
+              this.store.load();
+            }
+          }, this);
+        }, scope: this});
+    } else {
+      var recordId = selModel.selected.first().getId();
+      this.netzkeLoadComponent("edit_window", {
+        clientConfig: {record_id: recordId},
+        callback: function(w){
+          w.show();
+          w.on('close', function(){
+            if (w.closeRes === "ok") {
+              this.store.load();
+            }
+          }, this);
+        }, scope: this});
+    }
+  },
+
+  onAddInForm: function(){
+    this.netzkeLoadComponent("add_window", {callback: function(w){
+      w.show();
+      w.on('close', function(){
+        if (w.closeRes === "ok") {
+          this.store.load();
+        }
+      }, this);
+    }, scope: this});
   }
-}
+});

data/lib/netzke/basepack.rb

@@ -16,10 +16,9 @@ module Netzke
     mattr_accessor :icons_uri
 
     class << self
-
       # Called from netzke-basepack.rb
       def init
-        %w[netzkeremotecombo xdatetime basepack].each do |name|
+        %w[netzkeremotecombo xdatetime basepack columns mixins/grid_event_handlers].each do |name|
           Netzke::Core.ext_javascripts << "#{File.dirname(__FILE__)}/../../javascripts/#{name}.js"
         end
 
@@ -35,6 +34,5 @@ module Netzke
         yield self
       end
     end
-
   end
 end

data/lib/netzke/basepack/columns.rb

@@ -142,8 +142,6 @@ module Netzke
           {name: c.name, text: c.text, attr_type: c.attr_type}.tap do |a|
             if c[:assoc]
               a[:text].sub!("  ", " ")
-              a[:assoc] = true
-              a[:attr_type] = :string
             end
           end
         end

data/lib/netzke/basepack/data_adapters/abstract_adapter.rb

@@ -225,6 +225,24 @@ module Netzke::Basepack::DataAdapters
       name.to_s.humanize
     end
 
+    # Return root record for tree-like data
+    def root
+      model_class.root
+    end
+
+    def find_record_children(r)
+      r.children
+    end
+
+    def find_root_records
+      model_class.where(parent_id: nil)
+    end
+
+    # Does record respond to given method?
+    def model_respond_to?(method)
+      @model_class.instance_methods.include?(method)
+    end
+
     # -- End of overridable methods
 
     # Abstract-adapter specifics

data/lib/netzke/basepack/data_adapters/active_record_adapter.rb

@@ -39,7 +39,9 @@ module Netzke::Basepack::DataAdapters
     end
 
     def attr_type(attr_name)
-      association_attr?(attr_name) ? :integer : (@model_class.columns_hash[attr_name.to_s].try(:type) || :string)
+      method, assoc = method_and_assoc(attr_name)
+      klass = assoc.nil? ? @model_class : assoc.klass
+      klass.columns_hash[method].try(:type) || :string
     end
 
     # Implementation for {AbstractAdapter#get_records}
@@ -113,17 +115,17 @@ module Netzke::Basepack::DataAdapters
 
     def virtual_attribute?(c)
       assoc_name, asso = c[:name].split('__')
-      assoc, assoc_method = assoc_and_assoc_method_for_attr(c[:name])
+      method, assoc = method_and_assoc(c[:name])
 
       if assoc
-        return !assoc.klass.column_names.include?(assoc_method)
+        return !assoc.klass.column_names.include?(method)
       else
         return !@model_class.column_names.include?(c[:name])
       end
     end
 
     def combo_data(attr, query = "")
-      assoc, assoc_method = assoc_and_assoc_method_for_attr(attr[:name])
+      method, assoc = method_and_assoc(attr[:name])
 
       if assoc
         # Options for an asssociation attribute
@@ -131,16 +133,16 @@ module Netzke::Basepack::DataAdapters
         relation = assoc.klass.all
         relation = relation.extend_with(attr[:scope]) if attr[:scope]
 
-        if assoc.klass.column_names.include?(assoc_method)
+        if assoc.klass.column_names.include?(method)
           # apply query
           assoc_arel_table = assoc.klass.arel_table
 
-          relation = relation.where(assoc_arel_table[assoc_method].matches("%#{query}%"))  if query.present?
-          relation.to_a.map{ |r| [r.id, r.send(assoc_method)] }
+          relation = relation.where(assoc_arel_table[method].matches("%#{query}%"))  if query.present?
+          relation.to_a.map{ |r| [r.id, r.send(method)] }
         else
           query.downcase!
           # an expensive search!
-          relation.to_a.map{ |r| [r.id, r.send(assoc_method)] }.select{ |id,value| value.to_s.downcase.include?(query) }
+          relation.to_a.map{ |r| [r.id, r.send(method)] }.select{ |id,value| value.to_s.downcase.include?(query) }
         end
 
       else
@@ -240,7 +242,7 @@ module Netzke::Basepack::DataAdapters
         end
       # the composite_primary_keys gem produces [Key1,Key2...] and [Value1,Value2...]
       # on primary_key and id requests. Basepack::AttrConfig converts the keys-array to an String.
-      elsif r.class.primary_key.try(:to_s) == a[:name]
+      elsif primary_key.try(:to_s) == a[:name]
         r.id # return 'val1,val2...' on 'key1,key2...' composite_primary_keys
       end
 
@@ -296,11 +298,12 @@ module Netzke::Basepack::DataAdapters
       end
     end
 
-    # Returns association and association method for a column
-    def assoc_and_assoc_method_for_attr(column_name)
-      assoc_name, assoc_method = column_name.split('__')
-      assoc = @model_class.reflect_on_association(assoc_name.to_sym) if assoc_method
-      [assoc, assoc_method]
+    # If association attribute is given, returns [method, association]
+    # Else returns [attr_name]
+    def method_and_assoc(attr_name)
+      assoc_name, method = attr_name.to_s.split('__')
+      assoc = @model_class.reflect_on_association(assoc_name.to_sym) if method
+      assoc.nil? ? [attr_name] : [method, assoc]
     end
 
     # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
@@ -353,16 +356,10 @@ module Netzke::Basepack::DataAdapters
       predicates = conditions.map do |q|
         q = HashWithIndifferentAccess.new(q)
 
-        assoc, method = q["attr"].split('__')
-        if method
-          assoc = @model_class.reflect_on_association(assoc.to_sym)
-          assoc_arel = assoc.klass.arel_table
-          attr = method
-          arel_table = Arel::Table.new(assoc.klass.table_name.to_sym)
-        else
-          attr = assoc
-          arel_table = @model_class.arel_table
-        end
+        attr = q[:attr]
+        method, assoc = method_and_assoc(attr)
+
+        arel_table = assoc ? Arel::Table.new(assoc.klass.table_name.to_sym) : @model_class.arel_table
 
         value = q["value"]
         op = q["operator"]
@@ -371,15 +368,15 @@ module Netzke::Basepack::DataAdapters
 
         case attr_type
         when :datetime
-          update_predecate_for_datetime(arel_table[attr], op, value.to_date)
+          update_predecate_for_datetime(arel_table[method], op, value.to_date)
         when :string, :text
-          update_predecate_for_string(arel_table[attr], op, value)
+          update_predecate_for_string(arel_table[method], op, value)
         when :boolean
-          update_predecate_for_boolean(arel_table[attr], op, value)
+          update_predecate_for_boolean(arel_table[method], op, value)
         when :date
-          update_predecate_for_rest(arel_table[attr], op, value.to_date)
+          update_predecate_for_rest(arel_table[method], op, value.to_date)
         else
-          update_predecate_for_rest(arel_table[attr], op, value)
+          update_predecate_for_rest(arel_table[method], op, value)
         end
       end