phlex-forms 0.1.0

data/lib/forms/wrapped_input.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Forms
+  # The daisyui v5 "text/icon inside the field" pattern: a `<label class="input">`
+  # wrapper that owns the visual styling, with leading/trailing content (icons,
+  # kbd hints, a text prefix) rendered as siblings of a bare `<input>`.
+  #
+  #   f.field(:search).wrapped_input(:primary) do
+  #     _lucide("search")             # or any leading content
+  #   end
+  #
+  # The yielded block renders *before* the input (leading slot); pass `trailing:`
+  # for content after it. The input itself is bare (no `input` class) since the
+  # wrapping label carries it — this is the daisyui v5 convention.
+  class WrappedInput < Phlex::HTML
+    include PhlexForms::DelegatedField
+
+    def initialize(*modifiers, type: "text", name: nil, id: nil, value: nil,
+                   placeholder: nil, error: false, disabled: false, required: false,
+                   trailing: nil, **attributes)
+      @modifiers = normalize_modifiers(modifiers)
+      @type = type
+      @name = name
+      @id = id
+      @value = value
+      @placeholder = placeholder
+      @error = error
+      @disabled = disabled
+      @required = required
+      @trailing = trailing
+      @full_width = true
+      @attributes = attributes
+      super()
+    end
+
+    def view_template(&leading)
+      render DaisyUI::Label.new(:input, *daisy_modifiers, class: width_class) do
+        leading&.call
+        input(**bare_input_attributes)
+        render_trailing
+      end
+    end
+
+    private
+
+    def bare_input_attributes
+      attrs = {
+        type: @type,
+        name: @name,
+        id: @id,
+        value: @value.to_s,
+        placeholder: @placeholder,
+        class: "grow",
+        **@attributes.except(:error, :value, :class)
+      }
+      attrs[:disabled] = true if @disabled
+      attrs[:required] = true if @required
+      attrs.compact
+    end
+
+    def render_trailing
+      return unless @trailing
+
+      @trailing.respond_to?(:call) ? @trailing.call : plain(@trailing)
+    end
+  end
+end

data/lib/phlex-forms.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Allow `require "phlex-forms"` (dashed) as well as `require "phlex_forms"`.
+require_relative "phlex_forms"

