admin_assistant 0.0.1 → 1.0.0

data/lib/admin_assistant.rb

@@ -1,61 +1,39 @@
-require 'admin_assistant/builder'
+$: << File.join(File.dirname(__FILE__), '../vendor/ar_query/lib')
+require 'find'
 require 'admin_assistant/column'
-require 'admin_assistant/form_view'
-require 'admin_assistant/helper'
-require 'admin_assistant/index'
-require 'admin_assistant/request'
+Find.find(File.dirname(__FILE__)) do |path|
+  if path =~ %r|\.rb$| && path !~ %r|admin_assistant\.rb$| &&
+     path !~ %r|admin_assistant/column\.rb$|
+    require path
+  end
+end
 require 'will_paginate'
 
 class AdminAssistant
-  attr_reader :custom_column_labels, :form_settings, :index_settings, 
-              :model_class
-  attr_accessor :actions
-  
+  attr_reader   :base_settings, :controller_class, :form_settings, 
+                :index_settings, :model_class, :show_settings
+  attr_accessor :actions, :custom_destroy
+  attr_writer   :model_class_name
+
+  def self.template_file(template_name)
+    "#{File.dirname(__FILE__)}/views/#{template_name}.html.erb"
+  end
+
   def initialize(controller_class, model_class)
     @controller_class, @model_class = controller_class, model_class
-    @actions = [:index, :create, :update]
+    @model = Model.new model_class
+    @actions = [:index, :create, :update, :show]
     @form_settings = FormSettings.new self
     @index_settings = IndexSettings.new self
-    @custom_column_labels = {}
-  end
-  
-  def belongs_to_assoc(name)
-    model_class.reflect_on_all_associations.detect { |assoc|
-      assoc.macro == :belongs_to && assoc.name.to_s == name.to_s
-    }
-  end
-  
-  def column(name)
-    column = if file_columns.include?(name)
-      FileColumnColumn.new name
-    elsif (ar_column = model_class.columns_hash[name.to_s])
-      ActiveRecordColumn.new(ar_column)
-    elsif belongs_to_assoc = belongs_to_assoc(name)
-      BelongsToColumn.new(belongs_to_assoc)
-    else
-      AdminAssistantColumn.new(name)
-    end
-    if column && (custom = custom_column_labels[name.to_s])
-      column.custom_label = custom
-    end
-    column
+    @show_settings = ShowSettings.new self
+    @base_settings = BaseSettings.new self
   end
   
-  def column_name_or_assoc_name(name)
-    result = name
-    ar_column = model_class.columns_hash[name.to_s]
-    if ar_column
-      associations = model_class.reflect_on_all_associations
-      if belongs_to_assoc = associations.detect { |assoc|
-        assoc.macro == :belongs_to && assoc.association_foreign_key == name
-      }
-        result = belongs_to_assoc.name.to_s
-      end
-    end
-    result
+  def [](name)
+    @base_settings[name]
   end
     
-  def columns(names)
+  def accumulate_columns(names)
     columns = paperclip_attachments.map { |paperclip_attachment|
       PaperclipColumn.new paperclip_attachment
     }
@@ -68,10 +46,62 @@ class AdminAssistant
     columns
   end
   
