poetry-simple_form 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 938d26d4ca15b34d244fdc9d37b32310d8bab58ada91a2e53f097649d74ddbb8
+  data.tar.gz: 989eb21341bad9296b31e74f4c62410930db2d5350aef9da3bba7c45c9b21749
+SHA512:
+  metadata.gz: ba8eac52747366e0d54c09ca3c4bb293a155ffed98bdcb7bacbff33d0502d433ad8136eed3f39898989696c9ca48800eb45e65b3740b9a576df2ef8f1ae4937e
+  data.tar.gz: 3ce40235c63fbf05532db9d055de1e7aa19e844fe29b309ea453c5d9852e73b594106a218cdc3bd551ac6460ee9fce4ee069202bc3334631576ee68fa09f43fb

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# Changelog
+
+## [Unreleased]

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Matt Solt
+
+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,61 @@
+# poetry-simple_form
+
+The **migration bridge** from simple_form to poetry. One initializer re-maps
+simple_form's input types onto classes that render whole poetry Fields
+through `Poetry::Ui::FormBuilder` — existing `f.input` calls keep working,
+now with the quartet (label / hint / error / aria) derived from the model
+exactly like the native builder, because the shim renders *through* it.
+
+```ruby
+# Gemfile
+gem "poetry-simple_form"
+```
+
+```sh
+bin/rails g poetry:simple_form:install   # writes the one-line initializer
+```
+
+## What you get
+
+- `f.input` for string/email/url/tel/search/uuid/password/text/json/boolean/
+  numeric/range/date/time/file and the collection trio (select /
+  radio_buttons / check_boxes), plus grouped_select and time_zone, renders
+  poetry Fields: `aria-required` (never native), maxlength/min/max/step
+  from validations, errors wired via `aria-describedby`.
+- `f.association` works unchanged (simple_form fetches the records; the
+  shim's collection inputs render them as poetry pickers).
+- Every poetry form control is reachable by its poetry name through `as:`,
+  even the ones simple_form never had: `:switch`, `:slider`, `:otp`,
+  `:sensitive`, `:tag_group`, `:date_picker`, `:calendar`, `:combobox`,
+  `:autocomplete`, `:native_select`.
+- `required: true/false` overrides the model's presence inference; `label_method:`
+  and `value_method:` (symbols or callables) are honored on every collection
+  input, with simple_form's detection chain as the fallback.
+- Poetry-only options ride a `poetry:` hash - `f.input :active, poetry:
+  { switch: true }`, `f.input :code, as: :otp, poetry: { length: 4 }` -
+  merged last, so it wins over anything simple_form derived. `input_html`
+  still lands on the control (minus class and id, which the component owns).
+- `:datetime` renders poetry's DateTimeField (one datetime-local control,
+  local wall time on the wire). `:rich_text_area`, `:hidden`, and `:country`
+  fall back to stock simple_form rendering on purpose (no editor, nothing to
+  render, and a country list poetry does not carry).
+- Remove the initializer to restore stock rendering instantly.
+
+The full type-to-component table is `Poetry::SimpleForm::COVERAGE`; a
+parity test in this gem fails when a new poetry form control has no
+simple_form route, so the two vocabularies cannot drift apart.
+
+## What this is not
+
+Not the end state. The bridge exists so views can migrate to
+`form_with(model:, builder: Poetry::Ui::FormBuilder)` (and `f.input`
+there) at your own pace — see the poetry docs `/forms` guide. simple_form
+itself contributes only type resolution here; its wrapper tree is bypassed
+by design (a flat wrapper cannot express the Field quartet).
+
+Existing `simple_form.*` i18n keys (labels/hints/placeholders) keep
+working — poetry's builder reads them as a fallback chain.
+
+## License
+
+Available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/generators/poetry/simple_form/install/install_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Poetry
+  module SimpleForm
+    # The gem's Rails generators.
+    module Generators
+      # `rails g poetry:simple_form:install` - one initializer, the whole
+      # shim: activate! re-maps the input types and installs the
+      # passthrough wrapper. Delete the file to fall back to stock
+      # simple_form rendering.
+      class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path("templates", __dir__)
+
+        # Write config/initializers/poetry_simple_form.rb.
+        # @api private
+        def create_initializer
+          create_file "config/initializers/poetry_simple_form.rb", <<~RUBY_FILE
+            # poetry renders simple_form's inputs (the migration bridge):
+            # f.input keeps working while views move to
+            # form_with(builder: Poetry::Ui::FormBuilder). Remove this file
+            # to restore stock simple_form rendering.
+            Poetry::SimpleForm.activate!
+          RUBY_FILE
+        end
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    # The input classes the bridge maps simple_form's types onto.
+    module Inputs
+      # The shim's shared floor: every input renders through a
+      # Poetry::Ui::FormBuilder bound to the SAME object/template, so the
+      # poetry Field quartet (label/hint/error/aria) is byte-identical to
+      # the native-builder path - no duplicated derivation.
+      class Base < ::SimpleForm::Inputs::Base
+        # Render the attribute as a whole poetry Field through the bound
+        # Poetry::Ui::FormBuilder; the subclass's `poetry_as` pins the
+        # control type (nil lets poetry infer it).
+        #
+        # @param _wrapper_options [Hash, nil] unused - the Field owns its chrome
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.input(attribute_name, as: poetry_as, **poetry_options)
+        end
+
+        private
+
+        # Subclasses answer the poetry `as:` value (nil lets poetry infer).
+        def poetry_as = nil
+
+        def poetry_builder
+          Poetry::Ui::FormBuilder.new(object_name, object, template, {})
+        end
+
+        # simple_form option vocabulary -> poetry's: label/hint/placeholder
+        # pass through (false stays false-y as an omission), required:
+        # explicit override wins, input_html lands on the control minus the
+        # class string (poetry components own their classes; append via
+        # input_html: { class: } consciously with poetry_class:). A `poetry:`
+        # hash is the first-class channel for poetry-only options (switch:,
+        # length:, orientation:, ...) - merged last, so it wins.
+        def poetry_options
+          opts = input_html_options.except(:class, :id)
+          opts[:hint] = options[:hint] if options[:hint].is_a?(String)
+          label = options[:label].is_a?(String) ? options[:label] : translate_from_namespace(:labels)
+          opts[:label] = label if label.is_a?(String) # simple_form.labels.* keys, its own lookup chain
+          placeholder = options[:placeholder] || input_html_options[:placeholder]
+          opts[:placeholder] = placeholder if placeholder.is_a?(String)
+          opts[:required] = options[:required] if options.key?(:required) # explicit beats inference
+          opts.merge!(options[:poetry].to_h.transform_keys(&:to_sym)) if options[:poetry]
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/boolean_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # The horizontal boolean Field (poetry's f.input boolean story);
+      # input_html: { switch: true } opts into the setting-row Switch.
+      class BooleanInput < Base
+        private
+
+        def poetry_as = :boolean
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/collection_inputs.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # The collection floor: pairs from options[:collection] (both
+      # f.input(collection:) and f.association arrive here - association
+      # fetches the records first), label/value methods resolved with
+      # simple_form's own detection chain.
+      class CollectionBase < Base
+        private
+
+        def label_value_pairs(collection = Array(options[:collection]))
+          return [] if collection.empty?
+
+          sample = collection.first
+          label = options[:label_method]
+          value = options[:value_method]
+          if (sample.is_a?(Array) || !sample.respond_to?(:id)) && !(label || value)
+            collection.map { |item| item.is_a?(Array) ? item : [item.to_s, item] }
+          else
+            # simple_form's label_method:/value_method: (symbols or callables)
+            # win; otherwise its detection chain (name, title, to_s / id, to_s).
+            label ||= ::SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) }
+            value ||= ::SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) }
+            collection.map { |item| [read(item, label), read(item, value)] }
+          end
+        end
+
+        def read(item, method)
+          method.respond_to?(:call) ? method.call(item) : item.public_send(method)
+        end
+      end
+
+      # Serves `as: :select` (and f.association's default): a poetry Field
+      # wrapping the Select component; the hidden native <select> stays the
+      # serialization truth.
+      class CollectionSelectInput < CollectionBase
+        # Render the collection as a Field-wrapped Select;
+        # include_blank/prompt becomes the placeholder option.
+        #
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.poetry_select(attribute_name, label_value_pairs,
+                                       include_blank: options[:include_blank] || options[:prompt],
+                                       **poetry_options)
+        end
+      end
+
+      # Serves `as: :radio_buttons`: a poetry Field wrapping the
+      # RadioGroup component, one row per collection item.
+      class CollectionRadioButtonsInput < CollectionBase
+        # Render the collection as a Field-wrapped RadioGroup.
+        #
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          pairs = label_value_pairs.map { |label, value| [value, label] }
+          poetry_builder.radio_group(attribute_name, pairs, **poetry_options)
+        end
+      end
+
+      # Serves `as: :check_boxes`: a poetry Field wrapping the checkbox
+      # group - one Checkbox row per collection item, posting an array.
+      class CollectionCheckBoxesInput < CollectionBase
+        # Render the collection as a Field-wrapped checkbox group.
+        #
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          pairs = label_value_pairs.map { |label, value| [value, label] }
+          poetry_builder.checkbox_group(attribute_name, pairs, **poetry_options)
+        end
+      end
+
+      # Serves `as: :native_select`: a poetry Field wrapping the styled
+      # native <select> (the no-JS picker).
+      class NativeSelectInput < CollectionBase
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.native_select(attribute_name, label_value_pairs,
+                                       include_blank: options[:include_blank] || options[:prompt],
+                                       **poetry_options)
+        end
+      end
+
+      # Serves `as: :combobox`: a poetry Field wrapping the filterable Combobox.
+      class ComboboxInput < CollectionBase
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.poetry_combobox(attribute_name, label_value_pairs,
+                                         include_blank: options[:include_blank] || options[:prompt],
+                                         **poetry_options)
+        end
+      end
+
+      # Serves `as: :autocomplete`: a poetry Field wrapping the Autocomplete;
+      # the collection becomes its suggestions.
+      class AutocompleteInput < CollectionBase
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.autocomplete(attribute_name, label_value_pairs, **poetry_options)
+        end
+      end
+
+      # Serves `as: :grouped_select`: simple_form's group_method /
+      # group_label_method resolve the groups, poetry's Select renders them
+      # as labelled groups.
+      class GroupedCollectionSelectInput < CollectionBase
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.poetry_select(attribute_name, grouped_pairs,
+                                       include_blank: options[:include_blank] || options[:prompt],
+                                       **poetry_options)
+        end
+
+        private
+
+        # { "Group label" => [[label, value], ...] } in collection order.
+        def grouped_pairs
+          groups = options[:collection]
+          groups = groups.call if groups.respond_to?(:call)
+          group_method = options.fetch(:group_method)
+          Array(groups).to_h do |group|
+            [group_label_for(group).to_s, label_value_pairs(Array(group.public_send(group_method)))]
+          end
+        end
+
+        def group_label_for(group)
+          method = options[:group_label_method] ||
+                   ::SimpleForm.collection_label_methods.find { |m| group.respond_to?(m) }
+          method ? group.public_send(method) : group
+        end
+      end
+
+      # Serves `as: :time_zone`: every ActiveSupport::TimeZone in a poetry
+      # Select, the priority zones (priority: or SimpleForm.time_zone_priority)
+      # listed first.
+      class TimeZoneInput < CollectionBase
+        # @return [String] the rendered Field HTML
+        def input(_wrapper_options = nil)
+          poetry_builder.poetry_select(attribute_name, zone_pairs,
+                                       include_blank: options[:include_blank] || options[:prompt],
+                                       **poetry_options)
+        end
+
+        private
+
+        def zone_pairs
+          zones = ActiveSupport::TimeZone.all
+          priority = Array(options[:priority] || ::SimpleForm.time_zone_priority)
+          first = priority.filter_map do |zone|
+            zone.is_a?(ActiveSupport::TimeZone) ? zone : ActiveSupport::TimeZone[zone]
+          end
+          (first + (zones - first)).map { |zone| [zone.to_s, zone.name] }
+        end
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/custom_inputs.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # The poetry controls with no simple_form ancestor, each reachable by
+      # its poetry name: `f.input :active, as: :switch`. They are thin on
+      # purpose - the Field quartet and every option ride the shared Base.
+
+      # Serves `as: :switch`: a Field in the setting orientation wrapping the Switch.
+      class SwitchInput < Base
+        private
+
+        def poetry_as = :switch
+      end
+
+      # Serves `as: :slider` and simple_form's `:range`: a Field wrapping the Slider.
+      class SliderInput < Base
+        private
+
+        def poetry_as = :slider
+      end
+
+      # Serves `as: :otp`: a Field wrapping the InputOtp (length: via poetry:).
+      class OtpInput < Base
+        private
+
+        def poetry_as = :otp
+      end
+
+      # Serves `as: :sensitive`: a Field wrapping the masked, reveal-on-demand SensitiveInput.
+      class SensitiveInput < Base
+        private
+
+        def poetry_as = :sensitive
+      end
+
+      # Serves `as: :tag_group`: a Field wrapping the TagGroup.
+      class TagGroupInput < Base
+        private
+
+        def poetry_as = :tag_group
+      end
+
+      # Serves `as: :date_picker`: a Field wrapping the DatePicker (popover calendar).
+      class DatePickerInput < Base
+        private
+
+        def poetry_as = :date_picker
+      end
+
+      # Serves `as: :calendar`: a Field wrapping the inline Calendar.
+      class CalendarInput < Base
+        private
+
+        def poetry_as = :calendar
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/date_time_input.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # date -> DateField, time -> TimeField; :datetime falls back to
+      # poetry's own DateTimeField (one datetime-local control, no select trio).
+      class DateTimeInput < ::SimpleForm::Inputs::DateTimeInput
+        # Render :date/:time/:datetime attributes as poetry DateField /
+        # TimeField / DateTimeField - one control each, ISO on the wire.
+        #
+        # @return [String] the rendered HTML
+        def input(_wrapper_options = nil)
+          Poetry::Ui::FormBuilder.new(object_name, object, template, {})
+                                 .input(attribute_name, as: input_type)
+        end
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/file_input.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # Serves `as: :file`: a poetry Field wrapping the FileInput
+      # component (the native file control in poetry chrome; input_html
+      # options such as variant:/multiple: pass through).
+      class FileInput < Base
+        private
+
+        def poetry_as = :file
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/numeric_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # NumberField; poetry re-derives min/max/step from numericality, so
+      # the shim passes nothing simple_form computed.
+      class NumericInput < Base
+        private
+
+        def poetry_as = :number
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/password_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # Serves `as: :password`: a poetry Field wrapping a type=password
+      # Input; the value never round-trips into the markup.
+      class PasswordInput < Base
+        private
+
+        def poetry_as = :password
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/string_input.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # string/email/url/tel/search/citext: the resolved simple_form
+      # input_type IS poetry's as: vocabulary (citext folds to string).
+      class StringInput < Base
+        private
+
+        def poetry_as
+          # :string is simple_form's no-column fallback (ActiveModel,
+          # virtual attributes) - hand poetry a nil so ITS inference runs
+          # (type_for_attribute + name heuristics); a concretely resolved
+          # type passes through.
+          return nil if %i[string citext uuid].include?(input_type)
+
+          input_type
+        end
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs/text_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    module Inputs
+      # Serves `as: :text`: a poetry Field wrapping the Textarea
+      # component.
+      class TextInput < Base
+        private
+
+        def poetry_as = :text
+      end
+    end
+  end
+end