data/lib/phlex_forms/builder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # The shared form-builder surface, included by Forms::Form, Forms::Field, and
+  # Forms::FieldsForBuilder so the three no longer copy-paste the API three times.
+  #
+  # Two layers:
+  #
+  #   * The Control-first primary verb `field` — renders label + input +
+  #     error/hint in one call, inferring the input type and the `required` flag
+  #     from the model.
+  #
+  #   * Lower-level escape hatches (`Input`, `Select`, `Textarea`, `Checkbox`,
+  #     `Toggle`, `FileInput`, `Hidden`, `Label`, `Control`, `submit`) with the
+  #     same signatures they had before extraction, for when a caller needs full
+  #     control (custom Stimulus wiring, bespoke layout, ...).
+  #
+  # Hosts mix this in and provide: `render`, `model`, `scope`, `errors`, and a
+  # `field(name)`-style `field_object` that returns a Forms::Field for a name.
+  module Builder
+    # Positional symbols that name an input type (so `f.Input(:x, :email)` works).
+    INPUT_TYPE_MODIFIERS = %i[
+      text email password tel url search number date time datetime
+      color range file hidden month week
+    ].freeze
+
+    # Attribute-name -> input type inference. One canonical map (previously
+    # duplicated and divergent across Form and Field).
+    INPUT_TYPE_INFERENCE = {
+      email: :email,
+      password: :password, password_confirmation: :password,
+      current_password: :password, new_password: :password,
+      new_password_confirmation: :password,
+      phone: :tel, telephone: :tel, tel: :tel, mobile: :tel,
+      url: :url, website: :url, homepage: :url,
+      search: :search, query: :search,
+      date: :date, birthday: :date, birthdate: :date, born_on: :date,
+      started_at: :date, ended_at: :date,
+      time: :time,
+      datetime: :datetime, timestamp: :datetime,
+      color: :color, colour: :color
+    }.freeze
+
+    # ------------------------------------------------------------------
+    # Control-first primary API
+    # ------------------------------------------------------------------
+
+    # Render a complete field: label + control-wrapped input + error/hint.
+    #
+    #   f.field :email                          # type=email, label auto, required inferred
+    #   f.field :role, as: :select, choices: roles
+    #   f.field :bio, as: :textarea, rows: 6
+    #   f.field :accept, as: :toggle
+    #   f.field :name, :primary, label: "Full name", hint: "As on your ID"
+    #
+    # Options:
+    #   label:    label text (defaults to the model's humanized attribute name;
+    #             pass false to omit the label)
+    #   hint:     help text shown when there is no error
+    #   as:       override the rendered control (:select, :textarea, :toggle,
+    #             :checkbox, :file, :hidden, and text-like types)
+    #   required: force the required flag (otherwise inferred from validations)
+    #   choices:  choices for :select
+    # Remaining positional modifiers/keywords pass through to the inner input.
+    def field(name, *modifiers, label: nil, hint: nil, as: nil, required: nil,
+              choices: nil, **options)
+      fo = field_object(name)
+      req = required.nil? ? fo.required? : required
+      label_text = label == false ? nil : (label || fo.field_label)
+      options = fo.apply_validations(options)
+
+      render fo.control(label: label_text, hint:, required: req) do
+        render_field_input(fo, name, as, modifiers, choices:, required: req, **options)
+      end
+    end
+
+    # ------------------------------------------------------------------
+    # Escape-hatch component API (stable signatures)
+    # ------------------------------------------------------------------
+
+    def Input(name, *modifiers, **options)
+      fo = field_object(name)
+      type = resolve_input_type(name, modifiers)
+      type = :"datetime-local" if type == :datetime
+      remaining = modifiers - INPUT_TYPE_MODIFIERS
+      render fo.input(*remaining, type:, **fo.apply_validations(options))
+    end
+
+    def Select(name, *modifiers, choices: nil, **options)
+      fo = field_object(name)
+      render fo.choices_select(choices, *modifiers, **fo.apply_validations(options))
+    end
+
+    def Textarea(name, *modifiers, **options)
+      fo = field_object(name)
+      render fo.textarea(*modifiers, **fo.apply_validations(options))
+    end
+
+    def Checkbox(name, *modifiers, **options)
+      fo = field_object(name)
+      render fo.checkbox(*modifiers, **fo.apply_validations(options))
+    end
+
+    def Radio(name, value, *modifiers, **)
+      render field_object(name).radio(value, *modifiers, **)
+    end
+
+    def Toggle(name, *modifiers, **options)
+      fo = field_object(name)
+      render fo.toggle(*modifiers, **fo.apply_validations(options))
+    end
+
+    def FileInput(name, *modifiers, **options)
+      fo = field_object(name)
+      render fo.file(*modifiers, **fo.apply_validations(options))
+    end
+
+    def Hidden(name, **)
+      render field_object(name).hidden(**)
+    end
+
+    def Label(name, text = nil, *modifiers, **, &)
+      render field_object(name).label(text, *modifiers, **, &)
+    end
+
+    def Control(name, **, &)
+      render field_object(name).control(**, &)
+    end
+
+    private
+
+    # Dispatch the inner input for `field` based on `as:` / inferred type.
+    def render_field_input(fo, name, as, modifiers, choices:, required:, **)
+      kind = as || resolve_input_type(name, modifiers)
+      case kind
+      when :select   then render fo.choices_select(choices, *modifiers, required:, **)
+      when :textarea then render fo.textarea(*modifiers, required:, **)
+      when :toggle   then render fo.toggle(*modifiers, required:, **)
+      when :checkbox then render fo.checkbox(*modifiers, required:, **)
+      when :file     then render fo.file(*modifiers, required:, **)
+      when :hidden   then render fo.hidden(**)
+      else
+        type = kind == :datetime ? :"datetime-local" : kind
+        render fo.input(*(modifiers - INPUT_TYPE_MODIFIERS), type:, required:, **)
+      end
+    end
+
+    def resolve_input_type(name, modifiers)
+      explicit = modifiers.find { |m| INPUT_TYPE_MODIFIERS.include?(m) }
+      explicit || INPUT_TYPE_INFERENCE[name.to_sym] || :text
+    end
+  end
+end