+  def accumulate_belongs_to_columns(names)
+    accumulate_columns(names).select { |column| column.is_a?(BelongsToColumn) }
+  end
+  
+  def autocomplete_actions
+    ac_actions = []
+    if [:new, :create, :edit, :update].any? { |action|
+      actions.include?(action)
+    }
+      accumulate_belongs_to_columns(default_column_names).each { |column|
+        ac_actions << "autocomplete_#{column.name}".to_sym
+      }
+    end
+    if actions.include?(:index)
+      base_settings.all_polymorphic_types.each do |p_type|
+        ac_actions << "autocomplete_#{p_type.name.underscore.downcase}".to_sym
+      end
+    end
+    ac_actions.uniq
+  end
+  
+  def column(name)
+    if file_columns.include?(name.to_s)
+      FileColumnColumn.new name
+    elsif paperclip_attachments.include?(name)
+      PaperclipColumn.new name
+    elsif (belongs_to_assoc = belongs_to_assoc(name) or
+           belongs_to_assoc = belongs_to_assoc_by_foreign_key(name))
+      column_based_on_belongs_to_assoc name, belongs_to_assoc
+    elsif belongs_to_assoc = belongs_to_assoc_by_polymorphic_type(name)
+      # skip it, actually
+    elsif (ar_column = @model_class.columns_hash[name.to_s])
+      ActiveRecordColumn.new ar_column
+    else
+      VirtualColumn.new name, @model_class, self
+    end
+  end
+  
+  def column_based_on_belongs_to_assoc(name, belongs_to_assoc)
+    if belongs_to_assoc.options[:polymorphic]
+     PolymorphicBelongsToColumn.new belongs_to_assoc
+    else
+      BelongsToColumn.new(
+        belongs_to_assoc,
+        :match_text_fields_in_search => 
+            search_settings[name].match_text_fields_for_association?,
+        :sort_by => index_settings[name].sort_by
+      )
+    end
+  end
+  
   def controller_actions
     c_actions = actions.clone
     c_actions << :new if c_actions.include?(:create)
     c_actions << :edit if c_actions.include?(:update)
+    c_actions.concat(autocomplete_actions) if autocomplete_actions
     c_actions
   end
     
@@ -79,58 +109,50 @@ class AdminAssistant
     controller.controller_path.gsub(%r|/|, '_')
   end
   
-  def dispatch_to_request_method(request_method, controller)
+  def dispatch_to_request_method(request_class, controller)
     controller.instance_variable_set :@admin_assistant, self
-    klass = Request.const_get request_method.to_s.capitalize
-    @request = klass.new(self, controller)
+    @request = request_class.new(self, controller)
     @request.call
     @request = nil
   end
   
-  def file_columns
-    fc = []
-    if model_class.respond_to?(:file_column)
-      model_class.columns.each do |column|
-        suffixes = %w( relative_path dir relative_dir temp )
-        if suffixes.all? { |suffix|
-          model_class.method_defined? "#{column.name}_#{suffix}".to_sym
-        }
-          fc << column.name
-        end
-      end
-    end
-    fc
-  end
-  
   def method_missing(meth, *args)
-    request_methods = [:create, :destroy, :edit, :index, :new, :update]
-    if request_methods.include?(meth) and args.size == 1
-      dispatch_to_request_method meth, args.first
+    if @model.respond_to?(meth)
+      @model.send meth, *args
     else
-      if meth.to_s =~ /(.*)\?/ && request_methods.include?($1.to_sym)
-        @actions.include?($1.to_sym)
-      elsif @request.respond_to?(meth)
-        @request.send meth, *args
+      request_methods = [
+        :create, :destroy, :edit, :index, :new, :update, :show
+      ]
+      if request_methods.include?(meth) and args.size == 1
+        request_class = Request.const_get meth.to_s.capitalize
+        dispatch_to_request_method request_class, args.first
+      elsif autocomplete_actions && autocomplete_actions.include?(meth)
+        dispatch_to_request_method Request::Autocomplete, args.first
       else
-        super
+        if meth.to_s =~ /(.*)\?/ && request_methods.include?($1.to_sym)
+          @controller_class.public_instance_methods.include?($1)
+        elsif @request.respond_to?(meth)
+          @request.send meth, *args
+        else
+          super
+        end
       end
     end
   end
     
   def model_class_name
-    model_class.name.gsub(/([A-Z])/, ' \1')[1..-1].downcase
+    @model_class_name ||
+        @model_class.name.gsub(/([A-Z])/, ' \1')[1..-1].downcase
   end
-    
-  def paperclip_attachments
-    pa = []
-    if model_class.respond_to?(:attachment_definitions)
-      if model_class.attachment_definitions
-        pa = model_class.attachment_definitions.map { |name, definition|
-          name
-        }
-      end
+  
+  def profile(msg)
+    if @request_start_time
+      puts "#{msg}: #{Time.now - @request_start_time}"
     end
-    pa
+  end
+  
+  def search_settings
+    @index_settings.search_settings
   end
   
   def url_params(a = action)
@@ -159,13 +181,96 @@ class AdminAssistant
       end
     end
   end
