marty 0.5.15 → 0.5.16

data/app/components/marty/simple_app.rb~

@@ -1,101 +0,0 @@
-module Netzke
-  module Basepack
-    # Basis for a Ext.container.Viewport-based one-page application.
-    #
-    # == Features:
-    # * dynamic loading of components
-    # * browser history support (press the "Back"-button to go to the previously loaded component)
-    # * AJAX activity indicator
-    #
-    # == Extending SimpleApp
-    # You may want to extend SimpleApp to provide a custom layout. Make sure you create three regions with predefined itemId's that will be used by SimpleApp. You can use the following methods defined by SimpleApp: main_panel_config, status_bar_config, and menu_bar_config, e.g.:
-    #
-    #     class MySimpleApp < Netzke::Basepack::SimpleApp
-    #
-    #       def configuration
-    #         super.merge(
-    #           :items => [my_custom_navigation_config, main_panel_config, menu_bar_config, status_bar_config]
-    #         )
-    #       end
-    #
-    #       def my_custom_navigation_config
-    #         {
-    #           :item_id => 'navigation',
-    #           :region => :east,
-    #           :width => 200
-    #         }
-    #       end
-    #
-    #       ...
-    #     end
-    #
-    # The JS side of the component will have those regions referenced as this.mainPanel, this.statusBar, and this.menuBar.
-    class SimpleApp < Base
-      js_configure do |c|
-        c.extend = "Ext.container.Viewport"
-        c.layout = :border
-        c.require Netzke::Core.ext_path.join("examples", "ux/statusbar/StatusBar.js"), :statusbar_ext
-        c.mixin
-      end
-
-      def configure(c)
-        super
-        c.items = [main_panel_config, menu_bar_config, status_bar_config]
-      end
-
-      # In Ext 4.1 calling `render` on a viewport causes an error
-      def js_component_render
-        ""
-      end
-
-      # Override for custom menu
-      def menu
-        []
-      end
-
-      # Config for the main panel, which will contain dynamically loaded components.
-      def main_panel_config(overrides = {})
-        {
-          :itemId => 'main_panel',
-          :region => 'center',
-          :layout => 'fit'
-        }.merge(overrides)
-      end
-
-      # Config for the status bar
-      def status_bar_config(overrides = {})
-        {
-          :itemId => 'status_bar',
-          :xtype => 'statusbar',
-          :region => 'south',
-          :height => 22,
-          :statusAlign => 'right',
-          :busyText => 'Busy...',
-          :default_text => "Ready",
-          :default_icon_cls => ""
-        }.merge(overrides)
-      end
-
-      # Config for the menu bar
-      def menu_bar_config(overrides = {})
-        {
-          :itemId => 'menu_bar',
-          :xtype => 'toolbar',
-          :region => 'north',
-          :height => 28,
-          :items => menu
-        }.merge(overrides)
-      end
-
-      # Html required for Ext.History to work
-      def js_component_html
-        super << %Q{
-  <form id="history-form" class="x-hidden">
-      <input type="hidden" id="x-history-field" />
-      <iframe id="x-history-frame"></iframe>
-  </form>
-        }
-      end
-    end
-  end
-end

data/app/components/marty/tag_grid.rb~