data/lib/phlex_forms/class_merge.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # Class-string merging for phlex-forms components.
+  #
+  # DaisyUI component-class families are mutually exclusive: an element can't be
+  # both `input-sm` and `input-lg`, or both `input-primary` and `input-error`.
+  # When a component's default classes and a caller's `class:` override both name
+  # the same family, the LAST occurrence wins — matching Tailwind/daisyui
+  # intuition (the later class overrides the earlier).
+  #
+  # We deliberately do NOT depend on tailwind_merge: on form fields, callers pass
+  # daisyui modifiers (which this handles) rather than conflicting core Tailwind
+  # utilities, so tailwind_merge would add a runtime dependency for a conflict
+  # that does not occur here. Non-conflicting utilities (`w-full`, `py-0`, ...)
+  # simply pass through in order.
+  module ClassMerge
+    SIZE = /-(xs|sm|md|lg|xl)\z/
+    COLOR = /-(primary|secondary|accent|neutral|info|success|warning|error)\z/
+
+    module_function
+
+    # Merge any number of class strings/nil into one deduped string. Preserves
+    # order; within a daisyui size/color family only the last token survives.
+    def merge(*parts)
+      tokens = parts.flat_map { |p| p.to_s.split }.reject(&:empty?)
+      dedupe_daisyui_families(tokens).join(" ")
+    end
+
+    # For each (component-prefix, family) pair, keep only the last token.
+    def dedupe_daisyui_families(tokens)
+      last_index = {}
+      tokens.each_with_index do |tok, idx|
+        key = family_key(tok)
+        last_index[key] = idx if key
+      end
+      tokens.each_with_index.filter_map do |tok, idx|
+        key = family_key(tok)
+        next tok if key.nil? # not a daisyui family token — keep
+        next tok if last_index[key] == idx # last in its family — keep
+
+        nil # earlier duplicate in the family — drop
+      end
+    end
+
+    # A stable bucket key like "input:size" / "select:color", or nil if the token
+    # is not a recognized daisyui size/color modifier.
+    def family_key(token)
+      if (m = token.match(SIZE))
+        "#{token[0...m.begin(0)]}:size"
+      elsif (m = token.match(COLOR))
+        "#{token[0...m.begin(0)]}:color"
+      end
+    end
+  end
+end

data/lib/phlex_forms/configuration.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # Central configuration for phlex-forms. Set via `PhlexForms.configure`.
+  #
+  #   PhlexForms.configure do |c|
+  #     c.icon_renderer = ->(name, **opts) { MyIcons::Icon.new(name, **opts) }
+  #   end
+  #
+  # The icon renderer is a callable `->(name, **opts) { renderable }` returning
+  # something a Phlex component can emit: a Phlex component instance OR a raw SVG
+  # String.
+  #
+  # The DEFAULT is a bundled inline SVG so phlex-forms is self-contained and
+  # renders identically with no host configuration. To use the glyphs gem (which
+  # resolves a full icon set from the host app's rails_icons asset tree), opt in:
+  #
+  #   PhlexForms.configure do |c|
+  #     c.icon_renderer = PhlexForms::Configuration.glyphs_renderer
+  #   end
+  #
+  # glyphs is intentionally NOT the default: rails_icons reads SVGs from the host
+  # app's asset paths, which a minimal host (or the gem's own test suite) has not
+  # set up — so defaulting to glyphs would raise Icons::IconNotFound.
+  class Configuration
+    # A ready-made renderer that delegates to glyphs' LucideIcon. Raises a clear
+    # error if glyphs is not loaded.
+    def self.glyphs_renderer
+      unless defined?(Glyphs::LucideIcon)
+        raise PhlexForms::FeatureUnavailable,
+          "PhlexForms glyphs_renderer requires the `glyphs` gem to be loaded"
+      end
+
+      ->(name, **opts) { Glyphs::LucideIcon.new(name, **opts) }
+    end
+
+    attr_writer :icon_renderer
+
+    def icon_renderer
+      @icon_renderer ||= ->(name, **opts) { InlineIcons.render(name, **opts) }
+    end
+
+    # Returns a renderable for the named icon. Components pass the result to Phlex
+    # `render`/`raw` as appropriate.
+    def render_icon(name, **)
+      icon_renderer.call(name.to_s, **)
+    end
+  end
+end

