view_partial_form_builder 0.1.0 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e30eab928ee84a6217afbabc1c746aa7a7906efa5417fc323f6b78e476aa3fbb
-  data.tar.gz: 21af6978419ac00cebba9989b86943eb2d4d102397d880cee50acb8a7ef11c7c
+  metadata.gz: 1d1550e43fb981483d25dedf89ab64478b5dd2c5803b4aa7345ae6d7efba4fe2
+  data.tar.gz: d8bb992d8d959d2288c761d764275af9e470081145884b6bfcff7b7dda3fdc45
 SHA512:
-  metadata.gz: 848d4ddf155cb750a63400e9a5aaa3ea062a4d01b3041294c6ddbf64c3570882e28052d6b55066c731320daae6b43e7fa53c47f1a89924603bab50c3ba3885be
-  data.tar.gz: 05e69629609a81b0563bc5a234c3305dc0355e6f0b458d6aea41e75d49009d26a1e274a9ce7e4ccf6b50aa4ff90afa79c30220f44d97a4c754d9988fd9476046
+  metadata.gz: 121978b8280e71e3cf114291cf4874949c9323f7b909ab7cd93602f1a3fb00b143c2028ed1188623c8b926efe8b3a27e67005947599d66b8e1cb33c98d8c589e
+  data.tar.gz: 9e56d40123f55fac7ee53b3bd3e087ccc35bdf3ca709485cad0d636fb41f7f684744dbc068d7af13bcdc6aa246e9707373c557f792d86a1d3fee1cd76468e4f0

data/README.md

@@ -87,7 +87,7 @@ generating HTML through Rails' helpers:
 <%# app/views/form_builder/_button.html.erb %>
 
 <div class="button-wrapper">
-  <%= form.button(*arguments, **options, &block) %>
+  <%= form.button(value, options, &block) %>
 </div>
 ```
 
@@ -116,31 +116,8 @@ In addition, each view partial receives:
 * `form` - a reference to the instance of `ViewPartialFormBuilder`, which is a
   descendant of [`ActionView::Helpers::FormBuilder`][FormBuilder]
 
-* `arguments` - an Array containing the arguments the helper received, in the
-  order they were received. This can be useful to pass to the view partial's
-  helper by [splatting them][splat] out.
-
 * `&block` - a callable, `yield`-able block if the helper method was passed one
 
-In cases when a [`ActionView::Helpers::FormBuilder` helper
-method][FormBuilder]'s last arguments are options (either `Hash` instances or
-[keyword arguments][]), they're omitted from the `arguments` array.
-
-If you want to pass-through all arguments, options, and block parameters, you
-can splat them out:
-
-```html+erb
-<%# app/views/form_builder/_label.html.erb %>
-
-<%= form.label(*arguments, **options, &block) %>
-```
-
-```html+erb
-<%# app/views/form_builder/_select.html.erb %>
-
-<%= form.select(*arguments, **html_options, &block) %>
-```
-
 #### Handling DOMTokenList attributes
 
 An [HTML element's `class` attribute][mdn-class] is treated by browsers as a
@@ -158,16 +135,12 @@ When rendering a field's DOMTokenList-backed attributes (like `class` or
 controllers][stimulus-controller]), transforming and combining singular `String`
 instances into lists of token can be very useful.
 
-To simplify those scenarios, a partial's template-local optional attributes are
-made available with the `#merge_token_lists` method.
-
 These optional attributes are available through the `options` or `html_options`
 partial-local variables. Their name will depend on the partial's corresponding
 [`ActionView::Helpers::FormBuilder`][FormBuilder] interface.
 
