autocomplete-activeadmin 0.1.0

data/Rakefile

@@ -0,0 +1,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+task :default => [:uglify, :test]
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :uglify do
+  require 'uglifier'
+  file_folder = "lib/assets/javascripts"
+  File.open("#{file_folder}/autocomplete-rails.js", "w") do |f|
+    f << Uglifier.compile(File.read("#{file_folder}/autocomplete-rails-uncompressed.js"))
+  end
+end
+

data/lib/assets/javascripts/autocomplete-rails-uncompressed.js

@@ -0,0 +1,197 @@
+/*
+* Unobtrusive autocomplete
+*
+* To use it, you just have to include the HTML attribute autocomplete
+* with the autocomplete URL as the value
+*
+*   Example:
+*       <input type="text" data-autocomplete="/url/to/autocomplete">
+*
+* Optionally, you can use a jQuery selector to specify a field that can
+* be updated with the element id whenever you find a matching value
+*
+*   Example:
+*       <input type="text" data-autocomplete="/url/to/autocomplete" data-id-element="#id_field">
+*/
+
+(function(jQuery)
+{
+  var self = null;
+  jQuery.fn.railsAutocomplete = function(selector) {
+    var handler = function() {
+      if (!this.railsAutoCompleter) {
+        this.railsAutoCompleter = new jQuery.railsAutocomplete(this);
+      }
+    };
+    if (jQuery.fn.on !== undefined) {
+      if (!selector) {
+        return;
+      }
+      return jQuery(document).on('focus',selector,handler);
+    }
+    else {
+      return this.live('focus',handler);
+    }
+  };
+
+  jQuery.railsAutocomplete = function (e) {
+    var _e = e;
+    this.init(_e);
+  };
+  jQuery.railsAutocomplete.options = {
+    showNoMatches: true,
+    noMatchesLabel: 'no existing match'
+  }
+
+  jQuery.railsAutocomplete.fn = jQuery.railsAutocomplete.prototype = {
+    railsAutocomplete: '0.0.1'
+  };
+
+  jQuery.railsAutocomplete.fn.extend = jQuery.railsAutocomplete.extend = jQuery.extend;
+  jQuery.railsAutocomplete.fn.extend({
+    init: function(e) {
+      e.delimiter = jQuery(e).attr('data-delimiter') || null;
+      e.min_length = jQuery(e).attr('data-min-length') || jQuery(e).attr('min-length') || 2;
+      e.append_to = jQuery(e).attr('data-append-to') || null;
+      e.autoFocus = jQuery(e).attr('data-auto-focus') || false;
+      function split( val ) {
+        return val.split( e.delimiter );
+      }
+      function extractLast( term ) {
+        return split( term ).pop().replace(/^\s+/,"");
+      }
+
+      jQuery(e).autocomplete({
+        appendTo: e.append_to,
+        autoFocus: e.autoFocus,
+        delay: jQuery(e).attr('delay') || 0,
+        source: function( request, response ) {
+          var firedFrom = this.element[0];
+          var params = {term: extractLast( request.term )};
+          if (jQuery(e).attr('data-autocomplete-fields')) {
+              jQuery.each(jQuery.parseJSON(jQuery(e).attr('data-autocomplete-fields')), function(field, selector) {
+              params[field] = jQuery(selector).val();
+            });
+          }
+          jQuery.getJSON( jQuery(e).attr('data-autocomplete'), params, function() {
+            var options = {};
+            jQuery.extend(options, jQuery.railsAutocomplete.options);
+            jQuery.each(options, function(key, value) {
+              if(options.hasOwnProperty(key)) {
+                var attrVal = jQuery(e).attr('data-' + key);
+                options[key] = attrVal ? attrVal : value;
+              }
+            });
+            if(arguments[0].length == 0 && jQuery.inArray(options.showNoMatches, [true, 'true']) >= 0) {
+              arguments[0] = [];
+              arguments[0][0] = { id: "", label: options.noMatchesLabel };
+            }
+            jQuery(arguments[0]).each(function(i, el) {
+              var obj = {};
+              obj[el.id] = el;
+              jQuery(e).data(obj);
+            });
+            response.apply(null, arguments);
+            jQuery(firedFrom).trigger('railsAutocomplete.source', arguments);
+          });
+        },
+        change: function( event, ui ) {
+            if(!jQuery(this).is('[data-id-element]') ||
+                    jQuery(jQuery(this).attr('data-id-element')).val() === "") {
+                    return;
+            }
+            jQuery(jQuery(this).attr('data-id-element')).val(ui.item ? ui.item.id : "").trigger('change');
+
+            if (jQuery(this).attr('data-update-elements')) {
+                var update_elements = jQuery.parseJSON(jQuery(this).attr("data-update-elements"));
+                var data = ui.item ? jQuery(this).data(ui.item.id.toString()) : {};
+                if(update_elements && jQuery(update_elements['id']).val() === "") {
+                  return;
+                }
+                for (var key in update_elements) {
+                    var element = jQuery(update_elements[key]);
+                    if (element.is(':checkbox')) {
+                        if (data[key] != null) {
+                            element.prop('checked', data[key]);
+                        }
+                    } else {
+                        element.val(ui.item ? data[key] : "").trigger('change');
+                    }
+                }
+            }
+        },
+        search: function() {
+          // custom minLength
+          var term = extractLast( this.value );
+          if ( term.length < e.min_length ) {
+            return false;
+          }
+        },
+        focus: function() {
+          // prevent value inserted on focus
+          return false;
+        },
+        select: function( event, ui ) {
+          // first ensure value is a string
+          ui.item.value = ui.item.value.toString();
+          if(ui.item.value.toLowerCase().indexOf('no match') != -1 || ui.item.value.toLowerCase().indexOf('too many results') != -1){
+            jQuery(this).trigger('railsAutocomplete.noMatch', ui);
+            return false;
+          }
+          var terms = split( this.value );
+          // remove the current input
+          terms.pop();
+          // add the selected item
+          terms.push( ui.item.value );
+          // add placeholder to get the comma-and-space at the end
+          if (e.delimiter != null) {
+            terms.push( "" );
+            this.value = terms.join( e.delimiter );
+          } else {
+            this.value = terms.join("");
+            if (jQuery(this).attr('data-id-element')) {
+              jQuery(jQuery(this).attr('data-id-element')).val(ui.item.id).trigger('change');
+            }
+            if (jQuery(this).attr('data-update-elements')) {
+              var data = ui.item;
+              var new_record = ui.item.value.indexOf('Create New') != -1 ? true : false;
+              var update_elements = jQuery.parseJSON(jQuery(this).attr("data-update-elements"));
+              for (var key in update_elements) {
+                if(jQuery(update_elements[key]).attr("type") === "checkbox"){
+                   if(data[key] === true || data[key] === 1) {
+                       jQuery(update_elements[key]).attr("checked","checked");
+                   }
+                   else {
+                       jQuery(update_elements[key]).removeAttr("checked");
+                   }
+                }
+                else{
+                  if((new_record && data[key] && data[key].indexOf('Create New') == -1) || !new_record){
+                    jQuery(update_elements[key]).val(data[key]).trigger('change');
+                  }else{
+                    jQuery(update_elements[key]).val('').trigger('change');
+                  }
+                }
+               }
+            }
+          }
+          var remember_string = this.value;
+          jQuery(this).bind('keyup.clearId', function(){
+            if(jQuery.trim(jQuery(this).val()) != jQuery.trim(remember_string)){
+              jQuery(jQuery(this).attr('data-id-element')).val("").trigger('change');
+              jQuery(this).unbind('keyup.clearId');
+            }
+          });
+          jQuery(e).trigger('railsAutocomplete.select', ui);
+
+          return false;
+        }
+      });
+      jQuery(e).trigger('railsAutocomplete.init');
+    }
+  });
+
+  jQuery(document).ready(function(){
+    jQuery('input[data-autocomplete]').railsAutocomplete('input[data-autocomplete]');
+  });
+})(jQuery);