data/lib/poetry/simple_form/inputs.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "poetry/simple_form/inputs/base"
+require "poetry/simple_form/inputs/string_input"
+require "poetry/simple_form/inputs/password_input"
+require "poetry/simple_form/inputs/text_input"
+require "poetry/simple_form/inputs/boolean_input"
+require "poetry/simple_form/inputs/numeric_input"
+require "poetry/simple_form/inputs/date_time_input"
+require "poetry/simple_form/inputs/file_input"
+require "poetry/simple_form/inputs/collection_inputs"
+require "poetry/simple_form/inputs/custom_inputs"

data/lib/poetry/simple_form/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Poetry
+  module SimpleForm
+    # The gem version.
+    VERSION = "0.0.3"
+  end
+end

data/lib/poetry/simple_form.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "simple_form"
+require "poetry/simple_form/version"
+require "poetry/simple_form/inputs"
+
+# The Poetry namespace, shared by every gem in the family.
+module Poetry
+  # The simple_form migration bridge: one initializer re-maps simple_form's
+  # input types onto classes that render whole poetry Fields through
+  # Poetry::Ui::FormBuilder. Every f.input keeps working; every poetry form
+  # control is reachable by name through as:.
+  module SimpleForm
+    # simple_form input type => bridge input class. activate! installs
+    # exactly this table, so the coverage below cannot drift from it.
+    INPUTS = {
+      string: Inputs::StringInput, email: Inputs::StringInput, url: Inputs::StringInput,
+      tel: Inputs::StringInput, search: Inputs::StringInput, citext: Inputs::StringInput,
+      uuid: Inputs::StringInput,
+      password: Inputs::PasswordInput, sensitive: Inputs::SensitiveInput,
+      text: Inputs::TextInput, hstore: Inputs::TextInput, json: Inputs::TextInput, jsonb: Inputs::TextInput,
+      boolean: Inputs::BooleanInput, switch: Inputs::SwitchInput,
+      integer: Inputs::NumericInput, decimal: Inputs::NumericInput, float: Inputs::NumericInput,
+      range: Inputs::SliderInput, slider: Inputs::SliderInput,
+      date: Inputs::DateTimeInput, time: Inputs::DateTimeInput, datetime: Inputs::DateTimeInput,
+      date_picker: Inputs::DatePickerInput, calendar: Inputs::CalendarInput,
+      file: Inputs::FileInput, otp: Inputs::OtpInput, tag_group: Inputs::TagGroupInput,
+      select: Inputs::CollectionSelectInput, grouped_select: Inputs::GroupedCollectionSelectInput,
+      time_zone: Inputs::TimeZoneInput, native_select: Inputs::NativeSelectInput,
+      combobox: Inputs::ComboboxInput, autocomplete: Inputs::AutocompleteInput,
+      radio_buttons: Inputs::CollectionRadioButtonsInput, check_boxes: Inputs::CollectionCheckBoxesInput
+    }.freeze
+
+    # simple_form input type => the poetry component it renders (a registry
+    # key).
+    # The parity gate (test/poetry/simple_form/coverage_test.rb) checks this
+    # against every form-facing component in the registry.
+    COVERAGE = {
+      string: "input", email: "input", url: "input", tel: "input", citext: "input", uuid: "input",
+      password: "input", search: "search_field", sensitive: "sensitive_input",
+      text: "textarea", hstore: "textarea", json: "textarea", jsonb: "textarea",
+      boolean: "checkbox", switch: "switch",
+      integer: "number_field", decimal: "number_field", float: "number_field",
+      range: "slider", slider: "slider",
+      date: "date_field", time: "time_field", datetime: "date_time_field",
+      date_picker: "date_picker", calendar: "calendar",
+      file: "file_input", otp: "input_otp", tag_group: "tag_group",
+      select: "select", grouped_select: "select", time_zone: "select", native_select: "native_select",
+      combobox: "combobox", autocomplete: "autocomplete",
+      radio_buttons: "radio_group", check_boxes: "checkbox"
+    }.freeze
+
+    # simple_form types left to simple_form entirely, with the reason.
+    STOCK = {
+      rich_text_area: "poetry ships no rich-text editor",
+      hidden: "nothing to render",
+      country: "the country list comes from the country_select gem, which poetry does not depend on"
+    }.freeze
+
+    # Form-facing poetry components deliberately not reachable through a
+    # simple_form type, with the reason (empty today; the gate reads it).
+    BRIDGE_EXEMPT = {}.freeze
+
+    # Install the bridge: map every type in INPUTS and make the flat poetry
+    # wrapper the default (the Field owns its chrome, so the wrapper
+    # contributes only display: contents).
+    #
+    # @return [void]
+    def self.activate!
+      builder = ::SimpleForm::FormBuilder
+      INPUTS.each { |type, klass| builder.map_type type, to: klass }
+
+      ::SimpleForm.setup do |config|
+        config.wrappers :poetry, tag: :div, class: "contents" do |b|
+          b.use :input
+        end
+        config.default_wrapper = :poetry
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: poetry-simple_form
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Matt Solt
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: poetry-ui
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: simple_form
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+description: An opt-in shim that re-maps simple_form's input types onto Poetry's model-bound
+  Field components, so existing simple_form views keep working mid-migration. The
+  end state is Poetry::Ui::FormBuilder - this bridge exists to make getting there
+  boring.
+email:
+- mattsolt@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/generators/poetry/simple_form/install/install_generator.rb
+- lib/poetry/simple_form.rb
+- lib/poetry/simple_form/inputs.rb
+- lib/poetry/simple_form/inputs/base.rb
+- lib/poetry/simple_form/inputs/boolean_input.rb
+- lib/poetry/simple_form/inputs/collection_inputs.rb
+- lib/poetry/simple_form/inputs/custom_inputs.rb
+- lib/poetry/simple_form/inputs/date_time_input.rb
+- lib/poetry/simple_form/inputs/file_input.rb
+- lib/poetry/simple_form/inputs/numeric_input.rb
+- lib/poetry/simple_form/inputs/password_input.rb
+- lib/poetry/simple_form/inputs/string_input.rb
+- lib/poetry/simple_form/inputs/text_input.rb
+- lib/poetry/simple_form/version.rb
+homepage: https://poetryui.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://poetryui.com
+  documentation_uri: https://poetryui.com/docs
+  source_code_uri: https://github.com/roboruby/poetry-simple_form
+  changelog_uri: https://github.com/roboruby/poetry-simple_form/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/roboruby/poetry-simple_form/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: 'The simple_form migration bridge for Poetry: f.input renders Poetry Fields.'
+test_files: []