@@ -1,89 +0,0 @@
-class Marty::TagGrid < Marty::CmGridPanel
-  has_marty_permissions	read: :any,
-  			create: :dev
-
-  def configure(c)
-    super
-
-    c.header    = false
-    c.model     = "Marty::Tag"
-    c.columns ||= [:name, :created_dt, :user__name, :comment]
-    c.data_store.sorters = {
-      property: :created_dt,
-      direction: 'DESC',
-    }
-  end
-
-  js_configure do |c|
-    c.init_component = <<-JS
-    function() {
-       this.callParent();
-       // Set single selection mode. FIXME: can this be done on config?
-       this.getSelectionModel().setSelectionMode('SINGLE');
-    }
-    JS
-  end
-
-  endpoint :add_window__add_form__netzke_submit do |params, this|
-    data = ActiveSupport::JSON.decode(params[:data])
-
-    return this.netzke_feedback("Permission Denied") if
-      config[:prohibit_create]
-
-    # FIXME: disallow tag creation when no script has been modified?
-
-    tag = Marty::Tag.do_create(nil, data["comment"])
-
-    if tag.valid?
-      this.success = true
-      this.on_submit_success
-      return
-    end
-
-    data_adapter.errors_array(tag).each do |error|
-      flash :error => error
-    end
-
-    this.netzke_feedback(@flash)
-  end
-
-  action :add_in_form do |a|
-    a.text     = "New Tag"
-    a.tooltip  = "New Tag"
-    a.icon     = :time_add
-    a.disabled = config[:prohibit_create]
-  end
-
-  def default_bbar
-    [:add_in_form]
-  end
-
-  def default_context_menu
-    []
-  end
-
-  def default_fields_for_forms
-    [:comment]
-  end
-
-  column :name do |c|
-  end
-
-  column :created_dt do |c|
-    c.text   = "Date/Time"
-    c.format = "Y-m-d H:i"
-    c.hidden = true
-  end
-
-  column :user__name do |c|
-    c.width  = 100
-  end
-
-  column :comment do |c|
-    c.width  = 100
-    c.flex   = 1
-  end
-
-end
-
-TagGrid = Marty::TagGrid

data/app/components/marty/tree_panel.rb~