data/lib/phlex_forms/delegated_field.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # Shared helpers for the model-bound leaf components that delegate their markup
+  # and variants to a daisyui gem component (DaisyUI::Input/Textarea/Select/...).
+  #
+  # A host component sets @modifiers, @error, @disabled, @required, @full_width,
+  # and @attributes in its initializer, then calls #daisy_modifiers and
+  # #binding_attributes to assemble the delegated component's arguments.
+  module DelegatedField
+    # daisyui v4 `:bordered` is a no-op in v5 (base component class has the
+    # border); accept it silently so v4-era call sites don't break.
+    IGNORED_MODIFIERS = %i[bordered].freeze
+
+    private
+
+    def normalize_modifiers(modifiers)
+      modifiers - IGNORED_MODIFIERS
+    end
+
+    # Append :error when the field is invalid and the caller didn't already pass
+    # a color modifier, so daisyui emits the *-error class.
+    def daisy_modifiers
+      return @modifiers if !@error || @modifiers.include?(:error)
+
+      @modifiers + [:error]
+    end
+
+    # name/id + disabled/required booleans + a w-full class (unless full_width is
+    # false), merged with the caller's passthrough attributes. Excludes internal
+    # keys (:error, :value, :class, :placeholder handled per-component).
+    def binding_attributes(**extra)
+      attrs = {
+        name: @name,
+        id: @id,
+        class: width_class,
+        **@attributes.except(:error, :value, :class),
+        **extra
+      }
+      attrs[:disabled] = true if @disabled
+      attrs[:required] = true if @required
+      attrs.compact
+    end
+
+    def width_class
+      return @attributes[:class] unless @full_width
+
+      ["w-full", @attributes[:class]].compact.join(" ")
+    end
+  end
+end

data/lib/phlex_forms/engine.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # Optional Rails integration. Loaded only when Rails::Engine is defined (see
+  # lib/phlex_forms.rb), so the gem stays a plain Phlex library outside Rails.
+  #
+  # It wires up:
+  #   * the bundled Stimulus controllers (choices / searchable-select / tz) via
+  #     importmap-rails + the asset load path;
+  #   * the gem's default locale files (en/sv/de) prepended to I18n.load_path so
+  #     host apps can override any key.
+  #
+  # Asset-and-locale-only engine: no isolate_namespace, since it exposes no
+  # routes, models, or helpers.
+  class Engine < ::Rails::Engine
+    JAVASCRIPT_PATH = root.join("app/javascript")
+
+    initializer "phlex_forms.assets" do |app|
+      app.config.assets.paths << JAVASCRIPT_PATH.to_s if app.config.respond_to?(:assets)
+    end
+
+    initializer "phlex_forms.importmap", before: "importmap" do |app|
+      next unless app.config.respond_to?(:importmap)
+
+      importmap = app.config.importmap
+      importmap.paths << root.join("config/importmap.rb") if importmap.respond_to?(:paths)
+      importmap.cache_sweepers << JAVASCRIPT_PATH if importmap.respond_to?(:cache_sweepers)
+    end
+
+    initializer "phlex_forms.i18n" do |app|
+      locales = Dir[root.join("config/locales/*.yml")].map(&:to_s)
+      app.config.i18n.load_path.unshift(*locales)
+    end
+  end
+end