+  
+  class Model
+    def initialize(ar_model)
+      @ar_model = ar_model
+    end
+  
+    def belongs_to_associations
+      @ar_model.reflect_on_all_associations.select { |assoc|
+        assoc.macro == :belongs_to
+      }
+    end
+    
+    def belongs_to_assoc(association_name)
+      belongs_to_associations.detect { |assoc|
+        assoc.name.to_s == association_name.to_s
+      }
+    end
+    
+    def belongs_to_assoc_by_foreign_key(foreign_key)
+      belongs_to_associations.detect { |assoc|
+        assoc.association_foreign_key == foreign_key
+      }
+    end
+    
+    def belongs_to_assoc_by_polymorphic_type(name)
+      if name =~ /^(.*)_type/
+        belongs_to_associations.detect { |assoc|
+          assoc.options[:polymorphic] && $1 == assoc.name.to_s
+        }
+      end
+    end
+    
+    def default_column_names
+      @ar_model.columns.reject { |ar_column|
+        %w(id created_at updated_at).include?(ar_column.name)
+      }.map { |ar_column| ar_column.name }
+    end
+  
+    def file_columns
+      unless @file_columns
+        @file_columns = []
+        if @ar_model.respond_to?(:file_column)
+          names_to_check = @ar_model.columns.map &:name
+          names_to_check.concat(
+            @ar_model.instance_methods.
+                select { |m| m =~ /=$/ }.
+                map { |m| m.gsub(/=/, '')}.
+                select { |m| @ar_model.instance_methods.include?(m) }
+          )
+          names_to_check.uniq.each do |name|
+            suffixes = %w( relative_path dir relative_dir temp )
+            if suffixes.all? { |suffix|
+              @ar_model.method_defined? "#{name}_#{suffix}".to_sym
+            }
+              @file_columns << name
+            end
+          end
+        end
+      end
+      @file_columns
+    end
+    
+    def paperclip_attachments
+      pa = []
+      if @ar_model.respond_to?(:attachment_definitions)
+        if @ar_model.attachment_definitions
+          pa = @ar_model.attachment_definitions.map { |name, definition|
+            name
+          }
+        end
+      end
+      pa
+    end
+  
+    def searchable_columns
+      @ar_model.columns.select { |column|
+        [:string, :text].include?(column.type)
+      }
+    end
+  end
 end
 
 ActionController::Base.send :include, AdminAssistant::ControllerMethods
 
+css_dir = "#{RAILS_ROOT}/public/stylesheets/admin_assistant"
+FileUtils.mkdir(css_dir) unless File.exist?(css_dir)
+FileUtils.cp_r(Dir.glob("#{File.dirname(__FILE__)}/stylesheets/*"), css_dir)
 FileUtils.copy(
-  "#{File.dirname(__FILE__)}/stylesheets/admin_assistant.css",
-  "#{RAILS_ROOT}/public/stylesheets/admin_assistant.css"
+  "#{File.dirname(__FILE__)}/javascripts/admin_assistant.js",
+  "#{RAILS_ROOT}/public/javascripts/admin_assistant.js"
 )
 images_dir = "#{RAILS_ROOT}/public/images/admin_assistant"
 FileUtils.mkdir(images_dir) unless File.exist?(images_dir)

data/lib/javascripts/admin_assistant.js

