view_partial_form_builder 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e30eab928ee84a6217afbabc1c746aa7a7906efa5417fc323f6b78e476aa3fbb
+  data.tar.gz: 21af6978419ac00cebba9989b86943eb2d4d102397d880cee50acb8a7ef11c7c
+SHA512:
+  metadata.gz: 848d4ddf155cb750a63400e9a5aaa3ea062a4d01b3041294c6ddbf64c3570882e28052d6b55066c731320daae6b43e7fa53c47f1a89924603bab50c3ba3885be
+  data.tar.gz: 05e69629609a81b0563bc5a234c3305dc0355e6f0b458d6aea41e75d49009d26a1e274a9ce7e4ccf6b50aa4ff90afa79c30220f44d97a4c754d9988fd9476046

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Sean Doyle
+
+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,277 @@
+# ViewPartialFormBuilder
+
+Construct `<form>` elements and their fields by combining
+[`ActionView::Helpers::FormBuilder`][FormBuilder] with [Rails View
+Partials][partials].
+
+[FormBuilder]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormBuilder.html
+[partials]: https://api.rubyonrails.org/classes/ActionView/PartialRenderer.html
+
+## Usage
+
+### Building the Form
+
+First, render a `<form>` element with [`form_with`][form_with] the necessary
+fields:
+
+```html+erb
+<%# app/views/users/new.html.erb %>
+
+<%= form_with(model: user) do |form| %>
+  <%= form.label(:name) %>
+  <%= form.text_field(:name, class: "text-field", required: true) %>
+
+  <%= form.label(:email) %>
+  <%= form.email_field(:email, class: "text-field text-field--large", required: true) %>
+
+  <%= form.label(:password) %>
+  <%= form.password_field(:email, class: "text-field",  required: true) %>
+
+  <%= form.button(class: "button button--primary") %>
+<% end %>
+```
+
+### Declaring the Fields' View Partials
+
+Next, declare view partials that correspond to the [`FormBuilder`][FormBuilder]
+helper method you'd like to have more control over:
+
+```html+erb
+<%# app/views/form_builder/_text_field.html.erb %>
+
+<input
+  type="text"
+  name="<%= form.object_name %>[<%= method %>]"
+  class="text-field"
+<% options.each do |attribute, value| %>
+  <%= attribute %>="<%= value %>"
+<% end %>
+>
+
+<%# app/views/form_builder/_email_field.html.erb %>
+
+<input
+  type="email"
+  name="<%= form.object_name %>[<%= method %>]"
+  class="text-field text-field--large"
+<% options.each do |attribute, value| %>
+  <%= attribute %>="<%= value %>"
+<% end %>
+>
+
+<%# app/views/form_builder/_button.html.erb %>
+
+<button
+  class="button button--primary"
+<% options.each do |attribute, value| %>
+  <%= attribute %>="<%= value %>"
+<% end %>
+>
+  <%= value %>
+</button>
+```
+
+You'll have local access to the `FormBuilder` instance as the template-local
+`form` variable. You can mix and match between declaring HTML elements, and
+generating HTML through Rails' helpers:
+
+```html+erb
+<%# app/views/form_builder/_email_field.html.erb %>
+
+<div class="email-field-wrapper">
+  <%= form.email_field(method, required: true, **options)) %>
+</div>
+```
+
+```html+erb
+<%# app/views/form_builder/_button.html.erb %>
+
+<div class="button-wrapper">
+  <%= form.button(*arguments, **options, &block) %>
+</div>
+```
+
+Templates with calls to [`FormBuilder#fields`][fields] and
+[`FormBuilder::fields_for`][fields_for] will yield instances of
+`ViewPartialFormBuilder` as block arguments.
+
+With the exception of `fields` and `fields_for`, view partials for all other
+[`FormBuilder` field methods][FormBuilder] can be declared.
+
+When a partial for a helper method is not declared, `ViewPartialFormBuilder`
+will fall back to the default helper method's behavior.
+
+[fields]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-fields
+[fields_for]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-fields_for
+
+### Arguments
+
+Every view partial has access to the arguments it was invoked with. For example,
+the [`FormBuilder#button`][button] accepts two arguments: `method` and `value`.
+Arguments are made available as partial-local variables (along with key-value
+pairs in the [`local_assigns`][local_assigns]).
+
+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
+[`DOMTokenList`][DOMTokenList]:
+
+> set of space-separated tokens. Such a set is returned by
+> [`Element.classList`][classList], ...
+> [`HTMLAnchorElement.relList`][relList]...
+>
+> It is indexed beginning with `0` as with JavaScript Array objects.
+> `DOMTokenList` is always case-sensitive.
+
+When rendering a field's DOMTokenList-backed attributes (like `class` or
+[`"data-controller"` when specifying StimulusJS
+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:
+
+```html+erb
+  <%# app/views/users/new.html.erb %>
+<%= form_with(model: post) do |form| %>
+  <%= form.text_field(:name, class: "text-field--modifier") %>
+<% end %>
+
+<# app/views/form_builder/_text_field.html.erb %>
+
+<%= form.text_field(*arguments, **options.merge_token_lists(class: "text-field")) %>
+```
+
+The resulting HTML `<input>` element will merge have its [`class`
+attribute][mdn-class] set to a list containing both sets of ERB-side `class:`
+values:
+
+```html
+<input type="text" name="post[name]" class="text-field text-field--modifier">
+```
+
+[form_with]: https://api.rubyonrails.org/classes/ActionView/Helpers/FormHelper.html#method-i-form_with
+[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
+[relList]: https://developer.mozilla.org/en-US/docs/Web/API/HTMLAnchorElement/relList
+[stimulus-controller]: https://stimulusjs.org/reference/controllers#identifiers
+
+### Rendering the Fields
+
+The fields' view partial files behave like any other: their contents will be
+used to populate the original call-site.
+
+To opt-out of view partial rendering for a field, first call `#default` on the
+block-local `form` variable:
+
+```erb
+<%# app/views/users/form_builder/_email_field.html.erb %>
+
+<%= form.default.email_field(*arguments, **options) %>
+```
+
+When passing a `model:` or `scope:` to calls to [`form_with`][form_with],
+a pluralized version of the FormBuilder's object name will be prepended to the
+look up path.
+
+For example, when calling `form_with(model: User.new)`, a partial declared in
+`app/views/users/form_builder/` would take precedent over a partial declared in
+`app/views/form_builder/`.
+
+```erb
+<%# app/views/users/form_builder/_password_field.html.erb %>
+
+<div class="password-field-wrapper">
+  <%= form.password_field(*arguments, **options) %>
+</div>
+```
+
+If you'd like to render a specific partial for a field, you can declare the name
+as the `partial:` 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") %>
+<% end %>
+```
+
+### Configuration
+
+View partials lookup and resolution will be scoped to the
+`app/views/form_builder` directory.
+
+To override this destination to another directory (for example,
+`app/views/fields`, or `app/views/users/fields`), set
+`ViewPartialFormBuilder.view_partial_directory`:
+
+```ruby
+# config/initializers/view_partial_form_builder.rb
+ViewPartialFormBuilder.view_partial_directory = "fields"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'view_partial_form_builder'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ViewPartialFormBuilder'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/lib/view_partial_form_builder.rb

@@ -0,0 +1,5 @@
+require "view_partial_form_builder/engine"
+
+module ViewPartialFormBuilder
+  mattr_accessor :view_partial_directory, default: "form_builder"
+end

data/lib/view_partial_form_builder/engine.rb

@@ -0,0 +1,9 @@
+require "view_partial_form_builder/form_builder"
+
+module ViewPartialFormBuilder
+  class Engine < ::Rails::Engine
+    ActiveSupport.on_load(:action_controller_base) do
+      default_form_builder ViewPartialFormBuilder::FormBuilder
+    end
+  end
+end

data/lib/view_partial_form_builder/form_builder.rb

@@ -0,0 +1,296 @@
+require "view_partial_form_builder/lookup_context"
+require "view_partial_form_builder/html_attributes"
+
+module ViewPartialFormBuilder
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    attr_reader :default
+
+    def initialize(*)
+      super
+
+      @default = ActionView::Helpers::FormBuilder.new(
+        object_name,
+        object,
+        @template,
+        options,
+      )
+      @lookup_context = LookupContext.new(
+        overridden_context: @template.lookup_context,
+        object_name: object_name,
+        view_partial_directory: ViewPartialFormBuilder.view_partial_directory,
+      )
+    end
+
+    def label(method, text = nil, **options, &block)
+      locals = {
+        method: method,
+        text: text,
+        options: HtmlAttributes.new(options),
+        block: block,
+        arguments: [method, text],
+      }
+
+      render_partial("label", locals, fallback: -> { super }, &block)
+    end
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      locals = {
+        method: method,
+        options: HtmlAttributes.new(options),
+        checked_value: checked_value,
+        unchecked_value: unchecked_value,
+        arguments: [method, options, checked_value, unchecked_value],
+      }
+
+      render_partial("check_box", locals, fallback: -> { super })
+    end
+
+    def radio_button(method, tag_value, **options)
+      locals = {
+        method: method,
+        tag_value: tag_value,
+        options: HtmlAttributes.new(options),
+        arguments: [method, tag_value],
+      }
+
+      render_partial("radio_button", locals, fallback: -> { super })
+    end
+
+    def select(method, choices = nil, options = {}, **html_options, &block)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        choices: choices,
+        options: options,
+        html_options: HtmlAttributes.new(html_options),
+        block: block,
+        arguments: [method, choices, options],
+      }
+
+      render_partial("select", locals, fallback: -> { super }, &block)
+    end
+
+    def collection_select(method, collection, value_method, text_method, options = {}, **html_options)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        collection: collection,
+        value_method: value_method,
+        text_method: text_method,
+        options: options,
+        html_options: html_options,
+        arguments: [method, collection, value_method, text_method, options],
+      }
+
+      render_partial("collection_select", locals, fallback: -> { super })
+    end
+
+    def collection_check_boxes(method, collection, value_method, text_method, options = {}, **html_options, &block)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        collection: collection,
+        value_method: value_method,
+        text_method: text_method,
+        options: options,
+        html_options: HtmlAttributes.new(html_options),
+        block: block,
+        arguments: [
+          method,
+          collection,
+          value_method,
+          text_method,
+          options,
+        ],
+      }
+
+      render_partial("collection_check_boxes", locals, fallback: -> { super }, &block)
+    end
+
+    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, **html_options, &block)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        collection: collection,
+        value_method: value_method,
+        text_method: text_method,
+        options: options,
+        html_options: HtmlAttributes.new(html_options),
+        block: block,
+        arguments: [
+          method,
+          collection,
+          value_method,
+          text_method,
+          options,
+        ],
+      }
+
+      render_partial("collection_radio_buttons", locals, fallback: -> { super }, &block)
+    end
+
+    def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, **html_options)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        collection: collection,
+        group_method: group_method,
+        group_label_method: group_label_method,
+        option_key_method: option_key_method,
+        option_value_method: option_value_method,
+        html_options: HtmlAttributes.new(html_options),
+        options: options,
+        arguments: [
+          method,
+          collection,
+          group_method,
+          group_label_method,
+          option_key_method,
+          option_value_method,
+          options,
+        ],
+      }
+
+      render_partial("grouped_collection_select", locals, fallback: -> { super })
+    end
+
+    def time_zone_select(method, priority_zones = nil, options = {}, **html_options)
+      html_options = @default_html_options.merge(html_options)
+
+      locals = {
+        method: method,
+        priority_zones: priority_zones,
+        html_options: HtmlAttributes.new(html_options),
+        options: options,
+        arguments: [method, priority_zones, options],
+      }
+
+      render_partial("time_zone_select", locals, fallback: -> { super })
+    end
+
+    def hidden_field(method, **options)
+      @emitted_hidden_id = true if method == :id
+
+      locals = {
+        method: method,
+        options: HtmlAttributes.new(options),
+        arguments: [method],
+      }
+
+      render_partial("hidden_field", locals, fallback: -> { super })
+    end
+
+    def file_field(method, **options)
+      self.multipart = true
+
+      locals = {
+        method: method,
+        options: HtmlAttributes.new(options),
+        arguments: [method],
+      }
+
+      render_partial("file_field", locals, fallback: -> { super })
+    end
+
+    def submit(value = nil, **options)
+      value, options = nil, value if value.is_a?(Hash)
+      value ||= submit_default_value
+
+      locals = {
+        value: value,
+        options: HtmlAttributes.new(options),
+        arguments: [value],
+      }
+
+      render_partial("submit", locals, fallback: -> { super })
+    end
+
+    def button(value = nil, **options)
+      value, options = nil, value if value.is_a?(Hash)
+      value ||= submit_default_value
+
+      locals = {
+        value: value,
+        options: HtmlAttributes.new(options),
+        arguments: [value],
+      }
+
+      render_partial("button", locals, fallback: -> { super })
+    end
+
+    DYNAMICALLY_DECLARED = (
+      field_helpers +
+      [:rich_text_area] -
+      [:label, :check_box, :radio_button, :fields_for, :fields, :hidden_field, :file_field]
+    )
+
+    DYNAMICALLY_DECLARED.each do |selector|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{selector}(method, **options)
+          render_partial(
+            "#{selector}",
+            {
+              method: method,
+              options: HtmlAttributes.new(options),
+              arguments: [method],
+            },
+            fallback: -> { super },
+          )
+        end
+      RUBY
+    end
+
+    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
+      end
+    end
+
+    def partial_exists?(template_name)
+      template_is_partial = true
+
+      lookup_context.template_exists?(
+        template_name,
+        lookup_context.prefixes,
+        template_is_partial,
+      )
+    end
+
+    def render(partial_name, locals, &block)
+      if block.present?
+        @template.render(layout: partial_name, locals: locals, &block)
+      else
+        @template.render(partial: partial_name, locals: locals)
+      end
+    end
+
+    def about_to_recurse_infinitely?(field)
+      @template.instance_eval do
+        *, partial = @virtual_path.split("/")
+
+        partial == "_#{field}"
+      end
+    end
+  end
+end