data/lib/assets/javascripts/autocomplete-rails.js

@@ -0,0 +1 @@
+!function(t){t.fn.railsAutocomplete=function(e){var a=function(){this.railsAutoCompleter||(this.railsAutoCompleter=new t.railsAutocomplete(this))};if(void 0!==t.fn.on){if(!e)return;return t(document).on("focus",e,a)}return this.live("focus",a)},t.railsAutocomplete=function(t){var e=t;this.init(e)},t.railsAutocomplete.options={showNoMatches:!0,noMatchesLabel:"no existing match"},t.railsAutocomplete.fn=t.railsAutocomplete.prototype={railsAutocomplete:"0.0.1"},t.railsAutocomplete.fn.extend=t.railsAutocomplete.extend=t.extend,t.railsAutocomplete.fn.extend({init:function(e){function a(t){return t.split(e.delimiter)}function i(t){return a(t).pop().replace(/^\s+/,"")}e.delimiter=t(e).attr("data-delimiter")||null,e.min_length=t(e).attr("data-min-length")||t(e).attr("min-length")||2,e.append_to=t(e).attr("data-append-to")||null,e.autoFocus=t(e).attr("data-auto-focus")||!1,t(e).autocomplete({appendTo:e.append_to,autoFocus:e.autoFocus,delay:t(e).attr("delay")||0,source:function(a,r){var n=this.element[0],o={term:i(a.term)};t(e).attr("data-autocomplete-fields")&&t.each(t.parseJSON(t(e).attr("data-autocomplete-fields")),function(e,a){o[e]=t(a).val()}),t.getJSON(t(e).attr("data-autocomplete"),o,function(){var a={};t.extend(a,t.railsAutocomplete.options),t.each(a,function(i,r){if(a.hasOwnProperty(i)){var n=t(e).attr("data-"+i);a[i]=n?n:r}}),0==arguments[0].length&&t.inArray(a.showNoMatches,[!0,"true"])>=0&&(arguments[0]=[],arguments[0][0]={id:"",label:a.noMatchesLabel}),t(arguments[0]).each(function(a,i){var r={};r[i.id]=i,t(e).data(r)}),r.apply(null,arguments),t(n).trigger("railsAutocomplete.source",arguments)})},change:function(e,a){if(t(this).is("[data-id-element]")&&""!==t(t(this).attr("data-id-element")).val()&&(t(t(this).attr("data-id-element")).val(a.item?a.item.id:"").trigger("change"),t(this).attr("data-update-elements"))){var i=t.parseJSON(t(this).attr("data-update-elements")),r=a.item?t(this).data(a.item.id.toString()):{};if(i&&""===t(i.id).val())return;for(var n in i){var o=t(i[n]);o.is(":checkbox")?null!=r[n]&&o.prop("checked",r[n]):o.val(a.item?r[n]:"").trigger("change")}}},search:function(){var t=i(this.value);return t.length<e.min_length?!1:void 0},focus:function(){return!1},select:function(i,r){if(r.item.value=r.item.value.toString(),-1!=r.item.value.toLowerCase().indexOf("no match")||-1!=r.item.value.toLowerCase().indexOf("too many results"))return t(this).trigger("railsAutocomplete.noMatch",r),!1;var n=a(this.value);if(n.pop(),n.push(r.item.value),null!=e.delimiter)n.push(""),this.value=n.join(e.delimiter);else if(this.value=n.join(""),t(this).attr("data-id-element")&&t(t(this).attr("data-id-element")).val(r.item.id).trigger("change"),t(this).attr("data-update-elements")){var o=r.item,l=-1!=r.item.value.indexOf("Create New")?!0:!1,u=t.parseJSON(t(this).attr("data-update-elements"));for(var s in u)"checkbox"===t(u[s]).attr("type")?o[s]===!0||1===o[s]?t(u[s]).attr("checked","checked"):t(u[s]).removeAttr("checked"):l&&o[s]&&-1==o[s].indexOf("Create New")||!l?t(u[s]).val(o[s]).trigger("change"):t(u[s]).val("").trigger("change")}var c=this.value;return t(this).bind("keyup.clearId",function(){t.trim(t(this).val())!=t.trim(c)&&(t(t(this).attr("data-id-element")).val("").trigger("change"),t(this).unbind("keyup.clearId"))}),t(e).trigger("railsAutocomplete.select",r),!1}}),t(e).trigger("railsAutocomplete.init")}}),t(document).ready(function(){t("input[data-autocomplete]").railsAutocomplete("input[data-autocomplete]")})}(jQuery);

