cocooned 1.3.0

data/app/assets/javascripts/cocooned/plugins/reorderable.js

@@ -0,0 +1,101 @@
+Cocooned.Plugins.Reorderable = {
+
+  defaultOptionValue: true,
+
+  bindReorderable: function() {
+    var self = this;
+
+    // Maintain indexes
+    this.container
+      .on('cocooned:after-insert',  function(e) { self.reindex(); })
+      .on('cocooned:after-remove',  function(e) { self.reindex(); })
+      .on('cocooned:after-move',    function(e) { self.reindex(); });
+
+    // Move items
+    this.container.on(
+      this.namespacedNativeEvents('click'),
+      [this.selector('up'), this.selector('down')].join(', '),
+      function(e) {
+        e.preventDefault();
+        var node = this;
+        var up = self.classes['up'].some(function(klass) {
+          return node.className.indexOf(klass) != -1;
+        });
+        self.move(this, up ? 'up' : 'down');
+      });
+
+    // Ensure positions are unique before save
+    this.container.closest('form').on(
+      this.namespacedNativeEvents('submit'),
+      function(e) {
+        self.reindex();
+      });
+  },
+
+  move: function(moveLink, direction) {
+    var self = this;
+    var $mover = $(moveLink);
+    var node = $mover.closest(this.selector('item'));
+    var siblings = (direction == 'up'
+        ? node.prevAll(this.selector('item', '&:eq(0)'))
+        : node.nextAll(this.selector('item', '&:eq(0)')));
+
+    if (siblings.length == 0) {
+      return;
+    }
+
+    // Move can be prevented through a 'cocooned:before-move' event handler
+    var eventData = { link: $mover, node: node, cocooned: this };
+    if (!self.notify(node, 'before-move', eventData)) {
+      return false;
+    }
+
+    var height = self.container.outerHeight();
+    var width = self.container.outerWidth();
+
+    self.container.css('height', height).css('width', width);
+    self.hide(node, function() {
+      var movedNode = $(this).detach();
+      movedNode[(direction == 'up' ? 'insertBefore' : 'insertAfter')](siblings);
+
+      self.show(movedNode, function() {
+        self.container.css('height', '').css('width', ''); // Object notation does not work here.
+        self.notify(movedNode, 'after-move', eventData);
+      });
+    });
+  },
+
+  reindex: function() {
+    var self = this;
+    var i = 0;
+    var nodes = this.getItems('&:visible');
+    var eventData = { link: null, nodes: nodes, cocooned: this };
+
+    // Reindex can be prevented through a 'cocooned:before-reindex' event handler
+    if (!this.notify(this.container, 'before-reindex', eventData)) {
+      return false;
+    }
+
+    nodes.each(function() { $('input[id$=_position]', this).val(++i); });
+    this.notify(this.container, 'after-reindex', eventData);
+  },
+
+  show: function(node, callback) {
+    callback = callback || function() {};
+
+    node.addClass('cocooned-visible-item');
+    setTimeout(function() {
+      callback.apply(node);
+      node.removeClass('cocooned-hidden-item');
+    }, 500);
+  },
+
+  hide: function(node, callback) {
+    node.removeClass('cocooned-visible-item').addClass('cocooned-hidden-item');
+    if (callback) {
+      setTimeout(function() {
+        callback.apply(node);
+      }, 500);
+    }
+  }
+};

data/app/assets/javascripts/cocooned.js

@@ -0,0 +1,3 @@
+//= require './cocooned/core'
+//= require_tree './cocooned/plugins'
+//= require_tree './cocooned/jquery'

data/app/assets/stylesheets/cocoon.css

@@ -0,0 +1,3 @@
+/*
+ *= require cocooned
+ */

data/app/assets/stylesheets/cocooned.css

@@ -0,0 +1,9 @@
+
+.cocooned-visible-item {
+  transition: opacity .45s ease-out;
+  opacity: 1;
+}
+
+.cocooned-hidden-item {
+  opacity: 0;
+}