@@ -1,256 +0,0 @@
-# Ext.tree.TreePanel-based component
-#
-# ATTRIBUTION: this code is based on the netzke-extension module found at:
-# 	https://github.com/phgrey/netzke-extension
-# TODO: Add documentation for usage
-
-class Marty::TreePanel < Netzke::Base
-  include ::Netzke::Basepack::DataAccessor
-  include ::Netzke::Basepack::Columns
-
-  self.default_instance_config = {
-    indicate_leafs:	 true,
-    auto_scroll:	 false,
-    root_visible:	 false,
-    load_inline_data:	 false,
-    enable_pagination:	 false,
-    rows_per_page:	 30,
-    treecolumn:	 	'tree' # default name for tree column
-  }
-
-  def js_configure(c) #:nodoc:
-    super
-    c.bbar = bbar
-  end
-
-  js_configure do |c|
-    c.extend = "Ext.tree.TreePanel"
-    c.mixin
-    c.root_visible = false
-  end
-
-  # Configure dynamic JS properties for instantiation
-  def js_config
-    super.tap do |c|
-      # Hand over inline data to the js config hash
-      c[:inline_data] = get_data if config[:load_inline_data]
-    end
-  end
-
-  def configure(c) #:nodoc:
-    super
-    c.title ||= self.class.js_config.properties[:title] ||
-      data_class.name.pluralize
-    c.columns = final_columns(with_meta: true)
-
-    # Set it to the primary key if not given and camelize it Setting
-    # it to anything else than the primary key is especially useful
-    # when instances of different class are shown in one tree because
-    # the primary key MUST be unique!
-    c.pri = (c.pri || data_class.primary_key).to_s.camelize(:lower)
-
-    # Add extra fields for a tree: A method ':name(r)' is called for
-    # every record to retrieve the value
-    c.extra_fields ||= []
-
-    # This will call leaf?(r) for every record
-    c.extra_fields << {name: 'leaf', type: 'boolean'}
-
-    # This will call expanded?(r) for every record
-    c.extra_fields << {name: 'expanded', type: 'boolean'}
-
-    # only if the node id property is different from the data class'
-    # primary key, we need to add and extra field
-    c.extra_fields << {name: c.pri.to_s.camelize(:lower), type: 'string'} if
-      c.pri != data_class.primary_key
-  end
-
-  def config
-    @config ||= ActiveSupport::OrderedOptions.new.tap do |c|
-      # extend with data_store convenient config object
-      c.data_store = ActiveSupport::OrderedOptions.new
-    end
-  end
-
-  def bbar
-    config[:bbar]
-  end
-
-  # Sets the xtype to 'treecolumn' for the column with name equal to
-  # the :treecolumn value of the config
-  def set_default_xtype(c)
-    c[:xtype] = 'treecolumn' if c[:name].to_s == config[:treecolumn].to_s
-  end
-
-  # Set data_index -- The name of the field configuration of the Ext
-  # JS model will be set to this value This is neccessary since the
-  # data is serialized as a hash (with camelized keys) so the
-  # data_index must also be camelized
-  def set_default_data_index(c)
-    c[:data_index] = c[:name].camelize(:lower)
-  end
-
-  # Call super and then set the data_index
-  def augment_column_config(c)
-    super
-    set_default_data_index(c)
-    set_default_xtype c
-  end
-
-  # @!method get_data_endpoint
-  #
-  # Returns something like:
-  # [
-  # { 'id'=> 1, 'text'=> 'A folder Node', 'leaf'=> false },
-  # { 'id'=> 2, 'text'=> 'A leaf Node', 'leaf'=> true }
-  # ]
-  #
-  # @param [Hash] params
-  endpoint :get_data do |params, this|
-    this.merge! get_data(params)
-  end
-
-  # Method that is called by the get_data endpoint
-  # Calls the get_children method and returns the serialized records
-  #
-  # @param [] *args takes any arguments
-  # @return [Hash] all the serialized data
-  def get_data(*args)
-    params = args.first || {} # params are optional!
-
-    sortp = params["sort"]
-
-    # Giant hack to fix property field used in sort.  Not sure why
-    # this is coming in camelized.
-    if sortp.is_a?(Array)
-      sortp.each { |h|
-        h["property"] = h["property"].underscore if
-        h.is_a?(Hash) && h["property"]
-      }
-    end
-
-    if !config[:prohibit_read]
-      {}.tap do |res|
-        # set children to an instance variable in order to access them later
-        @records = get_children(params)
-
-        # Serialize children
-        res[:data] = serialize_data(@records)
-
-        res[:total] = count_records(params) if
-          config[:enable_pagination] &&
-          (params[:id].nil? || params[:id] == 'root')
-      end
-    else
-      flash :error => "You don't have permissions to read data"
-      { :netzke_feedback => @flash }
-    end
-  end
-
-  # Serializes an array of objects
-  #
-  # @param [Array] records
-  # @return [Array] the serialized data
-  def serialize_data(records)
-    records.map { |r|
-      data_adapter.record_to_hash(r, final_columns(:with_meta => true)).tap { |h|
-
-        config[:extra_fields].each do |f|
-          name = f[:name].underscore.to_sym
-          h[name] = send("#{name}#{f[:type] == 'boolean' ? '?' : ''}", r)
-        end
-
-        inline_children = get_inline_children(r)
-        h[:data] = serialize_data(inline_children) unless inline_children.nil?
-        h
-      }
-    }
-  end
-
-  # Retrieves all children for a node
-  # Note: It's recommended to override this method
-  #
-  # @param [Hash] params
-  # @return [Array] array of records
-  def get_children(params)
-    scope_data_class(params) do
-      params[:limit] = config[:rows_per_page] if
-        config[:enable_pagination] && (params[:id].nil? || params[:id] == 'root')
-      params[:scope] = config[:scope]
-      data_adapter.get_records(params, final_columns)
-    end
-  end
-
-  # Scopes the data class depending on the config of the parent_key and the node
-  #
-  # @param [Hash] params
-  def scope_data_class(params, &block)
-    if config[:parent_key]
-      # The value of the pri property of the expanded node is passed
-      # as params[:id] ('root' for the root collection)
-      if params[:id].nil? || params[:id] == 'root'
-        data_class.where(config[:parent_key] => nil).scoping do
-          yield
-        end
-      else
-        data_class.where(config[:parent_key] => params[:id]).scoping do
-          yield
-        end
-      end
-    else
-      yield
-    end
-  end
-
-  # Counts the total records
-  #
-  # @param [Hash] params
-  # @return [Fixnum] The number of records
-  def count_records(params)
-    scope_data_class(params) do
-      params[:scope] = config[:scope]
-      data_adapter.count_records(params, final_columns)
-    end
-  end
-
-  # Should return all children of the record that should also be
-  # serialized in the current request
-  # Note: It's recommended to override this method
-  #
-  # @param [Object] r The record for which the inline children should be loaded
-  # @return [NilClass, Array] If nil is returned, the tree doesn't
-  # know anything about any children, so opening the node will cause
-  # another request.  If an empty array is returned, the tree assumes
-  # that there are no children available for this node (and thus you
-  # can't open it!)
-  def get_inline_children(r)
-    nil
-  end
-
-  # Is the record a leaf or not?
-  # Note: It's recommended to override this method
-  #
-  # @param [Object] r
-  # @return [Boolean] Whether the node is a leaf or not
-  def leaf?(r)
-    r.children.empty?
-  end
-
-  # Is the record a expanded or not?
-  # Note: It's recommended to override this method
-  #
-  # @param [Object] r
-  # @return [Boolean] Whether the node is expanded or not
-  def expanded?(r)
-    false
-  end
-
-  # Is the record a leaf or not?
-  # Note: It's recommended to override this method
-  #
-  # @param [Object] r
-  # @return [Boolean] Whether the node is a leaf or not
-  def node_id(r)
-    r.send(data_class.primary_key)
-  end
-end