data/lib/view_partial_form_builder/html_attributes.rb

@@ -0,0 +1,47 @@
+module ViewPartialFormBuilder
+  class HtmlAttributes
+    def initialize(**attributes)
+      @attributes = attributes
+    end
+
+    def merge_token_lists(**token_list_attributes)
+      merge(
+        token_list_attributes.reduce({}) do |merged, (key, value)|
+          token_list = Array(attributes.delete(key)).unshift(value)
+
+          merged.merge(key => token_list.flatten.uniq)
+        end
+      )
+    end
+
+    def to_h
+      attributes.to_h
+    end
+
+    def to_hash
+      attributes.to_hash
+    end
+
+    def method_missing(method_name, *arguments, &block)
+      if attributes.respond_to?(method_name)
+        return_value = attributes.public_send(method_name, *arguments, &block)
+
+        if return_value.kind_of?(Hash)
+          HtmlAttributes.new(return_value)
+        else
+          return_value
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      attributes.respond_to?(method_name) || super
+    end
+
+    private
+
+    attr_reader :attributes
+  end
+end

data/lib/view_partial_form_builder/lookup_context.rb

@@ -0,0 +1,53 @@
+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
+      @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
+      *overridden_prefixes, root_prefix = @prefixes.dup
+
+      prefixes = [
+        "#{object_name}/#{view_partial_directory}",
+        object_name,
+        view_partial_directory,
+        "#{root_prefix}/#{view_partial_directory}",
+        root_prefix,
+      ]
+
+      overridden_prefixes.reverse_each do |prefix|
+        namespace, *files = prefix.split("/")
+
+        prefixes.unshift(prefix)
+
+        if namespace.present?
+          prefixes.unshift("#{namespace}/#{view_partial_directory}")
+        end
+
+        prefixes.unshift("#{prefix}/#{view_partial_directory}")
+      end
+
+
+      prefixes.uniq
+    end
+  end
+end

data/lib/view_partial_form_builder/version.rb

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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: view_partial_form_builder
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sean Doyle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: minitest-around
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord-nulldb-adapter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Rails form builder where all designer-facing configuration is via templates.
+email:
+- sean.p.doyle24@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/view_partial_form_builder.rb
+- 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/version.rb
+homepage: https://github.com/seanpdoyle/view_partial_form_builder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Construct <form> element fields by combining ActionView::Helpers::FormBuilder
+  with Rails View Partials
+test_files: []