data/cocooned.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cocooned/version'
+
+Gem::Specification.new do |spec|
+  spec.name         = 'cocooned'
+  spec.version      = Cocooned::VERSION
+  spec.licenses     = ['Apache-2.0']
+  spec.authors      = ['Gaël-Ian Havard', 'Nathan Van der Auwera']
+  spec.email        = ['gael-ian@notus.sh', 'nathan@dixis.com']
+
+  spec.summary      = 'Unobtrusive nested forms handling using jQuery.'
+  spec.description  = 'Easier nested form. Supports standard Rails forms, Formtastic and SimpleForm.'
+  spec.homepage     = 'http://github.com/notus-sh/cocooned'
+
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required.'
+  end
+
+  spec.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.add_dependency 'rails', '>= 4.0', '<= 6.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'jasmine', '~> 3.2'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.8.0'
+  spec.add_development_dependency 'rspec-rails', '~> 3.8.0'
+  spec.add_development_dependency 'rubocop'
+end

data/config/linters/js.json

@@ -0,0 +1,50 @@
+{
+  "extends": "standard",
+  "env": {
+    "browser": true,
+    "jquery": true
+  },
+  "parserOptions": { "ecmaVersion": 5 },
+  "rules": {
+    // Force strict mode
+    "strict": ["error", "function"],
+
+    // Coding style
+    "semi": ["error", "always"], // Keep semi-colon, even if standard say we shouldn't
+    "semi-style": ["error", "last"],
+    "object-curly-newline": ["error", { "consistent": true }],
+    "object-curly-spacing": ["error", "always"],
+    "switch-colon-spacing": ["error"],
+    "linebreak-style": ["error"],
+
+    // Warn on code smells
+    "max-len": ["warn", { "code": 150 }],
+    "max-params": ["warn"],
+
+    // No dead code
+    "no-else-return": ["error"],
+    "no-empty-function": ["error"],
+    "no-empty-pattern": ["error"],
+    "no-unused-expressions": ["error"],
+    "no-lonely-if": ["error"],
+
+    // Prevent stupid errors
+    "array-callback-return": ["error"],
+    "guard-for-in": ["error"],
+    "no-invalid-this": ["error"],
+    "no-loop-func": ["error"],
+    "radix": ["error"],
+    "no-catch-shadow": ["error"],
+    "no-use-before-define": ["error"],
+
+    // Prevent stupid syntaxes
+    "no-useless-concat": ["error"],
+    "no-useless-return": ["error"],
+
+    // No debug code will be commited
+    "no-alert": ["error"],
+
+    // eslint don't know the context
+    "no-invalid-this": ["off"]
+  }
+}

data/config/linters/ruby.yml

@@ -0,0 +1,16 @@
+inherit_mode:
+  merge:
+    - Exclude
+
+AllCops:
+  Exclude:
+    - 'spec/dummy/bin/*'
+
+Metrics/LineLength:
+  Max: 150
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/dummy/db/schema.rb'
+    - 'spec/cocooned/**/*_spec.rb'
+    - 'spec/shared_examples/**/*.rb'

data/gemfiles/Gemfile.rails-4

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+group :development, :test do
+  gem 'rails', '~> 4.0'
+  gem 'sqlite3'
+  gem 'simplecov', :require => false
+  gem 'nokogiri'
+end

data/gemfiles/Gemfile.rails-5

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+group :development, :test do
+  gem 'rails', '~> 5.0'
+  gem 'sqlite3'
+  gem 'simplecov', :require => false
+  gem 'nokogiri'
+end