@@ -0,0 +1,253 @@
+/******************************************************************************
+Don't edit this file: It gets re-copied every time the server starts.
+******************************************************************************/
+
+var AdminAssistant = {};
+AdminAssistant.clear_datetime_select = function(name) {
+  $R(1,5).each(function(index) {
+    $(name + '_' + index + 'i').value = '';
+  });
+};
+
+AdminAssistant.show_search_form = function() {
+  $('search_form').show();
+};
+
+AdminAssistant.PolymorphicFieldSearch = Class.create();
+AdminAssistant.PolymorphicFieldSearch.prototype = {
+  initialize: function(name, types) {
+    this.name = name;
+    this.hiddenFieldId = 'search_' + name + '_id';
+    this.hiddenTypeFieldId = 'search_' + name + '_type';
+    this.autocompleteTypes = types.autocompleteTypes;
+    this.autocompleters = {};
+    this.autocompleteTypes.each(function(autocompleteType) {
+      autocompleter = this.newAutocompleter(autocompleteType);
+      this.autocompleters[autocompleteType.name] = autocompleter;
+    }, this);
+    this.idTypes = types.idTypes;
+    this.idTypes.each(function(idType) {
+      Event.observe(
+        this.name + '_' + idType.name + "_id", 'keyup', 
+        this.setHiddenFieldsFromIdField.bind(this)
+      );
+    }, this);
+    this.selectTypes = types.selectTypes;
+    this.selectTypes.each(function(selectType) {
+      Event.observe(
+        this.name + '_' + selectType.name + "_id", 'change', 
+        this.setHiddenFieldsFromSelectField.bind(this)
+      );
+    }, this);
+  },
+  
+  clearHiddenFields: function() {
+    this.hiddenField().value = '';
+    this.hiddenTypeField().value = '';
+  },
+  
+  clearInputsExceptFor: function(name_to_not_clear) {
+    this.autocompleteTypes.each(function(autocompleteType) {
+      if (autocompleteType.name != name_to_not_clear) {
+        var autocompleter = this.autocompleters[autocompleteType.name]
+        autocompleter.clearTextField();
+        autocompleter.setClearLinkVisibility();
+      }
+    }, this);
+    this.idTypes.each(function(idType) {
+      if (idType.name != name_to_not_clear) {
+        $(this.name + '_' + idType.name + '_id').value = '';
+      }
+    }, this);
+    this.selectTypes.each(function(selectType) {
+      if (selectType.name != name_to_not_clear) {
+        $(this.name + '_' + selectType.name + '_id').value = '';
+      }
+    }, this);
+  },
+  
+  hiddenField: function() {
+    return $(this.hiddenFieldId);
+  },
+  
+  hiddenTypeField: function() {
+    return $(this.hiddenTypeFieldId);
+  },
+  
+  newAutocompleter: function(autocompleteType) {
+    options = {
+      clearLink: autocompleteType.clearLink,
+      includeBlank: true,
+      modelName: autocompleteType.name,
+      palette: autocompleteType.palette,
+      paletteClonesInputWidth: false,
+      parameters: autocompleteType.parameters,
+      paramName: autocompleteType.name + '_autocomplete_input',
+      textField: autocompleteType.textField
+    };
+    options.afterAutocomplete = function(value) {
+      this.hiddenTypeField().value = autocompleteType.type;
+      this.clearInputsExceptFor(autocompleteType.name);
+    }.bind(this);
+    options.afterClearSelected = function(value) {
+      this.hiddenTypeField().value = '';
+    }.bind(this);
+    return new AdminAssistant.RestrictedAutocompleter(
+      autocompleteType.name, this.hiddenFieldId, autocompleteType.url,
+      options
+    );
+  },
+  
+  setHiddenFieldsFromIdField: function(event) {
+    input = event.findElement();
+    idType = this.idTypes.detect(function(idt) {
+      return (this.name + '_' + idt.name + '_id' == input.id);
+    }, this);
+    if (input.value == '') {
+      if (this.hiddenTypeField().value == idType.type) {
+        this.clearHiddenFields();
+      }
+    } else {
+      this.hiddenField().value = input.value;
+      this.hiddenTypeField().value = idType.type;
+      this.clearInputsExceptFor(idType.name);
+    }
+  },
+  
+  setHiddenFieldsFromSelectField: function(event) {
+    select = event.findElement();
+    selectType = this.selectTypes.detect(function(st) {
+      return (this.name + '_' + st.name + '_id' == select.id);
+    }, this);
+    if (select.value == '') {
+      if (this.hiddenTypeField().value == selectType.type) {
+        this.clearHiddenFields();
+      }
+    } else {
+      this.hiddenField().value = select.value;
+      this.hiddenTypeField().value = selectType.type;
+      this.clearInputsExceptFor(selectType.name);
+    }
+  }
+}
+
+/*
+This autocompleter restricts based on a list of names and matching IDs; the IDs
+are set in a hidden field. Arguments 
+*/
+AdminAssistant.RestrictedAutocompleter = Class.create();
+AdminAssistant.RestrictedAutocompleter.prototype = {
+  initialize: function(name, hiddenField, url, options) {
+    this.name = name;
+    this.textField = options.textField || (this.name + '_autocomplete_input');
+    this.palette = options.palette || (this.name + '_autocomplete_palette');
+    this.selectedTextFieldValue = $(this.textField).value;
+    this.hiddenField = hiddenField;
+    this.includeBlank = options.includeBlank;
+    this.modelName = options.modelName || this.name;
+    this.clearLink = options.clearLink || ('clear_' + this.name + '_link');
+    ajaxAutocompleterOptions = {
+      afterUpdateElement: this.autocompleteAfterUpdateElement.bind(this),
+      fullSearch: true,
+      onHide: this.autocompleteOnHide,
+      parameters: options.parameters,
+      paramName: options.paramName,
+      partialChars: 1,
+    };
+    if (!options.paletteClonesInputWidth) {
+      ajaxAutocompleterOptions.onShow = this.onShowWithoutCloningInputWidth;
+    }
+    var ac = new Ajax.Autocompleter(
+      this.textField, this.palette, url, ajaxAutocompleterOptions
+    );
+    this.changeArrowBehavior(ac);
+    this.setClearLinkVisibility();
+    Event.observe(this.clearLink, 'click', function(event) {
+      this.clearSelected();
+    }.bind(this));
+    this.afterAutocomplete = options.afterAutocomplete;
+    this.afterClearSelected = options.afterClearSelected;
+  },
+  
+  /*
+  This is the callback that fires after a selection is made from the 
+  autocompleter results.
+  
+  In addition to setting hidden id fields, it will place the text label of the 
+  selected item in the search field. It assumes that your selectedElement is
+  one with simple text contents or some markup structure with an element of 
+  class "title". In the latter case, it will use the text of the "title"
+  element.
+  */
+  autocompleteAfterUpdateElement: function(element, selectedElement) {
+    var id_name = element.id;
+    var input_id       = id_name.substr(id_name.length - 1)
+    var selected_value = selectedElement.id.substr(this.modelName.length)
+    
+    // If they have more complex markup inside the selection, get the "title" element
+    var title_element = selectedElement.down(".title")
+    if (title_element) selectedElement = title_element
+    
+    $(this.hiddenField).value = selected_value
+    this.selectedTextFieldValue =
+        selectedElement.innerHTML.unescapeHTML().strip();
+    this.setClearLinkVisibility();
+    if (this.afterAutocomplete) { this.afterAutocomplete(selected_value); }
+  },
+  
+	/*
+	Refresh the text fill-in field to the value reflected in the underlying
+	hidden input fields
+	*/
+	autocompleteOnHide: function( element, update ) {
+    if (this.selectedTextFieldValue) {
+      element.value = this.selectedTextFieldValue;
+    }
+		new Effect.Fade(update,{duration:0.15});
+	},
+  
+  /*
+  Overriding totally wierd arrow-up and arrow-down scrolling behavior built
+  into the autocompleter in scriptaculous 1.7.0
+  */
+  changeArrowBehavior: function(ac) {
+    ac.markPrevious = function() {
+      if(this.index > 0) this.index--
+        else this.index = this.entryCount-1;
+    };
+    ac.markNext = function() {
+      if(this.index < this.entryCount-1) this.index++
+        else this.index = 0;
+    };
+  },
+  
+  clearSelected: function() {
+    $(this.hiddenField).value = '';
+    this.clearTextField();
+    this.setClearLinkVisibility();
+    if (this.afterClearSelected) { this.afterClearSelected(); }
+  },
+  
+  onShowWithoutCloningInputWidth: function(element, update){
+    if(!update.style.position || update.style.position=='absolute') {
+      update.style.position = 'absolute';
+      Position.clone(element, update, {
+        setHeight: false, setWidth: false, offsetTop: element.offsetHeight
+      });
+    }
+    Effect.Appear(update,{duration:0.15});
+  },
+  
+  clearTextField: function() {
+    $(this.textField).value = '';
+  },
+  
+  setClearLinkVisibility: function() {
+    if ($(this.textField).value == '') {
+      $(this.clearLink).hide();
+    } else {
+      if (this.includeBlank) { $(this.clearLink).show(); }
+    }
+  }
+}
+