data/app/components/marty/tree_panel/javascripts/tree_panel.js~

@@ -1,317 +0,0 @@
-// This is a hacked up version of 0.8.4 grid.js to work with
-// TreePanel.  FIXME: perhaps we can patch up grid.js dynamically
-// rather than copying all the code?
-{
-  trackMouseOver: true,
-  loadMask: true,
-
-  componentLoadMask: {msg: "Loading..."},
-  deleteMaskMsg: "Deleting...",
-
-  initComponent: function(){
-    var metaColumn;
-    var fields = this.extraFields; // field configs for the underlying data model
-
-    this.plugins = this.plugins || [];
-    this.features = this.features || [];
-
-    // Run through columns and set up different configuration for each
-    Ext.each(this.columns, function(c, i){
-
-      this.normalizeRenderer(c);
-
-      // Build the field configuration for this column
-      var fieldConfig = {name: c.dataIndex, defaultValue: c.defaultValue, useNull: true};
-
-      if (c.name !== 'meta') fieldConfig.type = this.fieldTypeForAttrType(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");
-        }
-      };
-
-      // 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;
-      }
-
-      fields.push(fieldConfig);
-
-      // We will not use meta columns as actual columns (not even hidden) - only to create the records
-      if (c.meta) {
-        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
-        c.editor = Ext.apply({
-          parentId: this.id,
-          name: c.name,
-          selectOnFocus: true // ?
-        }, c.editor);
-
-        // Renderer for association column
-        this.normalizeAssociationRenderer(c);
-      }
-
-      if (c.editor) {
-        Ext.applyIf(c.editor, {selectOnFocus: true});
-      }
-
-      // Setting the default filter type
-      if (c.filterable && !c.filter) {
-        c.filter = {type: this.fieldTypeForAttrType(c.attrType)};
-      }
-
-      // HACK: somehow this is not set by Ext (while it should be)
-      // if (c.xtype == 'datecolumn') c.format = c.format || Ext.util.Format.dateFormat;
-      // setting dataIndex
-      // c.dataIndex = c.name;
-
-    }, this);
-    /* ... and done with the columns */
-
-    // Define the model
-    Ext.define(this.id, {
-      extend: 'Ext.data.Model',
-      idProperty: this.pri, // Primary key
-      fields: fields
-    });
-
-    // After we created the record (model), we can get rid of the meta column
-    Ext.Array.remove(this.columns, metaColumn);
-
-    // Prepare column model config with columns in the correct order; columns out of order go to the end.
-    var colModelConfig = [];
-    var columns = this.columns;
-
-    Ext.each(this.columns, 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;
-
-    // DirectProxy that uses our Ext.direct provider
-    var proxy = Ext.create('Ext.data.proxy.Direct', {
-
-      directFn: Netzke.providers[this.id].getData,
-//      reader: Ext.create('Ext.data.reader.Array', {root: 'data', totalProperty: 'total'}),
-      reader: {
-        type: 'json',
-        root: 'data'
-      },
-      listeners: {
-        exception: {
-          fn: this.loadExceptionHandler,
-          scope: this
-        },
-        load: { // Netzke-introduced event; this will also be fired when an exception occurs.
-          fn: function(proxy, response, operation) {
-            // besides getting data into the store, we may also get commands to execute
-            response = response.result;
-
-            if (response) { // or did we have an exception?
-              Ext.each(['data', 'total', 'success'], function(property){delete response[property];});
-              this.netzkeBulkExecute(response);
-            }
-          },
-          scope: this
-        }
-      }
-    })
-
-    // Create the netzke PagingTreeStore
-
-    this.store = Ext.create('Ext.data.TreeStore', Ext.apply({
-      model: this.id,
-      proxy: proxy,
-      autoLoad: !this.loadInlineData,
-//      root: this.inlineData || {data: [{tree:'root', id:0}]}
-    }, this.dataStore));
-    delete this.dataStore;
-
-    this.store.load();
-    // HACK: we must let the store now totalCount
-//    this.store.setTotalCount(this.inlineData && this.inlineData[this.store.getProxy().getReader().totalProperty]);
-    
-    // Drag'n'Drop
-    if (this.enableRowsReordering){
-      this.ddPlugin = new Ext.ux.dd.GridDragDropRowOrder({
-        scrollable: true // enable scrolling support (default is false)
-      });
-      this.plugins.push(this.ddPlugin);
-    }
-
-    // Cell editing
-    if (!this.prohibitUpdate) {
-      this.plugins.push(Ext.create('Ext.grid.plugin.CellEditing', {pluginId: 'celleditor'}));
-    }
-
-    // Toolbar
-    this.dockedItems = this.dockedItems || [];
-    if (this.enablePagination) {
-      this.dockedItems.push({
-        xtype: 'pagingtoolbar',
-        dock: 'bottom',
-        store: this.store,
-	// append the old bbar. TODO: get rid of it.
-        items: this.bbar && ["-"].concat(this.bbar)
-      });
-    } else if (this.bbar) {
-      this.dockedItems.push({
-        xtype: 'toolbar',
-        dock: 'bottom',
-        items: this.bbar
-      });
-    }
-
-    delete this.bbar;
-
-    // Now let Ext.grid.EditorGridPanel do the rest (original initComponent)
-    this.callParent();
-
-    // Context menu
-    if (this.contextMenu) {
-      this.on('itemcontextmenu', this.onItemContextMenu, this);
-    }
-
-    // Disabling/enabling editInForm button according to current selection
-    if (this.enableEditInForm && !this.prohibitUpdate) {
-      this.getSelectionModel().on('selectionchange', function(selModel, selected){
-        var disabled;
-        if (selected.length === 0) { // empty?
-          disabled = true;
-        } else {
-          // Disable "edit in form" button if new record is present in selection
-          Ext.each(selected, function(r){
-            if (r.isNew) { disabled = true; return false; }
-          });
-        };
-        this.actions.editInForm.setDisabled(disabled);
-      }, this);
-    }
-
-
-    // Drag n Drop event
-    if (this.enableRowsReordering){
-      this.ddPlugin.on('afterrowmove', this.onAfterRowMove, this);
-    }
-
-    // WIP: GridView
-    this.getView().getRowClass = this.defaultGetRowClass;
-
-    // When starting editing as assocition column, pre-load the combobox store from the meta column, so that we don't see the real value of this cell (the id of the associated record), but rather the associated record by the configured method.
-    this.on('beforeedit', function(e){
-      return false;
-    }, this);
-
-    this.on('afterrender', function() {
-      // Persistence-related events (afterrender to avoid blank event firing on render)
-      if (this.persistence) {
-        // Inform the server part about column operations
-        this.on('columnresize', this.onColumnResize, this);
-        this.on('columnmove', this.onColumnMove, this);
-        this.on('columnhide', this.onColumnHide, this);
-        this.on('columnshow', this.onColumnShow, this);
-      }
-    }, this);
-  },
-
-  fieldTypeForAttrType: function(attrType){
-    var map = {
-      integer   : 'int',
-      decimal   : 'float',
-      datetime  : 'date',
-      date      : 'date',
-      string    : 'string',
-      text      : 'string',
-      'boolean' : 'boolean'
-    };
-    return map[attrType] || 'string';
-  },
-
-  // 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; }"
-  normalizeRenderer: 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.
-*/
-  normalizeAssociationRenderer: function(c) {
-    c.scope = this;
-    var passedRenderer = c.renderer; // renderer we got from normalizeRenderer
-    c.renderer = function(value, a, r, ri, ci){
-      var column = this.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 (c.assoc && r.get('meta')) {
-        renderedValue = r.get('meta').associationValues[c.name] || c.emptyText;
-      } else {
-        renderedValue = value;
-      }
-
-      return passedRenderer ? passedRenderer.call(this, renderedValue) : renderedValue;
-    };
-  }
-}