awesome_nested_fields 0.0.3

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in awesome_nested_fields.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/helpers/awesome_nested_fields_helper.rb

@@ -0,0 +1,46 @@
+module AwesomeNestedFieldsHelper
+  def nested_fields_items(builder, association, options={})
+    options = nested_fields_process_default_options(options, builder, association)
+
+    items = ''
+    builder.fields_for(association) do |f|
+      items << render(options[:partial], options[:builder_local] => f)
+    end
+
+    if options[:none_partial] and builder.object.send(association).empty?
+      items << render(options[:none_partial], options[:builder_local] => f)
+    end
+
+    items.html_safe
+  end
+
+  def nested_fields_template(builder, association, options={})
+    options = nested_fields_process_default_options(options, builder, association)
+
+    templates = content_tag(:script, type: 'text/html', class: options[:item_template_class]) do
+      builder.fields_for(association, options[:new_object], child_index: 'new_nested_item') do |f|
+        render(options[:partial], options[:builder_local] => f)
+      end
+    end
+
+    if options[:none_partial]
+      templates << content_tag(:script, type: 'text/html', class: options[:none_template_class]) do
+        builder.fields_for(association, options[:new_object], child_index: 'new_nested_item') do |f|
+          render(options[:none_partial], options[:builder_local] => f)
+        end
+      end
+    end
+
+    templates.html_safe
+  end
+
+protected
+  def nested_fields_process_default_options(options, builder, association)
+    options[:new_object] ||= builder.object.class.reflect_on_association(association).klass.new
+    options[:partial] ||= association.to_s.singularize
+    options[:builder_local] ||= :builder
+    options[:item_template_class] ||= 'template item'
+    options[:none_template_class] ||= 'template none'
+    options
+  end
+end

data/awesome_nested_fields.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/awesome_nested_fields/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'awesome_nested_fields'
+  s.version     = AwesomeNestedFields::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = %q[Lailson Bandeira]
+  s.email       = %q[lailson@guava.com.br]
+  s.homepage    = 'http://rubygems.org/gems/awesome_nested_fields'
+  s.summary     = 'Awesome nested fields for Rails'
+  s.description = 'Awesome dynamic nested fields for Rails and jQuery'
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "awesome_nested_fields"
+
+  s.add_development_dependency 'bundler', '>= 1.0.0'
+  s.add_runtime_dependency 'rails', '>= 3.0.0'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/lib/awesome_nested_fields.rb

@@ -0,0 +1,11 @@
+module AwesomeNestedFields
+  class Engine < Rails::Engine
+    initializer 'awesome_nested_fields.add_middleware' do |app|
+      app.middleware.use ActionDispatch::Static, "#{root}/public"
+    end
+
+    config.to_prepare do
+      ApplicationController.helper(AwesomeNestedFieldsHelper)
+    end
+  end
+end

data/lib/awesome_nested_fields/version.rb

@@ -0,0 +1,3 @@
+module AwesomeNestedFields
+  VERSION = "0.0.3"
+end

data/public/javascripts/jquery.nested-fields.js

