superform 0.5.1 → 0.6.0

data/lib/superform/rails/option_mapper.rb

@@ -0,0 +1,36 @@
+module Superform
+  module Rails
+    # Accept a collection of objects and map them to options suitable for form controls, like `select > options`
+    class OptionMapper
+      include Enumerable
+
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def each(&options)
+        @collection.each do |object|
+          case object
+            in ActiveRecord::Relation => relation
+              active_record_relation_options_enumerable(relation).each(&options)
+            in id, value
+              options.call id, value
+            in value
+              options.call value, value.to_s
+          end
+        end
+      end
+
+      def active_record_relation_options_enumerable(relation)
+        Enumerator.new do |collection|
+          relation.each do |object|
+            attributes = object.attributes
+            id = attributes.delete(relation.primary_key)
+            value = attributes.values.join(" ")
+            collection << [ id, value ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superform/rails/strong_parameters.rb

@@ -0,0 +1,73 @@
+module Superform
+  module Rails
+    module StrongParameters
+      protected
+      # Assigns permitted params to the given form and returns the model.
+      # Usage in a controller when you want to build/validate without saving:
+      #
+      # def preview
+      #   @post = Post.new
+      #   post = permit PostForm.new(@post)
+      #   # post now has attributes from params, but is not persisted
+      #   render :preview
+      # end
+      def permit(form)
+        form_params = params.require(form.key)
+        assign(form_params, to: form).model
+      end
+
+      # Saves the form's underlying model after assigning permitted params.
+      # Typical Rails controller usage (create):
+      #
+      # def create
+      #   @post = Post.new
+      #   if save PostForm.new(@post)
+      #     redirect_to @post
+      #   else
+      #     render :new, status: :unprocessable_entity
+      #   end
+      # end
+      #
+      # Typical Rails controller usage (update):
+      #
+      # def update
+      #   @post = Post.find(params[:id])
+      #   if save PostForm.new(@post)
+      #     redirect_to @post
+      #   else
+      #     render :edit, status: :unprocessable_entity
+      #   end
+      # end
+      def save(form)
+        permit(form).save
+      end
+
+      # Bang version that raises on validation failure.
+      # Useful when you prefer exceptions or are in a transaction:
+      #
+      # def create
+      #   @post = Post.new
+      #   save! PostForm.new(@post)
+      #   redirect_to @post
+      # rescue ActiveRecord::RecordInvalid
+      #   render :new, status: :unprocessable_entity
+      # end
+      def save!(form)
+        permit(form).save!
+      end
+
+      # Assigns params to the form and returns the form.
+      def assign(params, to:)
+        to.tap do |form|
+          # This output of this string goes nowhere since it likely
+          # won't be used. I'm not sure if I'm right about this though,
+          # If I'm wrong, then I think I need to encapsulate this module
+          # into a class that can store the rendered HTML that can be
+          # rendered later.
+          render_to_string form
+          form.assign params
+        end
+      end
+    end
+  end
+end

data/lib/superform/rails.rb

@@ -1,373 +1,22 @@
+require "phlex/rails"
+
 module Superform
   module Rails
-    # The `ApplicationComponent` is the superclass for all components in your application.
-    Component = ::ApplicationComponent
-
-    # A Phlex::HTML view module that accepts a model and sets a `Superform::Namespace`
-    # with the `Object#model_name` as the key and maps the object to form fields
-    # and namespaces.
-    #
-    # The `Form::Field` is a class that's meant to be extended so you can customize the `Form` inputs
-    # to your applications needs. Defaults for the `input`, `button`, `label`, and `textarea` tags
-    # are provided.
-    #
-    # The `Form` component also handles Rails authenticity tokens via the `authenticity_toklen_field`
-    # method and the HTTP verb via the `_method_field`.
-    class Form < Component
-      attr_accessor :model
-
-      delegate \
-          :field,
-          :collection,
-          :namespace,
-          :assign,
-          :serialize,
-        to: :@namespace
-
-      # The Field class is designed to be extended to create custom forms. To override,
-      # in your subclass you may have something like this:
-      #
-      # ```ruby
-      # class MyForm < Superform::Rails::Form
-      #   class MyLabel < Superform::Rails::Components::LabelComponent
-      #     def view_template(&content)
-      #       label(form: @field.dom.name, class: "text-bold", &content)
-      #     end
-      #   end
-      #
-      #   class Field < Field
-      #     def label(**attributes)
-      #       MyLabel.new(self, **attributes)
-      #     end
-      #   end
-      # end
-      # ```
-      #
-      # Now all calls to `label` will have the `text-bold` class applied to it.
-      class Field < Superform::Field
-        def button(**attributes)
-          Components::ButtonComponent.new(self, attributes: attributes)
-        end
-
-        def input(**attributes)
-          Components::InputComponent.new(self, attributes: attributes)
-        end
-
-        def checkbox(**attributes)
-          Components::CheckboxComponent.new(self, attributes: attributes)
-        end
-
-        def label(**attributes, &)
-          Components::LabelComponent.new(self, attributes: attributes, &)
-        end
-
-        def textarea(**attributes)
-          Components::TextareaComponent.new(self, attributes: attributes)
-        end
-
-        def select(*collection, **attributes, &)
-          Components::SelectField.new(self, attributes: attributes, collection: collection, &)
-        end
-
-        def title
-          key.to_s.titleize
-        end
-      end
-
-      def initialize(model, action: nil, method: nil, **attributes)
-        @model = model
-        @action = action
-        @method = method
-        @attributes = attributes
-        @namespace = Namespace.root(key, object: model, field_class: self.class::Field)
-      end
-
-      def around_template(&)
-        form_tag do
-          authenticity_token_field
-          _method_field
-          super
-        end
-      end
-
-      def form_tag(&)
-        form action: form_action, method: form_method, **@attributes, &
-      end
-
-      def view_template(&block)
-        yield_content(&block)
-      end
-
-      def submit(value = submit_value, **attributes)
-        input **attributes.merge(
-          name: "commit",
-          type: "submit",
-          value: value
-        )
-      end
-
-      def key
-        @model.model_name.param_key
-      end
-
-      protected
-        def authenticity_token_field
-          input(
-            name: "authenticity_token",
-            type: "hidden",
-            value: helpers.form_authenticity_token
-          )
-        end
-
-        def _method_field
-          input(
-            name: "_method",
-            type: "hidden",
-            value: _method_field_value
-          )
-        end
-
-        def _method_field_value
-          @method || resource_method_field_value
-        end
-
-        def resource_method_field_value
-          @model.persisted? ? "patch" : "post"
-        end
-
-        def submit_value
-          "#{resource_action.to_s.capitalize} #{@model.model_name}"
-        end
-
-        def resource_action
-          @model.persisted? ? :update : :create
-        end
-
-        def form_action
-          @action ||= helpers.url_for(action: resource_action)
-        end
-
-        def form_method
-          @method.to_s.downcase == "get" ? "get" : "post"
-        end
-    end
-
-    module StrongParameters
-      protected
-        # Assigns params to the form and returns the model.
-        def assign(params, to:)
-          form = to
-          # TODO: Figure out how to render this in a way that doesn't concat a string; just throw everything away.
-          render_to_string form
-          form.assign params
-          form.model
-        end
-    end
-
-    # Accept a collection of objects and map them to options suitable for form controls, like `select > options`
-    class OptionMapper
-      include Enumerable
-
-      def initialize(collection)
-        @collection = collection
-      end
-
-      def each(&options)
-        @collection.each do |object|
-          case object
-            in ActiveRecord::Relation => relation
-              active_record_relation_options_enumerable(relation).each(&options)
-            in id, value
-              options.call id, value
-            in value
-              options.call value, value.to_s
-          end
-        end
-      end
-
-      def active_record_relation_options_enumerable(relation)
-        Enumerator.new do |collection|
-          relation.each do |object|
-            attributes = object.attributes
-            id = attributes.delete(relation.primary_key)
-            value = attributes.values.join(" ")
-            collection << [ id, value ]
-          end
-        end
-      end
+    # When this is included in a Rails app, check if `Components::Base` is defined and
+    # inherit from that so we get all the users stuff; otherwise inherit from Phlex::HTML,
+    # which means we won't have all the users methods and overrides.
+    SUPERCLASSES = [
+      "::Components::Base",       # Phlex 2.x base class in a Rails project
+      "::ApplicationComponent",   # Phlex 1.x base class in a Rails project
+      "::Phlex::HTML",            # Couldn't detect a base Phlex Rails class, so use Phlex::HTML
+    ]
+
+    # Find the base class for the Rails app.
+    def self.base_class
+      const_get SUPERCLASSES.find { |const| const_defined?(const) }
     end
 
-    module Components
-      class BaseComponent < Component
-        attr_reader :field, :dom
-
-        delegate :dom, to: :field
-
-        def initialize(field, attributes: {})
-          @field = field
-          @attributes = attributes
-        end
-
-        def field_attributes
-          {}
-        end
-
-        def focus(value = true)
-          @attributes[:autofocus] = value
-          self
-        end
-
-        private
-
-        def attributes
-          field_attributes.merge(@attributes)
-        end
-      end
-
-      class FieldComponent < BaseComponent
-        def field_attributes
-          { id: dom.id, name: dom.name }
-        end
-      end
-
-      class LabelComponent < BaseComponent
-        def view_template(&content)
-          content ||= Proc.new { field.key.to_s.titleize }
-          label(**attributes, &content)
-        end
-
-        def field_attributes
-          { for: dom.id }
-        end
-      end
-
-      class ButtonComponent < FieldComponent
-        def view_template(&content)
-          content ||= Proc.new { button_text }
-          button(**attributes, &content)
-        end
-
-        def button_text
-          @attributes.fetch(:value, dom.value).titleize
-        end
-
-        def field_attributes
-          { id: dom.id, name: dom.name, value: dom.value }
-        end
-      end
-
-      class CheckboxComponent < FieldComponent
-        def view_template(&)
-          # Rails has a hidden and checkbox input to deal with sending back a value
-          # to the server regardless of if the input is checked or not.
-          input(name: dom.name, type: :hidden, value: "0")
-          # The hard coded keys need to be in here so the user can't overrite them.
-          input(type: :checkbox, value: "1", **attributes)
-        end
-
-        def field_attributes
-          { id: dom.id, name: dom.name, checked: field.value }
-        end
-      end
-
-      class InputComponent < FieldComponent
-        def view_template(&)
-          input(**attributes)
-        end
-
-        def field_attributes
-          {
-            id: dom.id,
-            name: dom.name,
-            type: type,
-            value: value
-          }
-        end
-
-        def has_client_provided_value?
-          case type.to_s
-          when "file", "image"
-            true
-          else
-            false
-          end
-        end
-
-        def value
-          dom.value unless has_client_provided_value?
-        end
-
-        def type
-          @type ||= ActiveSupport::StringInquirer.new(attribute_type || value_type)
-        end
-
-        protected
-          def value_type
-            case field.value
-            when URI
-              "url"
-            when Integer, Float
-              "number"
-            when Date, DateTime
-              "date"
-            when Time
-              "time"
-            else
-              "text"
-            end
-          end
-
-          def attribute_type
-            if type = @attributes[:type] || @attributes["type"]
-              type.to_s
-            end
-          end
-      end
-
-      class TextareaComponent < FieldComponent
-        def view_template(&content)
-          content ||= Proc.new { dom.value }
-          textarea(**attributes, &content)
-        end
-      end
-
-      class SelectField < FieldComponent
-        def initialize(*, collection: [], **, &)
-          super(*, **, &)
-          @collection = collection
-        end
-
-        def view_template(&options)
-          if block_given?
-            select(**attributes, &options)
-          else
-            select(**attributes) { options(*@collection) }
-          end
-        end
-
-        def options(*collection)
-          map_options(collection).each do |key, value|
-            option(selected: field.value == key, value: key) { value }
-          end
-        end
-
-        def blank_option(&)
-          option(selected: field.value.nil?, &)
-        end
-
-        def true_option(&)
-          option(selected: field.value == true, value: true.to_s, &)
-        end
-
-        def false_option(&)
-          option(selected: field.value == false, value: false.to_s, &)
-        end
-
-        protected
-          def map_options(collection)
-            OptionMapper.new(collection)
-          end
-      end
-    end
+    # Set the base class for the rem
+    Component = base_class
   end
-end
+end

data/lib/superform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Superform
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,34 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: superform
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Brad Gessler
 bindir: exe
 cert_chain: []
-date: 2025-04-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - "<"
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -59,17 +53,30 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- SPEC_STYLE_GUIDE.md
 - lib/generators/superform/install/USAGE
 - lib/generators/superform/install/install_generator.rb
-- lib/generators/superform/install/templates/application_form.rb
+- lib/generators/superform/install/templates/base.rb
 - lib/superform.rb
 - lib/superform/dom.rb
 - lib/superform/field.rb
 - lib/superform/field_collection.rb
+- lib/superform/form.rb
 - lib/superform/namespace.rb
 - lib/superform/namespace_collection.rb
 - lib/superform/node.rb
 - lib/superform/rails.rb
+- lib/superform/rails/components/base.rb
+- lib/superform/rails/components/button.rb
+- lib/superform/rails/components/checkbox.rb
+- lib/superform/rails/components/field.rb
+- lib/superform/rails/components/input.rb
+- lib/superform/rails/components/label.rb
+- lib/superform/rails/components/select.rb
+- lib/superform/rails/components/textarea.rb
+- lib/superform/rails/form.rb
+- lib/superform/rails/option_mapper.rb
+- lib/superform/rails/strong_parameters.rb
 - lib/superform/version.rb
 - sig/superform.rbs
 homepage: https://github.com/rubymonolith/superform
@@ -94,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Build forms in Rails
 test_files: []

data/lib/generators/superform/install/templates/application_form.rb

@@ -1,31 +0,0 @@
-class ApplicationForm < Superform::Rails::Form
-  include Phlex::Rails::Helpers::Pluralize
-
-  def row(component)
-    div do
-      render component.field.label(style: "display: block;")
-      render component
-    end
-  end
-
-  def around_template(&)
-    super do
-      error_messages
-      yield
-      submit
-    end
-  end
-
-  def error_messages
-    if model.errors.any?
-      div(style: "color: red;") do
-        h2 { "#{pluralize model.errors.count, "error"} prohibited this post from being saved:" }
-        ul do
-          model.errors.each do |error|
-            li { error.full_message }
-          end
-        end
-      end
-    end
-  end
-end