cocooned 1.4.1 → 2.0.0

data/lib/cocooned/helpers/tags/up.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Helpers
+    module Tags
+      # Output an action link to move an item up.
+      #
+      # = Signatures
+      #
+      #   cocooned_move_item_up_link(label, form, options = {})
+      #     # Explicit name
+      #
+      #   cocooned_move_item_up_link(form, options = {}) do
+      #     # Name as a block
+      #   end
+      #
+      #   cocooned_move_item_up_link(form, options = {})
+      #     # Use default name
+      #
+      # = Parameters
+      #
+      # `label` is the text to be used as the link label. See the main
+      # documentation for Cocooned::Helpers::Tags for more about labelling.
+      #
+      # `form` is your form builder. Can be a SimpleForm::Builder,
+      # Formtastic::Builder or a standard Rails FormBuilder.
+      module Up
+        # Output a link to move an item up.
+        #
+        # = Signatures
+        #
+        #   cocooned_move_item_up_link(label, form, options = {})
+        #     # Explicit name
+        #
+        #   cocooned_move_item_up_link(form, options = {}) do
+        #     # Name as a block
+        #   end
+        #
+        #   cocooned_move_item_up_link(form, options = {})
+        #     # Use default name
+        #
+        # See Cocooned::Helpers::Tags::Up main documentation for a reference of
+        # supported parameters.
+        #
+        # See the documentation of +ActionView::Base#link_to+ for additional
+        # options.
+        def cocooned_move_item_up_link(*args, &block)
+          cocooned_link(Cocooned::Tags::Up, *args, &block)
+        end
+
+        # Output a button to move an item up.
+        #
+        # = Signatures
+        #
+        #   cocooned_move_item_up_button(label, form, options = {})
+        #     # Explicit name
+        #
+        #   cocooned_move_item_up_button(form, options = {}) do
+        #     # Name as a block
+        #   end
+        #
+        #   cocooned_move_item_up_button(form, options = {})
+        #     # Use default name
+        #
+        # See Cocooned::Helpers::Tags::Up main documentation for a reference of
+        # supported parameters.
+        #
+        # See the documentation of +ActionView::Helpers::FormBuilder#button+ for
+        # valid options.
+        def cocooned_move_item_up_button(*args, &block)
+          cocooned_button(Cocooned::Tags::Up, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/cocooned/helpers/tags.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Helpers
+    # Cocooned tags helpers output action link to interact with a dynamic nested form.
+    #
+    # Each action has its dedicated helpers:
+    #
+    # - `cocooned_add_item_link` / `cocooned_add_item_button` to add an item
+    # - `cocooned_remove_item_link` / `cocooned_remove_item_button` to remove
+    #   an item
+    # - `cocooned_move_item_up_link` / `cocooned_move_item_up_button` to move
+    #   an item up (in a reorderable form)
+    # - `cocooned_move_item_down_link` / `cocooned_move_item_down_link` to move
+    #   an item down (in a reorderable form)
+    #
+    # Labelling action links
+    #
+    # The label of any action links can be given explicitly as helper's first
+    # argument or as a block, just as you can do on ActionView's `link_to` or
+    # similar helpers.
+    #
+    # Additionally, Cocooned helpers will lookup I18n translations for a default
+    # label based on the action name (`add`, `remove`, `up`, `down`) and the
+    # association name.
+    #
+    # For `add` action links, the association name used is the same as passed as
+    # argument. On other action triggers, it is extracted from nested form
+    # #object_name.
+    #
+    # You can declare default labels in your translation files with following
+    # keys:
+    #
+    # - `cocooned.{association}.{action}` (Ex: `cocooned.items.add`)
+    # - `cocooned.defaults.{action}`
+    #
+    # If no translation is found, the default label will be the humanized action
+    # name.
+    module Tags
+      autoload :Add, 'cocooned/helpers/tags/add'
+      autoload :Down, 'cocooned/helpers/tags/down'
+      autoload :Remove, 'cocooned/helpers/tags/remove'
+      autoload :Up, 'cocooned/helpers/tags/up'
+
+      include Cocooned::Deprecated::Helpers::Tags
+
+      protected
+
+      def cocooned_link(klass, *args, &block)
+        options = args.extract_options!
+        klass.create(self, *args, **options, &block).render(as: :link)
+      end
+
+      def cocooned_button(klass, *args, &block)
+        options = args.extract_options!
+        klass.create(self, *args, **options, &block).render(as: :button)
+      end
+    end
+  end
+end

data/lib/cocooned/helpers.rb

@@ -1,334 +1,8 @@
 # frozen_string_literal: true
 
-require 'cocooned/helpers/deprecate'
-require 'cocooned/helpers/cocoon_compatibility'
-require 'cocooned/association_builder'
-
 module Cocooned
-  # TODO: Remove in 3.0 (Only Cocoon class names).
-  HELPER_CLASSES = {
-    add: %w[cocooned-add add_fields],
-    remove: %w[cocooned-remove remove_fields],
-    up: %w[cocooned-move-up],
-    down: %w[cocooned-move-down]
-  }.freeze
-
-  module Helpers # rubocop:disable Metrics/ModuleLength
-    # Create aliases to old Cocoon method name
-    # TODO: Remove in 3.0
-    include Cocooned::Helpers::CocoonCompatibility
-
-    # Output an action link to add an item in a nested form.
-    #
-    # ==== Signatures
-    #
-    #   cocooned_add_item_link(label, form, association, options = {})
-    #     # Explicit name
-    #
-    #   cocooned_add_item_link(form, association, options = {}) do
-    #     # Name as a block
-    #   end
-    #
-    #   cocooned_add_item_link(form, association, options = {})
-    #     # Use default name
-    #
-    # ==== Parameters
-    #
-    # `label` is the text to be used as the link label.
-    # Just as when you use the Rails builtin helper +link_to+, you can give an explicit
-    # label to your link or use a block to build it.
-    # If you provide neither an explicit label nor a block, Cocooned will try to use I18n
-    # to find a suitable label. This lookup will check the following keys:
-    #
-    # - `cocooned.{association}.add`
-    # - `cocooned.defaults.add`
-    #
-    # If none of these translation exist, it will fallback to 'Add'.
-    #
-    #
-    # `form` is your form builder. Can be a SimpleForm::Builder, Formtastic::Builder
-    # or a standard Rails FormBuilder.
-    #
-    # `association` is the name of the nested association.
-    # Ex: cocooned_add_item_link "Add an item", form, :items
-    #
-    # ==== Options
-    #
-    # `options` can be any of the following.
-    #
-    # Rendering options:
-    #
-    # - **partial**: the nested form partial.
-    #   Defaults to `{association.singular_name}_fields`.
-    # - **form_name**: name used to access the form builder in the nested form partial.
-    #   Defaults to `:f`.
-    # - **form_options**: options to be passed to the nested form builder. Can be used
-    #   to specify a wrapper for simple_form_fields if you use its Bootstrap setup, for
-    #   example.
-    #   No defaults.
-    # - **locals**: a hash of local variables, will be forwarded to the partial.
-    #   No default.
-    #
-    # Association options:
-    #
-    # - **insertion_method** : the jQuery method to be used to insert new items.
-    #   Can be any of `before`, `after`, `append`, `prepend`, `replaceWith`.
-    #   Defaults to `before`
-    # - **insertion_traversal** and **insertion_node** : respectively the jQuery
-    #   traversal method and the jQuery compatible selector that will be used to find
-    #   the insertion node, relative to the generated link.
-    #   When both are specified, `$(addLink).{traversal}({node})` will be used.
-    #   When only **insertion_node** is specified, `$({node})` will be used.
-    #   When only **insertion_traversal** is specified, it will be ignored.
-    #   When none is specified, `$(addLink).parent()` will be used.
-    # - **count**: how many item will be inserted on click.
-    #   Defaults to 1.
-    # - **wrap_object**: anything responding to `call` to be used to wrap the newly build
-    #   item instance. Can be useful with decorators or special initialisations.
-    #   Ex: cocooned_add_item_link "Add an item", form, :items,
-    #         wrap_object: Proc.new { |comment| CommentDecorator.new(comment) })
-    #   No default.
-    # - **force_non_association_create**: force to build instances of the nested model
-    #   outside association (i.e. without calling `build_{association}` or `{association}.build`)
-    #   Can be usefull if, for some specific reason, you need an object to _not_ be created
-    #   on the association, for example if you did not want `after_add` callbacks to be triggered.
-    #   Defaults to false.
-    #
-    # Link HTML options:
-    #
-    # You can pass any option supported by +link_to+. It will be politely forwarded.
-    # See the documentation of +link_to+ for more informations.
-    #
-    # Compatibility options:
-    #
-    # These options are supported for backward compatibility with the original Cocoon.
-    # **Support for these options will be removed in the next major release !**.
-    #
-    # - **render_options**: A nested Hash originaly used to pass locals and form builder
-    #   options.
-    #
-    def cocooned_add_item_link(*args, &block)
-      if block_given?
-        cocooned_add_item_link(capture(&block), *args)
-
-      elsif args.first.respond_to?(:object)
-        association = args.second
-        cocooned_add_item_link(cocooned_default_label(:add, association), *args)
-
-      else
-        name, form, association, html_options = *args
-        html_options ||= {}
-        html_options = html_options.dup.with_indifferent_access
-
-        builder_options = cocooned_extract_builder_options!(html_options)
-        render_options = cocooned_extract_render_options!(html_options)
-
-        builder = Cocooned::AssociationBuilder.new(form, association, builder_options)
-        rendered = cocooned_render_association(builder, render_options)
-
-        data = cocooned_extract_data!(html_options).merge!(
-          association: builder.singular_name,
-          associations: builder.plural_name,
-          association_insertion_template: CGI.escapeHTML(rendered.to_str).html_safe
-        )
-
-        html_options[:data] = (html_options[:data] || {}).merge(data)
-        html_options[:class] = [Array(html_options.delete(:class)).collect { |k| k.to_s.split(' ') },
-                                Cocooned::HELPER_CLASSES[:add]].flatten.compact.uniq.join(' ')
-
-        link_to(name, '#', html_options)
-      end
-    end
-
-    # Output an action link to remove an item (and an hidden field to mark
-    # it as destroyed if it has already been persisted).
-    #
-    # ==== Signatures
-    #
-    #   cocooned_remove_item_link(label, form, html_options = {})
-    #     # Explicit name
-    #
-    #   cocooned_remove_item_link(form, html_options = {}) do
-    #     # Name as a block
-    #   end
-    #
-    #   cocooned_remove_item_link(form, html_options = {})
-    #     # Use default name
-    #
-    # See the documentation of +link_to+ for valid options.
-    def cocooned_remove_item_link(name, form = nil, html_options = {}, &block)
-      # rubocop:disable Style/ParallelAssignment
-      html_options, form = form, nil if form.is_a?(Hash)
-      form, name = name, form if form.nil?
-      # rubocop:enable Style/ParallelAssignment
-
-      return cocooned_remove_item_link(capture(&block), form, html_options) if block_given?
-
-      association = form.object.class.to_s.tableize
-      return cocooned_remove_item_link(cocooned_default_label(:remove, association), form, html_options) if name.nil?
-
-      link_options = html_options.dup
-      link_options[:class] = [html_options[:class], Cocooned::HELPER_CLASSES[:remove]].flatten.compact
-      link_options[:class] << (form.object.new_record? ? 'dynamic' : 'existing')
-      link_options[:class] << 'destroyed' if form.object.marked_for_destruction?
-
-      form.hidden_field(:_destroy, value: form.object._destroy) << link_to(name, '#', link_options)
-    end
-
-    # Output an action link to move an item up.
-    #
-    # ==== Signatures
-    #
-    #   cocooned_move_item_up_link(label, form, html_options = {})
-    #     # Explicit name
-    #
-    #   cocooned_move_item_up_link(form, html_options = {}) do
-    #     # Name as a block
-    #   end
-    #
-    #   cocooned_move_item_up_link(form, html_options = {})
-    #     # Use default name
-    #
-    # See the documentation of +link_to+ for valid options.
-    def cocooned_move_item_up_link(name, form = nil, html_options = {}, &block)
-      cocooned_move_item_link(:up, name, form, html_options, &block)
-    end
-
-    # Output an action link to move an item down.
-    #
-    # ==== Signatures
-    #
-    #   cocooned_move_item_down_link(label, html_options = {})
-    #     # Explicit name
-    #
-    #   cocooned_move_item_down_link(html_options = {}) do
-    #     # Name as a block
-    #   end
-    #
-    #   cocooned_move_item_down_link(html_options = {})
-    #     # Use default name
-    #
-    # See the documentation of +link_to+ for valid options.
-    def cocooned_move_item_down_link(name, form = nil, html_options = {}, &block)
-      cocooned_move_item_link(:down, name, form, html_options, &block)
-    end
-
-    private
-
-    def cocooned_move_item_link(direction, name, form = nil, html_options = {}, &block)
-      form, name = name, form if form.nil?
-      return cocooned_move_item_link(direction, capture(&block), form, html_options) if block_given?
-      return cocooned_move_item_link(direction, cocooned_default_label(direction), form, html_options) if name.nil?
-
-      link_options = html_options.dup
-      link_options[:class] = [html_options[:class], Cocooned::HELPER_CLASSES[direction]].flatten.compact.join(' ')
-      link_to name, '#', link_options
-    end
-
-    def cocooned_default_label(action, association = nil)
-      # TODO: Remove in 3.0
-      if I18n.exists?(:cocoon)
-        msg = Cocooned::Helpers::Deprecate.deprecate_release_message('the :cocoon i18n scope', ':cocooned')
-        warn msg
-      end
-
-      keys = ["cocooned.defaults.#{action}", "cocoon.defaults.#{action}"]
-      keys.unshift("cocooned.#{association}.#{action}", "cocoon.#{association}.#{action}") unless association.nil?
-      keys.collect!(&:to_sym)
-      keys << action.to_s.humanize
-
-      I18n.translate(keys.take(1).first, default: keys.drop(1))
-    end
-
-    def cocooned_render_association(builder, options = {})
-      render_options = options.dup
-      locals = (render_options.delete(:locals) || {}).symbolize_keys
-      partial = render_options.delete(:partial) || "#{builder.singular_name}_fields"
-      form_name = render_options.delete(:form_name)
-      form_options = (render_options.delete(:form_options) || {}).symbolize_keys
-      form_options.reverse_merge!(child_index: "new_#{builder.association}")
-
-      builder.form.send(cocooned_form_method(builder.form),
-                        builder.association,
-                        builder.build_object,
-                        form_options) do |form_builder|
-        partial_options = { form_name.to_sym => form_builder, :dynamic => true }.merge(locals)
-        render(partial, partial_options)
-      end
-    end
-
-    def cocooned_form_method(form)
-      ancestors = form.class.ancestors.map(&:to_s)
-      if ancestors.include?('SimpleForm::FormBuilder')
-        :simple_fields_for
-      elsif ancestors.include?('Formtastic::FormBuilder')
-        :semantic_fields_for
-      else
-        :fields_for
-      end
-    end
-
-    def cocooned_extract_builder_options!(html_options)
-      %i[wrap_object force_non_association_create].each_with_object({}) do |option_name, opts|
-        opts[option_name] = html_options.delete(option_name) if html_options.key?(option_name)
-      end
-    end
-
-    def cocooned_extract_render_options!(html_options)
-      render_options = { form_name: :f }
-
-      # TODO: Remove in 2.0
-      if html_options.key?(:render_options)
-        msg = Cocooned::Helpers::Deprecate.deprecate_release_message(':render_options', :none)
-        warn msg
-
-        options = html_options.delete(:render_options)
-        render_options[:locals] = options.delete(:locals) if options.key?(:locals)
-        render_options[:form_options] = options
-      end
-
-      %i[locals partial form_name form_options].each_with_object(render_options) do |option_name, opts|
-        opts[option_name] = html_options.delete(option_name) if html_options.key?(option_name)
-      end
-    end
-
-    def cocooned_extract_data!(html_options)
-      data = {
-        count: [
-          html_options.delete(:count).to_i,
-          (html_options.key?(:data) ? html_options[:data].delete(:count) : 0).to_i,
-          1
-        ].compact.max,
-        association_insertion_node: cocooned_extract_single_data!(html_options, :insertion_node),
-        association_insertion_method: cocooned_extract_single_data!(html_options, :insertion_method),
-        association_insertion_traversal: cocooned_extract_single_data!(html_options, :insertion_traversal)
-      }
-
-      # Compatibility with the old way to pass data attributes to Rails view helpers
-      # Has we build a :data key, they will not be looked up.
-      html_options.keys.select { |k| k.to_s.match?(/data[_-]/) }.each_with_object(data) do |data_key, d|
-        key = data_key.to_s.gsub(/^data[_-]/, '')
-        d[key] = html_options.delete(data_key)
-      end
-      data.compact
-    end
-
-    def cocooned_extract_single_data!(hash, key)
-      k = key.to_s
-      return hash.delete(k) if hash.key?(k)
-
-      # Compatibility alternatives
-      # TODO: Remove in 2.0
-      return hash.delete("association_#{k}") if hash.key?("association_#{k}")
-      return hash.delete("data_association_#{k}") if hash.key?("data_association_#{k}")
-      return hash.delete("data-association-#{k.tr('_', '-')}") if hash.key?("data-association-#{k.tr('_', '-')}")
-      return nil unless hash.key?(:data)
-
-      d = hash[:data].with_indifferent_access
-      return d.delete("association_#{k}") if d.key?("association_#{k}")
-      return d.delete("association-#{k.tr('_', '-')}") if d.key?("association-#{k.tr('_', '-')}")
-
-      nil
-    end
+  module Helpers # :nodoc:
+    autoload :Containers, 'cocooned/helpers/containers'
+    autoload :Tags, 'cocooned/helpers/tags'
   end
 end

data/lib/cocooned/railtie.rb

@@ -4,10 +4,15 @@ require 'rails'
 require 'cocooned/helpers'
 
 module Cocooned
-  class Railtie < ::Rails::Engine
+  class Railtie < ::Rails::Engine # :nodoc:
     initializer 'cocooned.initialize' do |_app|
       ActiveSupport.on_load :action_view do
-        ActionView::Base.include Cocooned::Helpers
+        include Cocooned::Helpers::Tags,
+                Cocooned::Helpers::Tags::Add,
+                Cocooned::Helpers::Tags::Down,
+                Cocooned::Helpers::Tags::Remove,
+                Cocooned::Helpers::Tags::Up,
+                Cocooned::Helpers::Containers
       end
     end
   end

data/lib/cocooned/tags/add.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Tags
+    class Add < Base # :nodoc:
+      module AssociationOptions # :nodoc:
+        protected
+
+        def association_options
+          # TODO: Replace with compact_blank when dropping support for Rails 6.0
+          {
+            association: association,
+            template: html_template_name,
+            association_insertion_count: [options.delete(:count).to_i, 1].compact.max,
+            association_insertion_node: options.delete(:insertion_node),
+            association_insertion_method: options.delete(:insertion_method),
+            association_insertion_traversal: options.delete(:insertion_traversal)
+          }.reject { |_, value| value.blank? }
+        end
+      end
+
+      include Cocooned::TagsHelper::AssociationLabel
+
+      include Cocooned::TagsHelper::Renderer
+      include Cocooned::Deprecated::TagsHelper::Renderer
+      include AssociationOptions
+      include Cocooned::Deprecated::TagsHelper::AssociationOptions
+
+      def initialize(template, form, association, **options, &block)
+        @association = association
+        super(template, form, **options, &block)
+      end
+
+      def render(as: :link)
+        template.safe_join([super(as: as), html_template])
+      end
+
+      protected
+
+      attr_reader :association
+
+      def html_template
+        template.content_tag(:template, data: { name: html_template_name }) do
+          renderer.render.html_safe # rubocop:disable Rails/OutputSafety
+        end
+      end
+
+      def html_template_name
+        @html_template_name ||= SecureRandom.uuid
+      end
+
+      def html_classes
+        super + %w[cocooned-add add_fields]
+      end
+
+      def html_data
+        super.merge(association_options, cocooned_trigger: :add)
+      end
+    end
+  end
+end

data/lib/cocooned/tags/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Tags
+    class Base # :nodoc:
+      include Cocooned::TagsHelper::DefaultLabel
+      include Cocooned::Deprecated::TagsHelper::DefaultLabel
+
+      include Cocooned::TagsHelper::DataAttributes
+      include Cocooned::Deprecated::TagsHelper::DataAttributes
+
+      class << self
+        def create(template, *args, **kwargs, &block)
+          return new(template, *args, **kwargs, &block) if block
+          return new(template, *args, **kwargs) unless args.first.is_a?(String)
+
+          label = args.shift
+          new(template, *args, **kwargs) { label }
+        end
+      end
+
+      def initialize(template, form, **options, &block)
+        @template = template
+        @form = form
+        @options = options.dup.symbolize_keys
+        @label_block = block if block
+      end
+
+      def render(as: :link)
+        return template.link_to('#', html_options) { label } if as == :link
+        return template.button_tag(type: :button, **html_options) { label } if as == :button
+
+        raise ArgumentError, "Unsupported value for :as. Expected :link or :button, got #{as}."
+      end
+
+      protected
+
+      attr_reader :template, :form, :options, :label_block
+
+      def label
+        return default_label if label_block.blank?
+
+        label_block.call
+      end
+
+      def html_options
+        @html_options ||= begin
+          options[:class] = html_classes
+          options[:data] = html_data
+          # TODO: Replace with compact_blank when dropping support for Rails 6.0
+          options.reject { |_, value| value.blank? }
+        end
+      end
+
+      def html_classes
+        # TODO: Replace with compact_blank when dropping support for Rails 6.0
+        Array.wrap(options.delete(:class)).flat_map { |k| k.to_s.split }.reject(&:blank?)
+      end
+    end
+  end
+end

data/lib/cocooned/tags/down.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Tags
+    class Down < Base # :nodoc:
+      include Cocooned::TagsHelper::AssociationLabel
+
+      protected
+
+      def html_classes
+        super + %w[cocooned-move-down]
+      end
+
+      def html_data
+        super.merge(cocooned_trigger: :down)
+      end
+    end
+  end
+end

data/lib/cocooned/tags/remove.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Tags
+    class Remove < Base # :nodoc:
+      include Cocooned::TagsHelper::AssociationLabel
+
+      def render(as: :link)
+        template.safe_join([hidden_field, super(as: as)])
+      end
+
+      protected
+
+      def hidden_field
+        form.hidden_field(:_destroy, value: marked_for_destruction?)
+      end
+
+      def html_classes
+        super + %w[cocooned-remove remove_fields]
+      end
+
+      def html_data
+        super.merge(cocooned_trigger: :remove, cocooned_persisted: persisted?)
+      end
+
+      def persisted?
+        !!form.object.try(:persisted?)
+      end
+
+      def marked_for_destruction?
+        !!form.object.try(:marked_for_destruction?)
+      end
+    end
+  end
+end

data/lib/cocooned/tags/up.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Cocooned
+  module Tags
+    class Up < Base # :nodoc:
+      include Cocooned::TagsHelper::AssociationLabel
+
+      protected
+
+      def html_classes
+        super + %w[cocooned-move-up]
+      end
+
+      def html_data
+        super.merge(cocooned_trigger: :up)
+      end
+    end
+  end
+end