@@ -0,0 +1,195 @@
+(function($) {
+  
+  var defaultSettings = {
+    beforeInsert: function(item, callback) { callback() },
+    afterInsert: function(item) {},
+    beforeRemove: function(item, callback) { callback() },
+    afterRemove: function(item) {},
+    itemTemplate: '.item.template',
+    noneTemplate: '.none.template',
+    container: '.container',
+    item: '.item',
+    none: '.none',
+    addHandler: '.add',
+    removeHandler: '.remove',
+    newItemIndex: 'new_nested_item'
+  };
+  
+  // PUBLIC API
+  var methods = {
+    init: function(options) {
+      var $this = $(this);
+      if($(this).data('nested-fields.options')) {
+        console.log('Nested fields already defined for this element. If you want to redefine options, destroy it and init again.');
+        return $this;
+      } else if(getOptions($this)) {
+        console.log('You cannot nest nested fields. Who would say that, uh?');
+        return $this;
+      }
+      
+      options = $.extend({}, defaultSettings, options);
+      options.itemTemplate = $(options.itemTemplate, $this);
+      options.noneTemplate = $(options.noneTemplate, $this);
+      options.container = $(options.container, $this);
+      options.addHandler = $(options.addHandler, $this);
+      $this.data('nested-fields.options', options); 
+      
+      options.addHandler.bind('click.nested-fields', function(e) {
+        e.preventDefault();
+        var newItem = prepareTemplate(options);
+        insertItemWithCallbacks(newItem, null, options);
+      });
+      
+      $(options.item, options.container).each(function(i, item) {
+        bindRemoveEvent(item, options);
+      });
+      
+      return $this;
+    },
+    
+    insert: function(callback, options) {
+      options = $.extend({}, getOptions(this), options);
+      var newItem = prepareTemplate(options);
+      
+      insertItemWithCallbacks(newItem, callback, options);
+    },
+    
+    remove: function(element, options) {
+      options = $.extend({}, getOptions(this), options);
+      return removeItem(element, options);
+    },
+    
+    removeAll: function(options) {
+      options = $.extend({}, getOptions(this), options);
+      $(methods.items.apply(this)).each(function(i, el) {
+        methods.remove(el, options);
+      });
+    },
+    
+    items: function() {
+      return findItems(getOptions(this));
+    },
+    
+    destroy: function() {
+      $(this).removeData('nested-fields.options');
+      $('*', this).unbind('.nested-fields');
+    }
+  };
+  
+  $.fn.nestedFields = function(method) {
+    if (methods[method]) {
+      return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
+    } else if (typeof method === 'object' || !method) {
+      return methods.init.apply(this, arguments);
+    } else {
+      $.error( 'Method ' +  method + ' does not exist on jQuery.nestedFields' );
+    }
+  };
+  
+  function getOptions(element) {
+    element = $(element);
+    while(element.length > 0) {
+      var data = element.data('nested-fields.options');
+      if(data) {
+        return data;
+      } else {
+        element = element.parent();
+      }
+    }
+    return null;
+  }
+  
+  function prepareTemplate(options) {
+    var regexp = new RegExp(options.newItemIndex, 'g');
+    var newId = new Date().getTime();
+    
+    var contents = options.itemTemplate.html();
+    var newItem = $(contents.replace(regexp, newId));
+    newItem.attr('data-new-record', true);
+    newItem.attr('data-record-id', newId);
+    
+    bindRemoveEvent(newItem, options);
+    
+    return newItem;
+  }
+  
+  function insertItem(newItem, options) {
+    removeNone(options);
+    options.container.append(newItem);
+  }
+  
+  function insertItemWithCallbacks(newItem, onInsertCallback, options) {  
+    function insert() {
+      if(onInsertCallback) {
+        onInsertCallback(newItem);
+      }
+      insertItem(newItem, options);
+    }
+    
+    if(!options.skipBefore) {
+      options.beforeInsert(newItem, insert);
+    } else {
+      insert();
+    }
+    
+    if(!options.skipAfter) {
+      options.afterInsert(newItem);
+    }
+    
+    return newItem;
+  }
+  
+  function removeItem(element, options) {
+    function remove() {
+      if($element.attr('data-new-record')) { // record is new
+        $element.remove();
+      } else { // record should be marked and sent to server
+        $element.find("INPUT[name$='[_destroy]']").val('true');
+        $element.hide();
+      }
+      insertNone(options);
+    }
+    
+    var $element = $(element);
+    if(!options.skipBefore) {
+      options.beforeRemove($element, remove);
+    } else {
+      remove();
+    }
+    
+    if(!options.skipAfter) {
+      options.afterRemove($element);
+    }
+    
+    return $element;
+  }
+  
+  function bindRemoveEvent(item, options) {
+    var removeHandler = $(item).find(options.removeHandler);
+    var needsConfirmation = removeHandler.attr('data-confirm');
+    
+    var event = needsConfirmation ? 'confirmed' : 'click';
+    removeHandler.bind(event + '.nested-fields', function(e) {
+      removeItem(item, options);
+    });
+  }
+  
+  function insertNone(options) {
+    if(findItems(options).length == 0) {
+      options.container.append(options.noneTemplate.html());
+    }
+  }
+  
+  function removeNone(options) {
+    findNone(options).remove();
+  }
+  
+  function findItems(options) {
+    return options.container.find(options.item + ':visible');
+  }
+  
+  function findNone(options) {
+    return options.container.find(options.none);
+  }
+  
+})(jQuery);

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: awesome_nested_fields
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 3
+  version: 0.0.3
+platform: ruby
+authors: 
+- Lailson Bandeira
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-12 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id002
+description: Awesome dynamic nested fields for Rails and jQuery
+email: lailson@guava.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- app/helpers/awesome_nested_fields_helper.rb
+- awesome_nested_fields.gemspec
+- lib/awesome_nested_fields.rb
+- lib/awesome_nested_fields/version.rb
+- public/javascripts/jquery.nested-fields.js
+has_rdoc: true
+homepage: http://rubygems.org/gems/awesome_nested_fields
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: awesome_nested_fields
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Awesome nested fields for Rails
+test_files: []
+