dependent-select 0.0.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in dependent-select.gemspec
+gemspec

data/README.md

@@ -0,0 +1,36 @@
+# Dependent Select #
+
+dependent-select is a Formtastic 1.2 compatible extension which provides a `select` where the available options depend on the current value of another field.  When the parent field's value is changed, the options of the `dependent_select` are updated via an AJAX request.  Much of the functionality is implemented in a [jQuery plugin](https://github.com/topsail/dependent-select/blob/master/lib/assets/javascripts/dependent-select.js) which could be used independenly of Formtastic.
+
+## Simple Example ##
+
+    <%= semantic_form_for @user do |f| %>
+    <%= f.inputs do %>
+      <%= f.input :department, :as => :select,           :collection => Department.find(:all) %>
+      <%= f.input :division,   :as => :dependent_select, :parent_method => :department, :collection => (@user.department ? @user.department.divisions : []) %>
+    <% end %>
+    <% end %>
+
+In this example each `Department` has many `Divisions`.  Whenever the department field changes value, the division field is updated to contain only the `Divisions` of the selected `Department`.
+
+## URL template ##
+
+The URL used to request the updated option values is controlled by a simple template option, `url_template`, which defaults to:
+
+    /${plural_parent_resource_name}/${value}/${plural_resource_name}.json
+
+In the above example, assuming the selected department ID is 47, this would translate to `/departments/47/divisions.json`
+
+The default URL template can also be overridden globally:
+
+    DependentSelect.default_url_template = '/${plural_resource_name}.json?${parent_resource_name}=${value}'
+
+## Option template ##
+
+The server must return JSON records.  The new `option` tags are then generated via the `option_template`, which defaults to:
+
+    <option value="${id}">${name}</option>
+
+If the returned objects do not have an `id` and `name` attribute, `option_template` must be overridden.
+
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dependent-select.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "dependent_select/version"
+
+Gem::Specification.new do |s|
+  s.name        = "dependent-select"
+  s.version     = Dependent::Select::VERSION
+  s.authors     = ["Mark Roghelia"]
+  s.email       = ["mroghelia@topsailtech.com"]
+  s.summary     = %q{Helper and Formtastic support for a select box whose value depends on another field.}
+  #s.rubyforge_project = "dependent-select"
+  s.files         = `git ls-files`.split("\n")
+  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  #s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.add_dependency "formtastic"
+end

data/lib/assets/javascripts/dependent-select.js

@@ -0,0 +1,56 @@
+(function($){
+  
+  /*
+   * Sets up a select that refreshes its options whenever another
+   * field changes value.
+   *
+   * parentId - the ID of the observed field
+   *
+   * urlTemplate - the URL used to request the new data from the
+   *               server.  The value of the parent field will be
+   *               substituted for ${value} in the template
+   *
+   */
+  $.fn.dependentSelect = function(parentId, urlTemplate, options) {
+    
+    options = $.extend({
+      optionTemplate: '<option value="${id}">${name}</option>',
+      blankOptionHtml: '<option value=""></option>'
+    }, options || {});
+
+    var select = this;
+    
+    $('#' + parentId).bind('change', function(event) {
+
+      select.empty().append(options.blankOptionHtml); // clear out the current options
+
+      var url = urlTemplate.replace('${value}', event.target.value);
+
+      $.getJSON(url, function(resources) {
+
+        var nodes = [ ];
+
+        if (options.includeBlank) {
+          nodes.push(options.blankOptionHtml);
+        }
+
+        for (var i = resources.length-1; i >= 0; i--) {
+          
+          var optionNode = options.optionTemplate;
+          
+          // substitute resource property values in optionTemplate
+          for (attr in resources[i]) {
+            optionNode = optionNode.replace('${' + attr + '}', resources[i][attr]);  
+          }
+          
+          nodes.push(optionNode);
+        }
+
+        select.empty().append(nodes.join(''));
+      });
+    });
+
+    return this;
+  };
+
+})(jQuery);

data/lib/dependent-select.rb

@@ -0,0 +1 @@
+require 'dependent_select'

data/lib/dependent_select.rb

@@ -0,0 +1,10 @@
+require "formtastic"
+require "dependent_select/version"
+require 'dependent_select/semantic_form_builder'
+require "dependent_select/engine"
+
+module DependentSelect
+  mattr_accessor :default_url_template
+end
+
+DependentSelect.default_url_template = '/${plural_parent_resource_name}/${value}/${plural_resource_name}.json'

data/lib/dependent_select/engine.rb

@@ -0,0 +1,6 @@
+module DependentSelect
+
+  class Engine < ::Rails::Engine
+  end
+
+end

data/lib/dependent_select/semantic_form_builder.rb

@@ -0,0 +1,55 @@
+module Formtastic
+  class SemanticFormBuilder
+
+    # Options:
+    # parent_id - The DOM ID of the parent field to observe
+    # url_template - The jQuery-compatible template used to generate the URL
+    # parent_method - If provided, parent_id and url_template can be created automatically
+    # option_template - The jQuery-compatible template used to generate the select options
+    def dependent_select_input(method, options)
+
+      html = select_input(method, options)
+
+      options = {}.merge(options)
+
+      html_options = options.delete(:input_html) || {}
+      input_name = generate_association_input_name(method)
+      html_options[:id] ||= generate_html_id(input_name, "")
+
+      if options[:parent_method]
+        
+        parent_input_name = generate_association_input_name(options[:parent_method])
+        options[:parent_id] ||= generate_html_id(parent_input_name, "")
+
+        child_reflection = reflection_for(method)
+        parent_reflection = reflection_for(options[:parent_method])
+
+        if child_reflection && parent_reflection && parent_reflection.macro == :belongs_to
+          options[:url_template] ||= DependentSelect.default_url_template
+            .gsub('${resource_name}', child_reflection.class_name.underscore)
+            .gsub('${plural_resource_name}', child_reflection.class_name.underscore.pluralize)
+            .gsub('${parent_resource_name}', parent_reflection.class_name.underscore)
+            .gsub('${plural_parent_resource_name}', parent_reflection.class_name.underscore.pluralize)
+            .gsub('${parent_parameter}', parent_reflection.foreign_key.to_s)
+        end
+
+      end
+
+      unless options[:parent_id].blank? || options[:url_template].blank?
+
+        # convert to camelcase keys, which is the convention in Javascript
+        js_options = options.inject({}) do |hash, pair|
+          hash[pair[0].to_s.camelize(:lower)] = pair[1]
+          hash
+        end
+
+        html += "<script>$(document).ready(function() { $('##{html_options[:id]}').dependentSelect('#{options[:parent_id]}', '#{options[:url_template]}', #{js_options.to_json}) });</script>".html_safe
+
+      end
+
+      return html
+
+    end
+
+  end
+end

data/lib/dependent_select/version.rb

@@ -0,0 +1,5 @@
+module Dependent
+  module Select
+    VERSION = "0.0.2"
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: dependent-select
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Mark Roghelia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: formtastic
+  requirement: &71770510 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *71770510
+description: 
+email:
+- mroghelia@topsailtech.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- dependent-select.gemspec
+- lib/assets/javascripts/dependent-select.js
+- lib/dependent-select.rb
+- lib/dependent_select.rb
+- lib/dependent_select/engine.rb
+- lib/dependent_select/semantic_form_builder.rb
+- lib/dependent_select/version.rb
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Helper and Formtastic support for a select box whose value depends on another
+  field.
+test_files: []