data/lib/cocooned/association_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Cocooned
+  class AssociationBuilder
+    attr_accessor :association
+    attr_accessor :form
+    attr_accessor :options
+
+    def initialize(form, association, options = {})
+      self.form = form
+      self.association = association
+      self.options = options.reverse_merge(force_non_association_create: false, wrap_object: false)
+    end
+
+    def build_object
+      model = reflection ? build_with_reflection : build_without_reflection
+      model = @options[:wrap_object].call(model) if @options[:wrap_object].respond_to?(:call)
+      model
+    end
+
+    def singular_name
+      association.to_s.singularize
+    end
+
+    def plural_name
+      association.to_s.pluralize
+    end
+
+    private
+
+    def reflection
+      @reflection ||= begin
+        klass = form.object.class
+        klass.respond_to?(:reflect_on_association) ? klass.reflect_on_association(association) : nil
+      end
+    end
+
+    def build_with_reflection
+      return build_with_conditions if should_use_conditions?
+
+      # Assume ActiveRecord or compatible
+      # We use a clone of the current form object to not link
+      # object together (even if unsaved)
+      dummy = form.object.dup
+      model = if reflection.collection?
+                dummy.send(association).build
+              else
+                dummy.send("build_#{association}")
+              end
+      model = model.dup if model.frozen?
+      model
+    end
+
+    def build_without_reflection
+      methods = %W[build_#{plural_name} build_#{singular_name}].select { |m| form.object.respond_to?(m) }
+      raise "Association #{association} doesn't exist on #{form.object.class}" unless methods.any?
+      form.object.send(methods.first)
+    end
+
+    def should_use_conditions?
+      reflection.class.name == 'Mongoid::Relations::Metadata' || @options[:force_non_association_create]
+    end
+
+    def build_with_conditions
+      conditions = reflection.respond_to?(:conditions) ? reflection.conditions.flatten : []
+      reflection.klass.new(*conditions)
+    end
+  end
+end

data/lib/cocooned/helpers/cocoon_compatibility.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'cocooned/helpers/deprecate'
+
+module Cocooned
+  module Helpers
+    # Provide aliases to old Cocoon method for backward compatibility.
+    # Cocoon methods are deprecated and will be removed in next major release.
+    #
+    # TODO: Remove in 2.0
+    module CocoonCompatibility
+      extend Cocooned::Helpers::Deprecate
+
+      # @deprecated: Please use {#cocooned_add_item_link} instead
+      def link_to_add_association(*args, &block)
+        cocooned_add_item_link(*args, &block)
+      end
+      deprecate_release :link_to_add_association, :cocooned_add_item_link
+
+      # @deprecated: Please use {#cocooned_remove_item_link} instead
+      def link_to_remove_association(*args, &block)
+        cocooned_remove_item_link(*args, &block)
+      end
+      deprecate_release :link_to_remove_association, :cocooned_remove_item_link
+    end
+  end
+end

data/lib/cocooned/helpers/deprecate.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rubygems/deprecate'
+
+module Cocooned
+  module Helpers
+    # Extend the standard Gem::Deprecation module to add a deprecation
+    # method that specify the gem release where methods will disappear
+    # instead of a date.
+    module Deprecate
+      extend Gem::Deprecate
+
+      def deprecate_release_message(target_and_name, replacement, release = '2.0', location = nil)
+        [
+          "NOTE: #{target_and_name} is deprecated",
+          replacement == :none ? ' with no replacement' : "; use #{replacement} instead",
+          format('. It will dissapear in %s.', release),
+          location.nil? ? '' : "\n#{target_and_name} called from #{location}"
+        ].join.strip
+      end
+
+      module_function :deprecate_release_message
+
+      def deprecate_release(name, replacement, release = '2.0')
+        class_eval do
+          old = "_deprecated_#{name}"
+          alias_method old, name
+          define_method name do |*args, &block|
+            klass = is_a? Module
+            target = klass ? "#{self}." : "#{self.class}#"
+
+            unless Gem::Deprecate.skip
+              warn(deprecate_release_message(
+                     "#{target}#{name}",
+                     replacement,
+                     release,
+                     Gem.location_of_caller.join(':')
+                   ))
+            end
+
+            send old, *args, &block
+          end
+        end
+      end
+
+      module_function :deprecate_release
+    end
+  end
+end