data/lib/phlex_forms/inline_icons.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  # The gem's zero-dependency fallback icon set: a small map of inline SVGs for
+  # the handful of icons phlex-forms itself renders. Swap the whole renderer via
+  # `PhlexForms.configure { |c| c.icon_renderer = ... }` (e.g. to use glyps).
+  module InlineIcons
+    # Lucide "chevron-down", 24x24, currentColor stroke — matches the icon the
+    # select trigger used before extraction.
+    CHEVRON_DOWN = <<~SVG
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m6 9 6 6 6-6"/></svg>
+    SVG
+
+    ICONS = {
+      "chevron-down" => CHEVRON_DOWN
+    }.freeze
+
+    module_function
+
+    # Returns a raw SVG string with any `class:` applied to the root element.
+    # The caller marks it safe for its render context (Phlex `raw(safe(...))`),
+    # so this stays a plain String and the gem needs no ActiveSupport. Unknown
+    # icon names return an empty string rather than raising, so a missing glyph
+    # degrades gracefully.
+    def render(name, **opts)
+      svg = ICONS[name.to_s]
+      return "" if svg.nil?
+
+      opts[:class] ? apply_class(svg, opts[:class]) : svg
+    end
+
+    def apply_class(svg, klass)
+      svg.sub("<svg ", %(<svg class="#{klass}" ))
+    end
+  end
+end

data/lib/phlex_forms/rubocop.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Entry point for phlex-forms' RuboCop cops. A host app enables them by adding
+# to its .rubocop.yml:
+#
+#   require:
+#     - phlex_forms/rubocop
+#   inherit_gem:
+#     phlex-forms: config/rubocop.yml
+#
+require "rubocop"
+
+require_relative "../rubocop/phlex_forms/cop/raw_form"
+require_relative "../rubocop/phlex_forms/cop/legacy_form_method"

data/lib/phlex_forms/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module PhlexForms
+  VERSION = "0.1.0"
+end

data/lib/phlex_forms.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "date" # Phlex's attribute serializer references Date; ensure it's loaded.
+require "active_support/core_ext/object/blank" # blank?/present?/presence
+require "phlex"
+require "daisy_ui"
+require "glyphs"
+require "zeitwerk"
+
+require_relative "phlex_forms/version"
+
+# phlex-forms exposes its components under the `Forms::` namespace (Form, Input,
+# Select, Submit, Label, ...) so that consuming apps can `include Forms` and call
+# `Form(model:) { |f| ... }` as a Phlex::Kit helper. Gem-internal machinery
+# (configuration, the icon renderer) lives under `PhlexForms::` to keep the
+# `Forms::` namespace clean for components only.
+module PhlexForms
+  class Error < StandardError; end
+
+  # Raised when an optional feature (e.g. rich text via ActionText/Lexxy) is
+  # used but its backing dependency is not available.
+  class FeatureUnavailable < Error; end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+    alias config configuration
+
+    def configure
+      yield(configuration)
+    end
+
+    # Reset configuration to defaults. Intended for test isolation.
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+# The component namespace. Extending Phlex::Kit makes every `Forms::Foo`
+# component callable as a bare `Foo(...)` helper wherever `Forms` is included.
+module Forms
+  extend Phlex::Kit
+end
+
+# Two non-overlapping autoload roots:
+#   lib/phlex_forms/**        (minus components) -> PhlexForms::  (gem internals)
+#   lib/phlex_forms/components -> Forms::                          (components)
+# We drive the loader manually (not `for_gem`) so the component root can map
+# onto the top-level `Forms` module while gem internals stay under `PhlexForms`.
+loader = Zeitwerk::Loader.new
+loader.tag = "phlex-forms"
+loader.inflector.inflect(
+  "phlex_forms" => "PhlexForms",
+  "phlex-forms" => "PhlexForms"
+)
+
+# Two sibling (non-nested) autoload roots:
+#   lib/phlex_forms -> PhlexForms::  (gem internals: config, class_merge, ...)
+#   lib/forms       -> Forms::        (the component kit)
+# Keeping them as separate top-level dirs avoids the ambiguity of nesting one
+# namespace root inside another.
+loader.push_dir("#{__dir__}/phlex_forms", namespace: PhlexForms)
+loader.push_dir("#{__dir__}/forms", namespace: Forms)
+
+# Files required explicitly above, or loaded only in specific contexts.
+loader.ignore("#{__dir__}/phlex_forms/version.rb") # required explicitly above
+loader.ignore("#{__dir__}/rubocop") # cops load on demand via the host .rubocop.yml
+loader.ignore("#{__dir__}/phlex_forms/rubocop.rb") # cop entry point (RuboCop:: namespace)
+# The engine is conditionally required at the bottom of this file (only under
+# Rails), so it must not be autoloaded/eager-loaded by Zeitwerk.
+loader.ignore("#{__dir__}/phlex_forms/engine.rb")
+
+loader.setup
+
+# Optional Rails integration (Stimulus controllers via importmap/assets, and
+# the gem's default locale files). Loaded only under Rails; the gem stays pure
+# Phlex otherwise.
+require_relative "phlex_forms/engine" if defined?(Rails::Engine)

data/lib/rubocop/phlex_forms/cop/legacy_form_method.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module PhlexForms
+      # Flags Rails-style legacy form-builder methods (text_field, select, ...) in
+      # favor of the phlex-forms API. The preferred primary path is the
+      # Control-first `form.field(:name, ...)`; the PascalCase component methods
+      # (form.Input/Select/Textarea/...) remain as escape hatches.
+      #
+      # @example
+      #   # bad
+      #   form.text_field(:name, :primary)
+      #   form.select(:role, choices: roles)
+      #
+      #   # good (primary)
+      #   form.field(:name, :primary)
+      #   form.field(:role, as: :select, choices: roles)
+      #
+      #   # good (escape hatch)
+      #   form.Input(:name, :primary)
+      #   form.Select(:role, choices: roles)
+      class LegacyFormMethod < Base
+        INPUT_TYPE_METHODS = {
+          text_field: :text,
+          email_field: :email,
+          password_field: :password,
+          number_field: :number,
+          date_field: :date,
+          time_field: :time,
+          datetime_field: :datetime,
+          url_field: :url,
+          tel_field: :tel,
+          search_field: :search,
+          range_field: :range,
+          color_field: :color
+        }.freeze
+
+        OTHER_LEGACY_METHODS = {
+          textarea: "Textarea",
+          text_area: "Textarea",
+          select: "Select",
+          checkbox: "Checkbox",
+          check_box: "Checkbox",
+          radio_button: "Radio",
+          toggle: "Toggle",
+          file_field: "FileInput",
+          hidden_field: "Hidden",
+          form_control: "Control",
+          label: "Label"
+        }.freeze
+
+        FORM_RECEIVERS = %i[form f af].freeze
+        FORM_SUFFIX = /_form\z/
+
+        def on_send(node)
+          return unless form_receiver?(node)
+
+          method_name = node.method_name
+          return unless legacy_method?(method_name)
+
+          add_offense(node.loc.selector, message: build_message(method_name, node))
+        end
+
+        private
+
+        def form_receiver?(node)
+          receiver = node.receiver
+          return false unless receiver
+          return false unless receiver.send_type? || receiver.lvar_type?
+
+          receiver_name = receiver.send_type? ? receiver.method_name : receiver.children.first
+          FORM_RECEIVERS.include?(receiver_name) || receiver_name.to_s.match?(FORM_SUFFIX)
+        end
+
+        def legacy_method?(method_name)
+          INPUT_TYPE_METHODS.key?(method_name) || OTHER_LEGACY_METHODS.key?(method_name)
+        end
+
+        def build_message(method_name, node)
+          replacement =
+            if INPUT_TYPE_METHODS.key?(method_name)
+              "form.Input(#{format_args_for_input(node, INPUT_TYPE_METHODS[method_name])})"
+            else
+              "form.#{OTHER_LEGACY_METHODS[method_name]}(#{format_args_passthrough(node)})"
+            end
+
+          "Use `form.field(...)` (or `#{replacement}`) instead of legacy " \
+            "`#{node.receiver.source}.#{method_name}`."
+        end
+
+        def format_args_for_input(node, type_modifier)
+          args = node.arguments
+          [args.first&.source, ":#{type_modifier}", *args.drop(1).map(&:source)].compact.join(", ")
+        end
+
+        def format_args_passthrough(node)
+          node.arguments.map(&:source).join(", ")
+        end
+      end
+    end
+  end
+end