data/lib/autocomplete-activeadmin.rb

@@ -0,0 +1,23 @@
+require 'autocomplete-activeadmin/form_helper'
+require 'autocomplete-activeadmin/autocomplete'
+
+module AutocompleteActiveAdmin
+  autoload :Orm              , 'autocomplete-activeadmin/orm'
+  autoload :FormtasticPlugin , 'autocomplete-activeadmin/formtastic_plugin'
+
+  unless ::Rails.version < "3.1"
+    require 'autocomplete-activeadmin/rails/engine'
+  end
+end
+
+class ActionController::Base
+  include AutocompleteActiveAdmin::Autocomplete
+end
+
+require 'autocomplete-activeadmin/formtastic'
+
+begin
+  require 'simple_form'
+  require 'autocomplete-activeadmin/simple_form_plugin'
+rescue LoadError
+end

data/lib/autocomplete-activeadmin/autocomplete.rb

@@ -0,0 +1,116 @@
+module AutocompleteActiveAdmin
+  module Autocomplete
+    def self.included(target)
+      target.extend AutocompleteActiveAdmin::Autocomplete::ClassMethods
+
+      target.send :include, AutocompleteActiveAdmin::Orm::Mongoid if defined?(Mongoid::Document)
+      target.send :include, AutocompleteActiveAdmin::Orm::MongoMapper if defined?(MongoMapper::Document)
+      target.send :include, AutocompleteActiveAdmin::Orm::ActiveRecord
+
+    end
+
+    #
+    # Usage:
+    #
+    # class ProductsController < Admin::BaseController
+    #   autocomplete :brand, :name
+    # end
+    #
+    # This will magically generate an action autocomplete_brand_name, so,
+    # don't forget to add it on your routes file
+    #
+    #   resources :products do
+    #      get :autocomplete_brand_name, :on => :collection
+    #   end
+    #
+    # Now, on your view, all you have to do is have a text field like:
+    #
+    #   f.text_field :brand_name, :autocomplete => autocomplete_brand_name_products_path
+    #
+    #
+    # Yajl is used by default to encode results, if you want to use a different encoder
+    # you can specify your custom encoder via block
+    #
+    # class ProductsController < Admin::BaseController
+    #   autocomplete :brand, :name do |items|
+    #     CustomJSONEncoder.encode(items)
+    #   end
+    # end
+    #
+    module ClassMethods
+      def autocomplete(object, method, options = {}, &block)
+
+        define_method("get_prefix") do |model|
+          if defined?(Mongoid::Document) && model.include?(Mongoid::Document)
+            'mongoid'
+          elsif defined?(MongoMapper::Document) && model.include?(MongoMapper::Document)
+            'mongo_mapper'
+          else
+            'active_record'
+          end
+        end
+        define_method("get_autocomplete_order") do |method, options, model=nil|
+          method("#{get_prefix(get_object(options[:class_name] || object))}_get_autocomplete_order").call(method, options, model)
+        end
+
+        define_method("get_autocomplete_items") do |parameters|
+          method("#{get_prefix(get_object(options[:class_name] || object))}_get_autocomplete_items").call(parameters)
+        end
+
+        define_method("autocomplete_#{object}_#{method}") do
+
+          method = options[:column_name] if options.has_key?(:column_name)
+
+          term = params[:term]
+
+          if term && !term.blank?
+            #allow specifying fully qualified class name for model object
+            class_name = options[:class_name] || object
+            items = get_autocomplete_items(:model => get_object(class_name), \
+              :options => options, :term => term, :method => method)
+          else
+            items = {}
+          end
+
+          render :json => json_for_autocomplete(items, options[:display_value] ||= method, options[:extra_data], &block), root: false
+        end
+      end
+    end
+
+    # Returns a limit that will be used on the query
+    def get_autocomplete_limit(options)
+      options[:limit] ||= 10
+    end
+
+    # Returns parameter model_sym as a constant
+    #
+    #   get_object(:actor)
+    #   # returns a Actor constant supposing it is already defined
+    #
+    def get_object(model_sym)
+      object = model_sym.to_s.camelize.constantize
+    end
+
+    #
+    # Returns a hash with three keys actually used by the Autocomplete jQuery-ui
+    # Can be overriden to show whatever you like
+    # Hash also includes a key/value pair for each method in extra_data
+    #
+    def json_for_autocomplete(items, method, extra_data=[])
+      items = items.collect do |item|
+        hash = HashWithIndifferentAccess.new({"id" => item.id.to_s, "label" => item.send(method), "value" => item.send(method)})
+        extra_data.each do |datum|
+          hash[datum] = item.send(datum)
+        end if extra_data
+        # TODO: Come back to remove this if clause when test suite is better
+        hash
+      end
+      if block_given?
+        yield(items)
+      else
+        items
+      end
+    end
+  end
+end
+