-Calls to `#merge_token_lists` will merge the key-value pairs and return a new
-Hash-like structure. The attribute's value will be transformed into an `Array`.
-Given call to `form.text_field` and a corresponding partial declaration:
+To "merge" attributes together, you can combine Ruby's `String` interpolation
+and `Hash#delete`:
 
 ```html+erb
   <%# app/views/users/new.html.erb %>
@@ -177,7 +150,11 @@ Given call to `form.text_field` and a corresponding partial declaration:
 
 <# app/views/form_builder/_text_field.html.erb %>
 
-<%= form.text_field(*arguments, **options.merge_token_lists(class: "text-field")) %>
+<%= form.text_field(
+  method,
+  class: "text-field #{options.delete(:class)}",
+  **options
+) %>
 ```
 
 The resulting HTML `<input>` element will merge have its [`class`
@@ -192,7 +169,6 @@ values:
 [button]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html#method-i-button
 [local_assigns]: https://api.rubyonrails.org/classes/ActionView/Template.html#method-i-local_assigns
 [splat]: https://ruby-doc.org/core-2.2.0/doc/syntax/calling_methods_rdoc.html#label-Array+to+Arguments+Conversion
-[keyword arguments]: https://thoughtbot.com/blog/ruby-2-keyword-arguments
 [mdn-class]: https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class
 [DOMTokenList]: https://developer.mozilla.org/en-US/docs/Web/API/DOMTokenList
 [classList]: https://developer.mozilla.org/en-US/docs/Web/API/Element/classList
@@ -210,7 +186,7 @@ block-local `form` variable:
 ```erb
 <%# app/views/users/form_builder/_email_field.html.erb %>
 
-<%= form.default.email_field(*arguments, **options) %>
+<%= form.default.email_field(method, options) %>
 ```
 
 When passing a `model:` or `scope:` to calls to [`form_with`][form_with],
@@ -225,21 +201,128 @@ For example, when calling `form_with(model: User.new)`, a partial declared in
 <%# app/views/users/form_builder/_password_field.html.erb %>
 
 <div class="password-field-wrapper">
-  <%= form.password_field(*arguments, **options) %>
+  <%= form.password_field(method, options) %>
 </div>
 ```
 
-If you'd like to render a specific partial for a field, you can declare the name
-as the `partial:` option:
+If you'd like to render a specific partial for a field, make sure that you pass
+along the `form:` (along with any other partial-local variables) as part of the
+`render` call's `locals:` option:
+
 
 ```erb
 <%# app/views/users/new.html.erb %>
 
 <%= form_with(model: User.new) do |form| %>
-  <%= form.email_field(:email, partial: "emails/my_special_text_field") %>
+  <%= render("emails/my_special_email_field", {
+    form: form,
+    method: :email,
+    options: { class: "user-email" },
+  ) %>
 <% end %>
+
+<%# app/views/emails/_my_special_email_field.html.erb %>
+
+<%= form.email_field(
+  method,
+  class: "my-special-email #{options.delete(:class)},
+  **options
+) %>
 ```
 
+#### Composing partials
+
+Layering partials on top of one another can be useful to share foundational
+styles and configuration across your fields. For instance, consider an
+administrative interface that shares styles with a consumer facing site, but has
+additional bells and whistles.
+
+Declare the consumer facing inputs (in this example, `<input type="search">`):
+
+```html+erb
+<%# app/views/form_builder/_search_field.html.erb %>
+
+<%= form.search_field(
+  method,
+  class: "
+    search-field
+    #{options.delete(:class}
+  ",
+  "data-controller": "
+    input->search#executeQuery
+    #{options.delete(:"data-controller")}
+  ",
+  **options
+) %>
+```
+
+Then, declare the administrative interface's inputs, in terms of overriding the
+foundation built by the more general definitions:
+
+```html+erb
+<%# app/views/admin/form_builder/_search_field.html.erb %>
+
+<%= form.search_field(
+  method,
+  class: "
+    search-field--admin
+    #{options.delete(:class}
+  ",
+  "data-controller": "
+    focus->admin-search#clearResults
+    #{options.delete(:"data-controller")}
+  ",
+) %>
+```
+
+The rendered `admin/form_builder/search_field` partial combines options and
+arguments from both partials:
+
+```html
+<input
+  type="search"
+  class="
+    search-field
+    search-field--admin
+  "
+  data-controller="
+    input->search#executeQuery
+    focus->admin-search#clearResults
+  "
+>
+```
+
+When constructing fields within a `form_with(model: ...)` block, partials will
+use the `model:` instance's [`tableize`-d model name][tableize] to resolve
+partials.
+
+For example, `posts/form_builder/_text_field.html.erb` will be resolved ahead of
+`form_builder/_text_field.html.erb`:
+
+```html+erb
+<%# app/views/posts/form_builder/_text_field.html.erb %>
+
+<%= form.text_field(method, class: "post-text #{options.delete(:class)}", **options) %>
+
+<%# app/views/application/form_builder/_text_field.html.erb %>
+
+<%= form.text_field(method, class: "text #{options.delete(:class)}", **options) %>
+```
+
+The rendered `posts/form_builder/text_field` partial could combine options and
+arguments from both partials:
+
+```html
+<input type="text" class="post-text text">
+```
+
+Models declared within modules will be delimited with `/`. For example,
+`Special::Post` instances would first resolve partials within the
+`app/views/special/posts/form_builder` directory, before falling back to
+`app/views/application/form_builder`.
+
+[tableize]: https://api.rubyonrails.org/classes/String.html#method-i-tableize
+
 ### Configuration
 
 View partials lookup and resolution will be scoped to the

data/lib/view_partial_form_builder/form_builder.rb

@@ -1,4 +1,4 @@
-require "view_partial_form_builder/lookup_context"
+require "view_partial_form_builder/lookup_override"
 require "view_partial_form_builder/html_attributes"
 
 module ViewPartialFormBuilder
@@ -14,9 +14,9 @@ module ViewPartialFormBuilder
         @template,
         options,
       )
-      @lookup_context = LookupContext.new(
-        overridden_context: @template.lookup_context,
-        object_name: object_name,
+      @lookup_override = LookupOverride.new(
+        prefixes: @template.lookup_context.prefixes,
+        object_name: object&.model_name || object_name,
         view_partial_directory: ViewPartialFormBuilder.view_partial_directory,
       )
     end
@@ -173,6 +173,17 @@ module ViewPartialFormBuilder
       render_partial("time_zone_select", locals, fallback: -> { super })
     end
 
+    def date_select(method, options = {}, **html_options)
+      locals = {
+        method: method,
+        options: options,
+        html_options: HtmlAttributes.new(html_options),
+        arguments: [method, options, html_options],
+      }
+
+      render_partial("date_select", locals, fallback: -> { super })
+    end
+
     def hidden_field(method, **options)
       @emitted_hidden_id = true if method == :id
 
@@ -247,50 +258,90 @@ module ViewPartialFormBuilder
 
     private
 
-    attr_reader :lookup_context
-
     def render_partial(field, locals, fallback:, &block)
-      return fallback.call if about_to_recurse_infinitely?(field)
-
       options = locals.fetch(:options, {})
       partial_override = options.delete(:partial)
-      locals = objectify_options(options).merge(locals, form: self)
-
-      lookup_context.override do
-        if partial_override.present?
-          render(partial_override, locals, &block)
-        elsif partial_exists?(field)
-          render(field, locals, &block)
-        else
-          fallback.call
-        end
+      options_as_locals = objectify_options(options)
+      locals = DeprecatedHash.new(
+        options_as_locals.merge(locals, form: self),
+        deprecated_keys: options_as_locals.keys + [:arguments],
+      )
+
+      partial = if partial_override.present?
+        ActiveSupport::Deprecation.new("0.2.0", "ViewPartialFormBuilder").warn(<<~WARNING)
+          Providing a `partial:` option for a form field is deprecated.
+        WARNING
+
+        find_partial(partial_override, locals, prefixes: [])
+      else
+        find_partial(field, locals, prefixes: prefixes_after(field))
+      end
+
+      if partial.nil? || about_to_recurse_infinitely?(partial)
+        fallback.call
+      else
+        partial.render(@template, locals, &block)
       end
     end
 
-    def partial_exists?(template_name)
+    def find_partial(template_name, locals, prefixes:)
       template_is_partial = true
 
-      lookup_context.template_exists?(
+      @template.lookup_context.find_all(
         template_name,
-        lookup_context.prefixes,
+        prefixes,
         template_is_partial,
-      )
+        locals.keys,
+      ).first.tap do |partial|
+        root_directory = ViewPartialFormBuilder.view_partial_directory
+
+        if partial&.virtual_path == "#{root_directory}/_#{template_name}"
+          ActiveSupport::Deprecation.new("0.2.0", "ViewPartialFormBuilder").warn(<<~WARNING.strip)
+            Declare root-level partials in app/views/application/#{root_directory}/, not app/views/#{root_directory}/.
+          WARNING
+        end
+      end
+    end
+
+    def prefixes_after(template_name)
+      prefixes = @lookup_override.prefixes
+      current_prefix = current_virtual_path.delete_suffix("/_#{template_name}")
+
+      if prefixes.include?(current_prefix)
+        prefixes.from(prefixes.index(current_prefix).to_i + 1)
+      else
+        prefixes
+      end
+    end
+
+    def about_to_recurse_infinitely?(partial)
+      partial.virtual_path == current_virtual_path
     end
 
-    def render(partial_name, locals, &block)
-      if block.present?
-        @template.render(layout: partial_name, locals: locals, &block)
+    def current_virtual_path
+      if (current_template = @template.instance_values["current_template"])
+        current_template.virtual_path.to_s
       else
-        @template.render(partial: partial_name, locals: locals)
+        @template.instance_values["virtual_path"].to_s
       end
     end
+  end
 
-    def about_to_recurse_infinitely?(field)
-      @template.instance_eval do
-        *, partial = @virtual_path.split("/")
+  class DeprecatedHash < Hash
+    def initialize(hash, deprecated_keys: [])
+      super()
+      merge!(hash)
+      @deprecated_keys = deprecated_keys
+    end
 
-        partial == "_#{field}"
+    def [](key)
+      if @deprecated_keys.include?(key)
+        ActiveSupport::Deprecation.new("0.2.0", "ViewPartialFormBuilder").warn <<~WARNING
+          Accessing `#{key}` from partials is deprecated.
+        WARNING
       end
+
+      super
     end
   end
 end

data/lib/view_partial_form_builder/html_attributes.rb

@@ -1,5 +1,13 @@
 module ViewPartialFormBuilder
   class HtmlAttributes
+    deprecate merge_token_lists: <<~'WARNING', deprecator: ActiveSupport::Deprecation.new("0.2.0", "ViewPartialFormBuilder")
+
+      As an alternative, merge arguments through String interpolation:
+
+      <%= form.label(method, class: "label #{options.delete(:class)}", **options) %>
+
+    WARNING
+
     def initialize(**attributes)
       @attributes = attributes
     end

data/lib/view_partial_form_builder/{lookup_context.rb → lookup_override.rb}

@@ -1,29 +1,12 @@
 module ViewPartialFormBuilder
-  class LookupContext
-    delegate_missing_to :overridden_context
-
-    def initialize(overridden_context:, object_name:, view_partial_directory:)
-      @object_name = object_name.to_s.pluralize
-      @overridden_context = overridden_context
-      @prefixes = overridden_context.prefixes.dup.freeze
+  class LookupOverride
+    def initialize(prefixes:, object_name:, view_partial_directory:)
+      @object_name = object_name.to_s.tableize
+      @prefixes = prefixes
       @view_partial_directory = view_partial_directory
     end
 
-    def override(&block)
-      previous_prefixes = overridden_context.prefixes
-
-      overridden_context.prefixes = prefix_overrides
-
-      yield
-    ensure
-      overridden_context.prefixes = previous_prefixes
-    end
-
-    private
-
-    attr_reader :overridden_context, :object_name, :view_partial_directory
-
-    def prefix_overrides
+    def prefixes
       *overridden_prefixes, root_prefix = @prefixes.dup
 
       prefixes = [
@@ -49,5 +32,9 @@ module ViewPartialFormBuilder
 
       prefixes.uniq
     end
+
+    private
+
+    attr_reader :object_name, :view_partial_directory
   end
 end

data/lib/view_partial_form_builder/version.rb

@@ -1,3 +1,3 @@
 module ViewPartialFormBuilder
-  VERSION = '0.1.0'
+  VERSION = '0.1.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: view_partial_form_builder
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.5
 platform: ruby
 authors:
 - Sean Doyle
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-12 00:00:00.000000000 Z
+date: 2020-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionview
@@ -94,7 +94,7 @@ files:
 - lib/view_partial_form_builder/engine.rb
 - lib/view_partial_form_builder/form_builder.rb
 - lib/view_partial_form_builder/html_attributes.rb
-- lib/view_partial_form_builder/lookup_context.rb
+- lib/view_partial_form_builder/lookup_override.rb
 - lib/view_partial_form_builder/version.rb
 homepage: https://github.com/seanpdoyle/view_partial_form_builder
 licenses: