dynamic-fields-for 1.0.0

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Sergey Tokarenko
+
+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,139 @@
+DynamicFieldsFor
+================
+
+DynamicFieldsFor is a Rails plugin which provides the dynamic association fieldsets to your forms without a pain. And it does nothing more.
+
+The main features are:
+* Not breaks the HTML layout - no any wrappers, additional divs etc;
+* Works with fields block, i.e. not requires the separated partial for them;
+* Not provides new form helpers, but extend the existing one;
+* Simple and predictable interface and behavior;
+* Not requires any special HTML intities inside templates;
+* Supports [Simple Form](https://github.com/plataformatec/simple_form).
+
+## Alternatives
+* [coccon](https://github.com/nathanvda/cocoon)
+* [Nested Form](https://github.com/ryanb/nested_form)
+
+## Dependencies
+* [rails](https://github.com/rails/rails) >= 3.2.13
+* [jquery-rails](https://github.com/rails/jquery-rails)
+* [association-soft-build](https://github.com/stokarenko/association-soft-build)
+
+## Getting started
+
+Add to your Gemfile:
+
+```ruby
+  gem 'dynamic-fields-for'
+```
+
+Run the bundle command to install it.
+
+Add to `app/assets/javascripts/application.js`:
+```js
+//= require dynamic-fields-for
+```
+
+## Usage
+Lets say that we have the models:
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :roles
+end
+
+class Role < ActiveRecod::Base
+  belongs_to :user
+
+  validates :user, presence: true
+end
+```
+
+First, apply `inverse_of` to User's `:roles` associations, otherwise no chance to pass
+the validation of Role's user presence on user creation:
+```ruby
+class User < ActiveRecord::Base
+  has_many :roles, inverse_of: :user
+end
+```
+
+Add to User model:
+```ruby
+accepts_nested_attributes_for :roles, allow_destroy: true
+```
+
+Skip `allow_destroy` definition if you don't need to use `remove_fields_link` helper).
+
+Take care about strong parameters in controller like that:
+```ruby
+params.require(:user).permit(roles_attributes: [:id, :_destroy])
+```
+
+It is important to permit `id` role's parameter, don't miss it. As for `_destroy`,
+skip it if you don't need to use `remove_fields_link` helper.
+
+Then, in view:
+```haml
+= form_for resource do |f|
+  = f.text_field :user_name
+
+  = f.fields_for :roles, dynamic: true do |rf|
+    = rf.text_field :role_name
+    = rf.remove_fields_link 'Remove role'
+
+  = f.add_fields_link :roles, 'Add role'
+
+  = f.submit
+```
+
+DynamicFieldsFor supports SimpleForm:
+```haml
+= simple_form_for resource do |f|
+  = f.input :user_name
+
+  = f.simple_fields_for :roles, dynamic: true do |rf|
+    = rf.input :role_name
+    = rf.remove_fields_link 'Remove role'
+
+  = f.add_fields_link :roles, 'Add role'
+
+  = f.submit
+```
+
+## JavaScript events
+There are the events which will be triggered on `add_fields_link` click, in actual order:
+* `dynamic-fields:before-add-into` touched to dynamic fields parent node;
+* `dynamic-fields:after-add` touched to each first-level elements which was inserted;
+* `dynamic-fields:after-add-into` touched to dynamic fields parent node;
+
+Like that, these events will be triggered on `add_fields_link` click, in actual order:
+* `dynamic-fields:before-remove-from` touched to dynamic fields parent node;
+* `dynamic-fields:before-remove` touched to each first-level elements which going to be removed;
+* `dynamic-fields:after-remove-from` touched to dynamic fields parent node;
+
+Typical callback for dynamic fields parent node looks like:
+```js
+$(document).on('dynamic-fields:after-add-into', function(event){
+  $(event.target).find('li').order();
+})
+```
+
+As for first-level elements, need to remember that compatible callbacks
+will be triggered to each of them. To deal with this,
+use `$.find2` javascript helper, which provided by DynamicFieldsFor:
+```js
+$('#some_id').find2('.some_class');
+// doing the same as...
+$('#some_id').find('.some_class').add($('#some_id').filter('.some_class'));
+```
+
+Typical event callback first-level elements should looks like:
+```js
+$(document).on('dynamic-fields:after-add', function(event){
+  $(event.target).find2('.datepicker').datetimepicker();
+})
+```
+
+## License
+MIT License. Copyright (c) 2015 Sergey Tokarenko

data/app/assets/javascripts/dynamic-fields-for.js

@@ -0,0 +1,114 @@
+(function() {
+  var DynamicFields;
+
+  $.fn.extend({
+    find2: function(selector) {
+      return this.filter(selector).add(this.find(selector));
+    }
+  });
+
+  DynamicFields = (function() {
+    DynamicFields._counter = 0;
+
+    DynamicFields.add = function(element) {
+      var lazy_dynamic_fields;
+      lazy_dynamic_fields = this._find($(element).data('dynamicFieldsAdd'));
+      if (lazy_dynamic_fields) {
+        return lazy_dynamic_fields.add();
+      }
+    };
+
+    DynamicFields.remove = function(element) {
+      var lazy_dynamic_fields;
+      lazy_dynamic_fields = this._find($(element).data('dynamicFieldsRemove'));
+      if (lazy_dynamic_fields) {
+        return lazy_dynamic_fields.remove($(element));
+      }
+    };
+
+    DynamicFields._find = function(fields_id) {
+      var $fields_begin, fields_begin;
+      $fields_begin = this._$anchor('begin', fields_id);
+      fields_begin = $fields_begin.get(0);
+      if (!fields_begin) {
+        return null;
+      }
+      return fields_begin.lazy_dynamic_fields || (fields_begin.lazy_dynamic_fields = new this($fields_begin));
+    };
+
+    DynamicFields._anchor = function(postfix, fields_id) {
+      return "[data-dynamic-fields-" + postfix + "=" + fields_id + "]";
+    };
+
+    DynamicFields._$anchor = function(postfix, fields_id) {
+      return $(this._anchor(postfix, fields_id));
+    };
+
+    function DynamicFields($fields_begin) {
+      this.fields_id = $fields_begin.data('dynamicFieldsBegin');
+      this.$fields_begin = $fields_begin;
+      this.$fields_end = this._$anchor('end');
+      this.$fields_parent = this.$fields_begin.parent();
+    }
+
+    DynamicFields.prototype.add = function() {
+      var fields_add;
+      fields_add = $(this._render_insertion('Add'));
+      this.$fields_parent.trigger('dynamic-fields:before-add-into');
+      this.$fields_end.before(fields_add);
+      fields_add.not('script').trigger('dynamic-fields:after-add');
+      return this.$fields_parent.trigger('dynamic-fields:after-add-into');
+    };
+
+    DynamicFields.prototype.remove = function($element) {
+      var destroy_inputs, fields_item_begin, fields_remove, node, object_id;
+      node = $element;
+      while ((fields_item_begin = node.prevAll((this._anchor('item-begin')) + ":first"), fields_item_begin.length === 0)) {
+        node = node.parent();
+        if (node.length === 0) {
+          break;
+        }
+      }
+      if (fields_item_begin.length === 0) {
+        return;
+      }
+      if ((object_id = $element.data('dynamicFieldsRemoveId'))) {
+        destroy_inputs = this._render_insertion('Remove').replace(/(["])dynamic_fields_object_id(["])/g, "$1" + object_id + "$2");
+        this.$fields_begin.after(destroy_inputs);
+      }
+      fields_remove = fields_item_begin.nextUntil((this._anchor('item-begin')) + ", " + (this._anchor('end'))).andSelf();
+      this.$fields_parent.trigger('dynamic-fields:before-remove-from');
+      fields_remove.not('script').trigger('dynamic-fields:before-remove');
+      fields_remove.remove();
+      return this.$fields_parent.trigger('dynamic-fields:after-remove-from');
+    };
+
+    DynamicFields.prototype._anchor = function(postfix) {
+      return this.constructor._anchor(postfix, this.fields_id);
+    };
+
+    DynamicFields.prototype._$anchor = function(postfix) {
+      return this.constructor._$anchor(postfix, this.fields_id);
+    };
+
+    DynamicFields.prototype._render_insertion = function(template_type) {
+      var template;
+      template = this.$fields_begin.data("dynamicFields" + template_type + "Template");
+      return template.replace(/([_\[])dynamic_fields_index([_\]])/g, "$1" + (new Date().getTime() + this.constructor._counter++) + "$2");
+    };
+
+    return DynamicFields;
+
+  })();
+
+  $(document).on('click', '[data-dynamic-fields-remove]', function(event) {
+    event.preventDefault();
+    return DynamicFields.remove(this);
+  });
+
+  $(document).on('click', '[data-dynamic-fields-add]', function(event) {
+    event.preventDefault();
+    return DynamicFields.add(this);
+  });
+
+}).call(this);

data/lib/dynamic-fields-for.rb

@@ -0,0 +1,9 @@
+require 'dynamic-fields-for/version'
+require 'jquery-rails'
+require 'association-soft-build'
+
+module DynamicFieldsFor
+  autoload :FormHelper, 'dynamic-fields-for/form_helper'
+end
+
+require 'dynamic-fields-for/railtie'

data/lib/dynamic-fields-for/form_helper.rb

@@ -0,0 +1,69 @@
+module DynamicFieldsFor
+  module FormHelper
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :fields_for, :dynamic_fields
+      alias_method_chain :fields_for_nested_model, :dynamic_fields
+    end
+
+    def fields_for_with_dynamic_fields(association, record_object = nil, options = {}, &block)
+      #Inherit the native parameters adjustment
+      options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
+
+      return fields_for_without_dynamic_fields(association, record_object, options, &block) unless options.delete(:dynamic)
+
+      new_object = @object.send(association).soft_build
+
+      options[:child_index] = 'dynamic_fields_index'
+      remove_template = fields_for_without_dynamic_fields(association, new_object, options) do |f|
+        f.hidden_field(:id, value: 'dynamic_fields_object_id') +
+        f.hidden_field(:_destroy, value: true)
+      end
+
+      options[:dynamic_fields_id] = dynamic_fields_id(association)
+      add_template = fields_for_without_dynamic_fields(association, new_object, options, &block)
+
+      options.delete(:child_index)
+      collection_output = fields_for_without_dynamic_fields(association, record_object, options, &block)
+
+      @template.content_tag(:script, nil, data: {
+        'dynamic-fields-begin' => options[:dynamic_fields_id],
+        'dynamic-fields-add-template' => CGI.escapeHTML(add_template).html_safe,
+        'dynamic-fields-remove-template' => CGI.escapeHTML(remove_template).html_safe
+      }) +
+      collection_output +
+      @template.content_tag(:script, nil, data: {
+        'dynamic-fields-end' => options[:dynamic_fields_id]
+      })
+    end
+
+    def add_fields_link(association, label, options = {})
+      @template.link_to(label, '#', {data: {'dynamic-fields-add' => dynamic_fields_id(association)}}.deep_merge(options))
+    end
+
+    def remove_fields_link(label, options = {})
+      data_options = {data: {'dynamic-fields-remove' => @options[:dynamic_fields_id]}}
+      data_options[:data]['dynamic-fields-remove-id'] = @object.id if @object.try(:persisted?)
+
+      @template.link_to(label, '#', data_options.deep_merge(options))
+    end
+
+    def fields_for_nested_model_with_dynamic_fields(name, object, fields_options, block)
+      dynamic_item_begin_mark = fields_options.has_key?(:dynamic_fields_id) ?
+        @template.content_tag(:script, nil, data: {
+          'dynamic-fields-item-begin' => fields_options[:dynamic_fields_id]
+        }) : ''.html_safe
+
+        dynamic_item_begin_mark +
+        fields_for_nested_model_without_dynamic_fields(name, object, fields_options, block)
+    end
+
+    private
+
+    def dynamic_fields_id(association)
+      "#{self.object_id}-#{association}"
+    end
+
+  end
+end

data/lib/dynamic-fields-for/railtie.rb

@@ -0,0 +1,12 @@
+require 'active_record/railtie'
+
+module DynamicFieldsFor
+  class Engine < Rails::Engine
+
+    initializer 'dynamic-fields-for.configure_rails_initialization' do
+      ActiveSupport.on_load :action_view do
+        ActionView::Helpers::FormBuilder.send :include, DynamicFieldsFor::FormHelper
+      end
+    end
+  end
+end

data/lib/dynamic-fields-for/version.rb

@@ -0,0 +1,3 @@
+module DynamicFieldsFor
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: dynamic-fields-for
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sergey Tokarenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: jquery-rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: association-soft-build
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Dynamic association fieldsets without pain.
+email: private.tokarenko.sergey@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/assets/javascripts/dynamic-fields-for.js
+- lib/dynamic-fields-for/form_helper.rb
+- lib/dynamic-fields-for/railtie.rb
+- lib/dynamic-fields-for/version.rb
+- lib/dynamic-fields-for.rb
+- LICENSE
+- README.md
+homepage: https://github.com/stokarenko/dynamic-fields-for
+licenses:
+- MIT
+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.23.2
+signing_key: 
+specification_version: 3
+summary: Dynamic association fieldsets without pain.
+test_files: []