data/lib/autocomplete-activeadmin/form_helper.rb

@@ -0,0 +1,49 @@
+module ActionView
+  module Helpers
+    module FormHelper
+      # Returns an input tag of the "text" type tailored for accessing a specified attribute (identified by +method+) and
+      # that is populated with jQuery's autocomplete plugin.
+      #
+      # ==== Examples
+      #   autocomplete_field(:post, :title, author_autocomplete_path, :size => 20)
+      #   # => <input type="text" id="post_title" name="post[title]" size="20" value="#{@post.title}"  data-autocomplete="author/autocomplete"/>
+      #
+      def autocomplete_field(object_name, method, source, options ={})
+        options["data-autocomplete"] = source
+        text_field(object_name, method, rewrite_autocomplete_option(options))
+      end
+    end
+
+    module FormTagHelper
+      # Creates a standard text field that can be populated with jQuery's autocomplete plugin
+      #
+      # ==== Examples
+      #   autocomplete_field_tag 'address', '', address_autocomplete_path, :size => 75
+      #   # => <input id="address" name="address" size="75" type="text" value="" data-autocomplete="address/autocomplete"/>
+      #
+      def autocomplete_field_tag(name, value, source, options ={})
+        options["data-autocomplete"] = source
+        text_field_tag(name, value, rewrite_autocomplete_option(options))
+      end
+    end
+
+    #
+    # Method used to rename the autocomplete key to a more standard
+    # data-autocomplete key
+    #
+    private
+    def rewrite_autocomplete_option(options)
+      options["data-autocomplete-fields"] = JSON.generate(options.delete :fields) if options[:fields]
+      options["data-update-elements"] = JSON.generate(options.delete :update_elements) if options[:update_elements]
+      options["data-id-element"] = options.delete :id_element if options[:id_element]
+      options["data-append-to"] = options.delete :append_to if options[:append_to]
+      options
+    end
+  end
+end
+
+class ActionView::Helpers::FormBuilder #:nodoc:
+  def autocomplete_field(method, source, options = {})
+    @template.autocomplete_field(@object_name, method, source, objectify_options(options))
+  end
+end

data/lib/autocomplete-activeadmin/formtastic.rb

@@ -0,0 +1,41 @@
+#
+# Load the formtastic plugin if using Formtastic
+#
+begin
+  require 'formtastic'
+  begin
+    require "formtastic/version"
+  rescue LoadError
+  end
+
+  if defined?(Formtastic::VERSION)
+    #
+    # Formtastic 2.x
+    #
+
+    module Formtastic
+      module Inputs
+        class AutocompleteInput
+          include Base
+          include Base::Stringish
+
+          def to_html
+            input_wrapping do
+              label_html <<
+              builder.autocomplete_field(method, options.delete(:url), input_html_options)
+            end
+          end
+        end
+      end
+    end
+  else
+
+    #
+    # Formtastic 1.x
+    #
+    class Formtastic::SemanticFormBuilder < ActionView::Helpers::FormBuilder
+      include AutocompleteActiveAdmin::FormtasticPlugin
+    end
+  end
+rescue LoadError
+end