dynamic_selectable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b7f85c87b48e34c7b50514a220866f28c90d1e8
+  data.tar.gz: ec0448eeef9049b09ffbc00dd2a11fb2aee80345
+SHA512:
+  metadata.gz: ec3da87a01ef946068c95835cd7fce47b913b51599edfe46876591b001ec8d00c367dfb6af7aaa01949f79dce145d9ca8fa1fd60d0ed7225322892ed5d39a196
+  data.tar.gz: 056e1406e19753391bc3583634a0bee4e0db5c70433c50c4ef149202f279267446321014a80864eddccacb99c3feb6b4ad02c8ee9b44b0eb53a93236514c2c63

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dynamic_selectable.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2018 Moorem Technologies
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# DynamicSelectable
+
+DynamicSelectable is a [Rails](http://github.com/rails/rails) gem that allows you to easily create `collection_select` fields with results that dynamically populate a related field. The dynamic population occurs with the help of the jQuery library [*jquery-dynamic-selectable*](http://railsguides.net/cascading-selects-with-ajax-in-rails/) written by [Andrey Koleshko](http://railsguides.net/about-author/).
+
+How about a use case? Let's say your application allowed users to look up parts for their vehicle. A user selecting their car's model might include the following:
+
+1. User selects the `Make` of their vehicle
+2. The `Model` field is populated with models of the selected `Make`
+3. User selects the `Model` of their vehicle
+
+DynamicSelectable makes the above easy to do by providing a generator for your dynamic `collection_select` along with a new `FormHelper` method called `dynamic_collection_select`.
+
+To see this gem in action, you can check out the sample application [here](https://github.com/mattantonelli/dynamic-selectable-test).
+
+## Updating from 0.0.2
+
+***Warning:*** *If you are updating from `0.0.2` you will need to re-generate any content created with* `rails generate dynamic_selectable:select`.
+
+## Installation
+
+Add the following line to your application's Gemfile:
+
+```ruby
+gem 'dynamic_selectable', git: 'https://github.com/moorem/dynamic_selectable.git'
+```
+
+Install the gem by running `bundle install`.
+
+Run the gem's install generator:
+
+```
+$ rails generate dynamic_selectable:install
+```
+
+If you are using [Devise](https://github.com/plataformatec/devise) for user authentication, you will want to skip authentication in the newly generated `app/controllers/select/select_controller.rb`:
+
+```ruby
+class DynamicSelectable::SelectController < ApplicationController
+  # skip_before_action :authenticate_user!
+end
+```
+
+Finally, you'll want to add the following require to your `application.js`:
+
+```javascript
+//= require jquery-dynamic-selectable
+```
+
+Now that you have DynamicSelectable installed, you're ready to start creating some `dynamic_collection_select` fields in your application!
+
+## Usage
+
+The first step to creating a `dynamic_collection_select` is to generate a controller and route for it. Using the vehicle example from above, your `Make` and `Model` models might look like the following:
+
+```ruby
+# == Schema Information
+#
+# Table name: makes
+#
+#  id         :integer          not null, primary key
+#  name       :string
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+class Make < ActiveRecord::Base
+end
+```
+
+```ruby
+# == Schema Information
+#
+# Table name: models
+#
+#  id         :integer          not null, primary key
+#  name       :string
+#  make_id    :integer
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+class Model < ActiveRecord::Base
+  belongs_to :make
+end
+```
+
+To generate the controller and route necessary for your selection of `Make` to dynamically populate your selection of `Model`, run the following:
+
+```
+# Usage: rails generate dynamic_selectable:select parent child value_method text_method [sort_col:asc/desc]
+$ rails generate dynamic_selectable:select make model id name name:asc
+```
+
+Now you just need to build your form. The method `dynamic_collection_select` is very similar to [collection_select](http://apidock.com/rails/ActionView/Helpers/FormOptionsHelper/collection_select), but contains the new `dynamic_model` parameter. This parameter is a symbol representing the child model whose collection will be populated based on the value selected in this parent field.
+
+If you would like to submit the value of the `dynamic_collection_select` with the form, just add `{ submit_with_form: true }` to the `options` hash.
+
+
+```ruby
+def dynamic_collection_select(object, method, dynamic_model, collection, value_method, text_method,
+                              options = {}, html_options = {})
+```
+
+A very simple form would look something like this:
+
+```html+erb
+<%= form_for(@vehicle) do |f| %>
+  <div>
+    <%= label_tag :make_id %>
+    <%= dynamic_collection_select :vehicle, :make_id, :model, Make.all, :id, :name,
+        { include_blank: true }, {} %>
+  </div>
+
+  <div>
+    <%= f.label :model_id %>
+    <%= f.collection_select :model_id, [], :id, :name, {}, {} %>
+  </div>
+
+  <%# ... %>
+<% end %>
+```
+
+That's it. Happy selecting!
+
+## Overriding data attributes
+
+By default, DynamicSelectable uses the `object` and `method` parameters of `dynamic_collection_select` to generate data attributes used by the gem's Javascript. Depending on your model, or if you are creating a form with a gem like [Ransack](https://github.com/activerecord-hackery/ransack), the values you provide for these parameters could prevent DynamicSelectable from generating the necessary data attributes properly. To resolve this, you can manually specify these attributes in a `data` hash within your tag's `html_options` hash. For example:
+
+```html+erb
+<%= dynamic_collection_select :q, :make_id_eq, :model, Make.all, :id, :name,
+  {}, { data: { dynamic_selectable_url:    '/dynamic_selectable/makes/:make_id/models',
+                dynamic_selectable_target: '#q_model_id_eq' } } %>
+```
+
+The value for `dynamic_selectable_url` can be found in your routes:
+
+```
+$ rake routes | grep dynamic
+dynamic_selectable_make_models GET    /dynamic_selectable/makes/:make_id/models(.:format) dynamic_selectable/make_models#index
+```
+
+and the value for `dynamic_selectable_target` is generated with your form. This can be found by inspecting the child element in your web browser.
+
+## Removing generated content
+
+#### Remove a generated controller/route
+
+```
+$ rm app/controllers/dynamic_selectable/models_controller.rb
+```
+
+and remove the related line from your `routes.rb`:
+
+```ruby
+get ':make_id/models', to: 'models#index', as: :models
+```
+
+#### Complete uninstallation
+
+```bash
+$ rm -rf app/controllers/dynamic_selectable
+```
+
+and remove the following block from your `routes.rb`:
+
+```ruby
+namespace :dynamic_selectable do
+  # ...
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/moorem/dynamic_selectable/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+

data/Rakefile

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

data/dynamic_selectable.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dynamic_selectable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dynamic_selectable'
+  spec.version       = DynamicSelectable::VERSION
+  spec.authors       = ['Moorem Technologies']
+  spec.email         = ['mooremtechnologies@gmail.com']
+  spec.summary       = %q{Allows for easy dynamic population of cascading collection_select fields.}
+  spec.description   = 'DynamicSelectable will allow you to easily create collection_select fields
+                        with results that dynamically populate a related field.'
+  spec.homepage      = 'https://github.com/moorem/dynamic_selectable'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  spec.add_runtime_dependency 'coffee-script', '~> 2.3'
+  spec.add_runtime_dependency 'rails', '>= 4.1', '< 6.0'
+end

data/lib/dynamic_selectable.rb

@@ -0,0 +1,7 @@
+require 'dynamic_selectable/version'
+require 'dynamic_selectable/rails/engine'
+require 'dynamic_selectable/action_view/helpers/dynamic_form_options_helper'
+require 'dynamic_selectable/dynamic_collection_select' if defined?(Rails)
+
+module DynamicSelectable
+end

data/lib/dynamic_selectable/action_view/helpers/dynamic_form_options_helper.rb

@@ -0,0 +1,30 @@
+module DynamicSelectable
+  module ActionView
+    module Helpers
+      module DynamicFormOptionsHelper
+        def dynamic_collection_select(object, method, dynamic_model, collection, value_method, text_method,
+                                      options = {}, html_options = {})
+          select_url    = "dynamic_selectable_#{method.to_s.sub(/_id$/, '')}_#{dynamic_model.to_s.pluralize}_path"
+          parent_id     = ":#{method}"
+          select_target = "##{object}_#{dynamic_model}_id"
+
+          data = html_options.fetch(:data, {})
+          url, target = data.delete(:dynamic_selectable_url), data.delete(:dynamic_selectable_target)
+
+          data_options = { data: { dynamic_selectable_url:    url    || send(select_url, parent_id),
+                                   dynamic_selectable_target: target || select_target } }
+
+          data_options[:data].merge!(data)
+
+          if options[:submit_with_form] == true
+            submit_object = object
+            submit_method = method
+          end
+
+          collection_select(submit_object, submit_method, collection, value_method, text_method,
+                            options, html_options.merge(data_options))
+        end
+      end
+    end
+  end
+end

data/lib/dynamic_selectable/dynamic_collection_select.rb

@@ -0,0 +1,9 @@
+module DynamicSelectable
+  class Railtie < Rails::Railtie
+    initializer 'dynamic_selectable.configure_form_options_helpers' do |app|
+      ActiveSupport.on_load :action_view do
+        include DynamicSelectable::ActionView::Helpers::DynamicFormOptionsHelper
+      end
+    end
+  end
+end

data/lib/dynamic_selectable/rails/engine.rb

@@ -0,0 +1,4 @@
+module DynamicSelectable
+  class Engine < Rails::Engine
+  end
+end

data/lib/dynamic_selectable/version.rb

@@ -0,0 +1,3 @@
+module DynamicSelectable
+  VERSION = "0.0.1"
+end

data/lib/generators/dynamic_selectable/install_generator.rb

@@ -0,0 +1,15 @@
+module DynamicSelectable
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates',  __FILE__)
+
+    def create_route_namespace
+      inject_into_file 'config/routes.rb',
+        "  namespace :dynamic_selectable do\n  end\n\n",
+        after: "Rails.application.routes.draw do\n"
+    end
+
+    def create_parent_controller
+      copy_file 'select_controller.rb', 'app/controllers/dynamic_selectable/select_controller.rb'
+    end
+  end
+end

data/lib/generators/dynamic_selectable/select_generator.rb

@@ -0,0 +1,43 @@
+module DynamicSelectable
+  class SelectGenerator < Rails::Generators::Base
+    argument :attributes, :type => :array, :default => [],
+      :banner => "parent child value_method text_method [sort_col:asc/desc]"
+
+    def create_route
+      inject_into_file 'config/routes.rb', route(*attributes.first(2)), after: "namespace :dynamic_selectable do\n"
+    end
+
+    def create_controller_file
+      create_file controller_path(*attributes.first(2)), controller_body(*attributes)
+    end
+
+    private
+    def route(parent, child)
+      children = child.pluralize
+      "    get '#{parent.pluralize}/:#{parent}_id/#{children}', to: '#{parent}_#{children}#index', as: :#{parent}_#{children}\n"
+    end
+
+    def controller_path(parent, child)
+      "app/controllers/dynamic_selectable/#{parent}_#{child.pluralize.underscore}_controller.rb"
+    end
+
+    def controller_body(parent, child, val, text, sort)
+      children = child.pluralize
+      parent_class = parent.titleize.gsub(' ', '')
+      select_class = children.titleize.gsub(' ', '')
+      child_class  = child.titleize.gsub(' ', '')
+      order = sort.present? ? ".order('#{sort.gsub(':', ' ')}')" : ''
+
+      <<-END
+module DynamicSelectable
+  class #{parent_class}#{select_class}Controller < SelectController
+    def index
+      #{children} = #{child_class}.where(#{parent}_id: params[:#{parent}_id]).select('#{val}, #{text}')#{order}
+      render json: #{children}
+    end
+  end
+end
+      END
+    end
+  end
+end

data/lib/generators/dynamic_selectable/templates/select_controller.rb

@@ -0,0 +1,3 @@
+class DynamicSelectable::SelectController < ApplicationController
+  # skip_before_action :authenticate_user!
+end

data/vendor/assets/javascripts/jquery-dynamic-selectable.coffee

@@ -0,0 +1,35 @@
+$.fn.extend
+  dynamicSelectable: ->
+    $(@).each (i, el) ->
+      new DynamicSelectable($(el))
+
+class DynamicSelectable
+  constructor: ($select) ->
+    @init($select)
+
+  init: ($select) ->
+    @urlTemplate = $select.data('dynamicSelectableUrl')
+    @$targetSelect = $($select.data('dynamicSelectableTarget'))
+    $select.on 'change', =>
+      @clearTarget()
+      url = @constructUrl($select.val())
+      if url
+        $.getJSON url, (data) =>
+          $.each data, (index, el) =>
+            @$targetSelect.append "<option value='#{el.id}'>#{el.name}</option>"
+          @reinitializeTarget()
+      else
+        @reinitializeTarget()
+
+  reinitializeTarget: ->
+    @$targetSelect.trigger("change")
+
+  clearTarget: ->
+    @$targetSelect.html('<option></option>')
+
+  constructUrl: (id) ->
+    if id && id != ''
+      @urlTemplate.replace(/:.+_id/, id)
+
+$ ->
+  $('select[data-dynamic-selectable-url][data-dynamic-selectable-target]').dynamicSelectable()

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: dynamic_selectable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Moorem Technologies
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: coffee-script
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: |-
+  DynamicSelectable will allow you to easily create collection_select fields
+                          with results that dynamically populate a related field.
+email:
+- mooremtechnologies@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".idea/inspectionProfiles/Project_Default.xml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dynamic_selectable.gemspec
+- lib/dynamic_selectable.rb
+- lib/dynamic_selectable/action_view/helpers/dynamic_form_options_helper.rb
+- lib/dynamic_selectable/dynamic_collection_select.rb
+- lib/dynamic_selectable/rails/engine.rb
+- lib/dynamic_selectable/version.rb
+- lib/generators/dynamic_selectable/install_generator.rb
+- lib/generators/dynamic_selectable/select_generator.rb
+- lib/generators/dynamic_selectable/templates/select_controller.rb
+- vendor/assets/javascripts/jquery-dynamic-selectable.coffee
+homepage: https://github.com/moorem/dynamic_selectable
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Allows for easy dynamic population of cascading collection_select fields.
+test_files: []