superform 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f11fa90121336cea5cba3e376930c7c03c59f1a4cad8383de46482921651a94
-  data.tar.gz: cfec05650064dcb07e6eadb0b78c501317cace17bd7062c666ad3972379e4c1b
+  metadata.gz: b87df41698b91049bed9e30f976d56b92c5c694762a63803453d29fa47c025a9
+  data.tar.gz: bd9ec4dd8499de8303411c3ee88f7a2888ce285b5592eb32829db6043782a4f9
 SHA512:
-  metadata.gz: ec98e31913b9ca5f3aac6c75952b2ee51a19c01c82368f2dc5c87f58c91eb6dd0f41dfae969165f6be7fc1ac2e87595f85c30d19ef43938e3c95a58e2cd1c7ba
-  data.tar.gz: b138902a808ecbff61fbc8b3ae37a34e576895972512a7c0c5d78e8c318130fa567d53570d9163210d2015141ea47a38e3c0b021082be936341d9f5c951a4b25
+  metadata.gz: 5f945ca1d2a57d3b4ac69d064c72f701cd7d3d524a64dd241c80a23b3fd53cecd572800f2ebbe760321348d0f770b60d60be5acb4a4482e007d9040d21b3898f
+  data.tar.gz: a47df25dcc990f3162b874f85999df79e0acf170643395071aaa2b2c29fde23ff302a055a9ed132927945cc53c30376f645846370f5e323eb89115dc740136ce

data/Gemfile

@@ -7,4 +7,6 @@ gemspec
 
 gem "rake", "~> 13.0"
 
+# Run tests
 gem "rspec", "~> 3.0"
+gem "guard-rspec", "~> 4.7"

data/Gemfile.lock

@@ -0,0 +1,220 @@
+PATH
+  remote: .
+  specs:
+    superform (0.2.0)
+      phlex-rails (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.6)
+      actionpack (= 7.0.6)
+      activesupport (= 7.0.6)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.6)
+      actionpack (= 7.0.6)
+      activejob (= 7.0.6)
+      activerecord (= 7.0.6)
+      activestorage (= 7.0.6)
+      activesupport (= 7.0.6)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.6)
+      actionpack (= 7.0.6)
+      actionview (= 7.0.6)
+      activejob (= 7.0.6)
+      activesupport (= 7.0.6)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.6)
+      actionview (= 7.0.6)
+      activesupport (= 7.0.6)
+      rack (~> 2.0, >= 2.2.4)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.6)
+      actionpack (= 7.0.6)
+      activerecord (= 7.0.6)
+      activestorage (= 7.0.6)
+      activesupport (= 7.0.6)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.6)
+      activesupport (= 7.0.6)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.6)
+      activesupport (= 7.0.6)
+      globalid (>= 0.3.6)
+    activemodel (7.0.6)
+      activesupport (= 7.0.6)
+    activerecord (7.0.6)
+      activemodel (= 7.0.6)
+      activesupport (= 7.0.6)
+    activestorage (7.0.6)
+      actionpack (= 7.0.6)
+      activejob (= 7.0.6)
+      activerecord (= 7.0.6)
+      activesupport (= 7.0.6)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.6)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    builder (3.2.4)
+    cgi (0.3.6)
+    coderay (1.1.3)
+    concurrent-ruby (1.2.2)
+    crass (1.0.6)
+    date (3.3.3)
+    diff-lcs (1.5.0)
+    erb (4.0.2)
+      cgi (>= 0.3.3)
+    erubi (1.12.0)
+    ffi (1.15.5)
+    formatador (1.1.0)
+    globalid (1.1.0)
+      activesupport (>= 5.0)
+    guard (2.18.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.13.0)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-rspec (4.7.3)
+      guard (~> 2.1)
+      guard-compat (~> 1.1)
+      rspec (>= 2.99.0, < 4.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    listen (3.8.0)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    loofah (2.21.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.12.0)
+    lumberjack (1.2.8)
+    mail (2.8.1)
+      mini_mime (>= 0.1.1)
+      net-imap
+      net-pop
+      net-smtp
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.18.1)
+    nenv (0.3.0)
+    net-imap (0.3.6)
+      date
+      net-protocol
+    net-pop (0.1.2)
+      net-protocol
+    net-protocol (0.2.1)
+      timeout
+    net-smtp (0.3.3)
+      net-protocol
+    nio4r (2.5.9)
+    nokogiri (1.15.3-arm64-darwin)
+      racc (~> 1.4)
+    nokogiri (1.15.3-x86_64-linux)
+      racc (~> 1.4)
+    notiffany (0.1.3)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    phlex (1.8.1)
+      concurrent-ruby (~> 1.2)
+      erb (>= 4)
+      zeitwerk (~> 2.6)
+    phlex-rails (1.0.0)
+      phlex (~> 1.7)
+      rails (>= 6.1, < 8)
+      zeitwerk (~> 2.6)
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.7.1)
+    rack (2.2.7)
+    rack-test (2.1.0)
+      rack (>= 1.3)
+    rails (7.0.6)
+      actioncable (= 7.0.6)
+      actionmailbox (= 7.0.6)
+      actionmailer (= 7.0.6)
+      actionpack (= 7.0.6)
+      actiontext (= 7.0.6)
+      actionview (= 7.0.6)
+      activejob (= 7.0.6)
+      activemodel (= 7.0.6)
+      activerecord (= 7.0.6)
+      activestorage (= 7.0.6)
+      activesupport (= 7.0.6)
+      bundler (>= 1.15.0)
+      railties (= 7.0.6)
+    rails-dom-testing (2.1.1)
+      activesupport (>= 5.0.0)
+      minitest
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.6.0)
+      loofah (~> 2.21)
+      nokogiri (~> 1.14)
+    railties (7.0.6)
+      actionpack (= 7.0.6)
+      activesupport (= 7.0.6)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rake (13.0.6)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    shellany (0.0.1)
+    thor (1.2.2)
+    timeout (0.4.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.6.8)
+
+PLATFORMS
+  arm64-darwin-22
+  x86_64-linux
+
+DEPENDENCIES
+  guard-rspec (~> 4.7)
+  rake (~> 13.0)
+  rspec (~> 3.0)
+  superform!
+
+BUNDLED WITH
+   2.4.8

data/Guardfile

@@ -0,0 +1,70 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/README.md

@@ -4,58 +4,56 @@ Superform aims to be the best way to build forms in Rails applications. Here's w
 
 * **Everything is a component.** Superform is built on top of [Phlex](https://phlex.fun), so every bit of HTML in the form can be customized to your precise needs. Use it with your own CSS Framework or go crazy customizing every last bit of TailwindCSS.
 
-* **Strong Params are built in.** Superform automatically permits the form fields for you. How many times have you changed the form and forgot to permit a param from the controller? No more! Superform has you covered.
+* **Automatic strong parameters.** Superform automatically permits form fields so you don't have to facepalm yourself after adding a field, wondering why it doesn't persist, only to realize you forgot to add the parameter to your controller. No more! Superform was architected with safety & security in mind, meaning it can automatically permit your form parameters.
 
-* **Compose forms with Plain 'ol Ruby Objects**. Superform is built on top of POROs, so you can easily compose forms together to create complex forms. You can even extend forms to create new forms with a different look and feel.
+* **Compose complex forms with Plain 'ol Ruby Objects.** Superform is built on top of POROs, so you can easily compose classes, modules, & ruby code together to create complex forms. You can even extend forms to create new forms with a different look and feel.
 
-It's a complete rewrite of Rails form's internals that's inspired by Reactive component system. [Chris McCord said it very eloquently in a love letter to react](https://fly.io/blog/love-letter-react/). This aspires to be that, but in Ruby.
+It's a complete rewrite of Rails form's internals that's inspired by Reactive component design patterns.
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/0e4dfe2a1ece26e3a59e/maintainability)](https://codeclimate.com/github/rubymonolith/superform/maintainability) [![Ruby](https://github.com/rubymonolith/superform/actions/workflows/main.yml/badge.svg)](https://github.com/rubymonolith/superform/actions/workflows/main.yml)
 
 ## Installation
 
-Install the gem and add to the Rails application's Gemfile by executing:
+Add to the Rails application's Gemfile by executing:
 
     $ bundle add superform
 
-## Usage
+Then install it.
 
-Super Forms streamlines the development of forms on Rails applications by making everything a component.
+    $ rails g superform:install
 
-Here's what a Superform looks in your Erb files.
+This will install both Phlex Rails and Superform.
 
-```erb
-<%= render ApplicationForm.new model: @user do
-      render field(:email).input(type: :email)
-      render field(:name).input
+## Usage
 
-      button(type: :submit) { "Sign up" }
-    end %>
+Superform streamlines the development of forms on Rails applications by making everything a component.
+
+After installing, create a form in `app/views/*/form.rb`. For example, a form for a `Post` resource might look like this.
+
+```ruby
+# ./app/views/posts/form.rb
+class Posts::Form < ApplicationForm
+  def template(&)
+    row field(:title).input
+    row field(:body).textarea
+  end
+end
 ```
 
-That's very spartan form! Let's add labels and HTML between each form row so we have something to work with.
+Then render it in your templates. Here's what it looks like from an Erb file.
 
 ```erb
-<%= render ApplicationForm.new do
-      div class: "form-row" do
-        render field(:email).label
-        render field(:email).input(type: :email)
-      end
-      div class: "form-row" do
-        render field(:name).label
-        render field(:name).input
-      end
-
-      button(type: :submit) { "Sign up" }
-    end %>
+<h1>New post</h1>
+<%= render Posts::Form.new @post %>
 ```
 
-Jumpin' Jimmidy! That's starting to get purty verbose. Let's add some helpers to `ApplicationForm` and tighten things up.
-
-## Customizing Look & Feel
+## Customization
 
-Superforms are built entirely out of Phlex components. The method names correspeond with the tag, its arguments are attributes, and the blocks are the contents of the element.
+Superforms are built out of [Phlex components](https://www.phlex.fun/html/components/). The method names correspeond with the HTML tag, its arguments are attributes, and the blocks are the contents of the tag.
 
 ```ruby
-class ApplicationForm < Superform::Base
+# ./app/views/forms/application_form.rb
+class ApplicationForm < ApplicationForm
   class MyInputComponent < ApplicationComponent
     def template(&)
       div class: "form-field" do
@@ -88,18 +86,27 @@ end
 
 That looks like a LOT of code, and it is, but look at how easy it is to create forms.
 
-```erb
-<%= render ApplicationForm.new model: @user do
-      labeled field(:name).input
-      labeled field(:email).input(type: :email)
+```ruby
+# ./app/views/users/form.rb
+class Users::Form < ApplicationForm
+  def template(&)
+    labeled field(:name).input
+    labeled field(:email).input(type: :email)
 
-      submit "Sign up"
-    end %>
+    submit "Sign up"
+  end
+end
+```
+
+Then render it from Erb.
+
+```erb
+<%= render Users::Form.new @user %>
 ```
 
 Much better!
 
-### Extending Forms
+## Extending Superforms
 
 The best part? If you have forms with a completely different look and feel, you can extend the forms just like you would a Ruby class:
 
@@ -122,63 +129,96 @@ end
 
 Then, just like you did in your Erb, you create the form:
 
-```erb
-<%= render AdminForm.new model: @user do
-      labeled field(:name).tooltip_input
-      labeled field(:email).tooltip_input(type: :email)
+```ruby
+class Admin::Users::Form < AdminForm
+  def template(&)
+    labeled field(:name).tooltip_input
+    labeled field(:email).tooltip_input(type: :email)
 
-      submit "Save"
-    end %>
+    submit "Save"
+  end
+end
 ```
 
-### Self-permitting Parameters
+Since Superforms are just Ruby objects, you can organize them however you want. You can keep your view component classes embedded in your Superform file if you prefer for everythign to be in one place, keep the forms in the `app/views/forms/*.rb` folder and the components in `app/views/forms/**/*_component.rb`, use Ruby's `include` and `extend` features to modify different form classes, or put them in a gem and share them with an entire organization or open source community. It's just Ruby code!
+
+## Automatic strong parameters
 
-Guess what? It also permits form fields for you in your controller, like this:
+Guess what? Superform eliminates then need for Strong Parameters in Rails by assigning the values of the `params` hash _through_ your form. Here's what it looks like.
 
 ```ruby
-class UserController < ApplicationController
-  # Your actions
+class PostsController < ApplicationController
+  include Superform::Rails::StrongParameters
 
-  private
+  def create
+    @post = assign params.require(:post), to: Post.new
 
-  def permitted_params
-    @form.permit params
+    if @post.save
+      # Success path
+    else
+      # Error path
+    end
   end
+
+  def update
+    @post = Post.find(params[:id])
+
+    assign params.require(:post), to: @post
+
+    if @post.save
+      # Success path
+    else
+      # Error path
+    end
+  end
+
+  private
+    # Defaults to `Posts::Form`, but you can override it here if
+    # you uncomment and add your own class. You could also pass the
+    # `form: FormClass` into the `assign` method.
+    #
+    # def form_class
+    # end
 end
 ```
 
-To do that though you need to move the form into your controller, which is pretty easy:
+How does it work? An instance of the form is created, then the hash is assigned to it. If the params include data outside of what a form accepts, it will be ignored.
 
-```ruby
-class UserController < ApplicationController
-  class Form < ApplicationForm
-    render field(:email).input(type: :email)
-    render field(:name).input
+## Comparisons
 
-    button(type: :submit) { "Sign up" }
-  end
+Rails ships with a lot of great options to make forms. Many of these inspired Superform. The tl;dr:
 
-  before_action :assign_form
+1. Rails has a lot of great form helpers. Simple Form and Formtastic both have concise ways of defining HTML forms, but do require frequently opening and closing Erb tags.
 
-  # Your actions
+2. Superform is uniquely capable of permitting its own controller parameters, leaving you with one less thing to worry about and test. Additionally it can be extended, shared, and modularized since its Plain' 'ol Ruby, which opens up a world of TailwindCSS form libraries and proprietary form libraries developed internally by organizations.
 
-  private
+### Rails form helpers
 
-  def assign_form
-    @form = Form.new(model: @user)
-  end
+Rails form helpers have lasted for almost 20 years and are super solid, but things get tricky when your application starts to take on different styles of forms. To manage it all you have to cobble together helper methods, partials, and templates. Additionally, the structure of the form then has to be expressed to the controller as strong params, forcing you to repeat yourself.
 
-  def permitted_params
-    @form.permit params
-  end
-end
-```
+With Simpleform, you build the entire form with Ruby code, so you avoid the Erb gymnastics and helper method soup that it takes in Rails to scale up forms in an organization.
 
-Then render it from your Erb in less lines, like this:
+### Simple Form
 
-```
-<%= render @form %>
-```
+I built some pretty amazing applications with Simple Form and admire its syntax. It requires "Erb soup", which is an opening and closing line of Erb per line. If you follow a specific directory structure or use their component framework, you can get pretty far, but you'll hit a wall when you need to start putting wrappers around forms or inputs.
+
+https://github.com/heartcombo/simple_form#the-wrappers-api
+
+The API is there, but when you change the syntax, you have to reboot the server to see the changes. UI development should be reflected immediately when the page is reloaded, which is what Superforms can do.
+
+Like Rails form helpers, it doesn't self-permit parameters.
+
+https://www.ruby-toolbox.com/projects/simple_form
+
+### Formtastic
+
+Formtastic gives us a nice DSL inside of Erb that we can use to create forms, but like Simple Form, there's a lot of opening and closing Erb tags that make the syntax clunky.
+
+It has generators that give you Ruby objects that represent HTML form inputs that you can customize, but its limited to very specific parts of the HTML components. Superform lets you customize every aspect of the HTML in your form elements.
+
+It also does not permit its own parameters.
+
+https://www.ruby-toolbox.com/projects/formtastic
 
 ## Development
 

data/lib/generators/superform/install/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Installs Phlex Rails and Superform
+
+Example:
+    bin/rails generate superform:install
+
+    This will create:
+        app/views/forms/application_form.rb

data/lib/generators/superform/install/install_generator.rb

@@ -0,0 +1,24 @@
+class Superform::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path("templates", __dir__)
+
+  APPLICATION_CONFIGURATION_PATH = Rails.root.join("config/application.rb")
+
+  def install_phlex_rails
+    gem "phlex-rails"
+    generate "phlex:install"
+  end
+
+  def autoload_components
+    return unless APPLICATION_CONFIGURATION_PATH.exist?
+
+    inject_into_class(
+      APPLICATION_CONFIGURATION_PATH,
+      "Application",
+      %(    config.autoload_paths << "\#{root}/app/views/forms"\n)
+    )
+  end
+
+  def create_application_form
+    template "application_form.rb", Rails.root.join("app/views/forms/application_form.rb")
+  end
+end

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

@@ -0,0 +1,31 @@
+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

data/lib/superform/rails.rb

@@ -0,0 +1,209 @@
+module Superform
+  module Rails
+    class Form < Phlex::HTML
+      attr_reader :model
+
+      delegate \
+          :field,
+          :collection,
+          :namespace,
+          :key,
+          :assign,
+          :serialize,
+        to: :@namespace
+
+      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 label(**attributes)
+          Components::LabelComponent.new(self, attributes: attributes)
+        end
+
+        def textarea(**attributes)
+          Components::TextareaComponent.new(self, attributes: attributes)
+        end
+
+        def title
+          key.to_s.titleize
+        end
+      end
+
+      def initialize(model, action: nil, method: nil)
+        @model = model
+        @action = action
+        @method = method
+        @namespace = Namespace.root(model.model_name.param_key, object: model, field_class: self.class::Field)
+      end
+
+      def around_template(&)
+        form action: form_action, method: form_method do
+          authenticity_token_field
+          _method_field
+          super
+        end
+      end
+
+      def template(&block)
+        yield_content(&block)
+      end
+
+      def submit(value = submit_value)
+        input(
+          name: "commit",
+          type: "submit",
+          value: value
+        )
+      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 || @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 model.
+        def assign(params, to:, form: form_class)
+          to.tap do |model|
+            form.new(model).tap do |form|
+              # 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
+            end
+          end
+        end
+
+        # Defaults to the form defined in `./app/views/*/form.rb`.
+        def form_class
+          self.controller_name.camelize.constantize::Form
+        end
+    end
+
+    module Components
+      class FieldComponent < ApplicationComponent
+        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 LabelComponent < FieldComponent
+        def template(&)
+          label(**attributes) { field.key.to_s.titleize }
+        end
+
+        def field_attributes
+          { for: dom.id }
+        end
+      end
+
+      class ButtonComponent < FieldComponent
+        def template(&block)
+          button(**attributes) { button_text }
+        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 InputComponent < FieldComponent
+        def template(&)
+          input(**attributes)
+        end
+
+        def field_attributes
+          { id: dom.id, name: dom.name, value: dom.value, type: type }
+        end
+
+        def type
+          case field.value
+          when URI
+            "url"
+          when Integer
+            "number"
+          when Date, DateTime
+            "date"
+          when Time
+            "time"
+          else
+            "text"
+          end
+        end
+      end
+
+      class TextareaComponent < FieldComponent
+        def template(&)
+          textarea(**attributes) { dom.value }
+        end
+
+        def field_attributes
+          { id: dom.id, name: dom.name }
+        end
+      end
+    end
+  end
+end

data/lib/superform/version.rb

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

data/lib/superform.rb

@@ -1,8 +1,223 @@
-# frozen_string_literal: true
-
-require_relative "superform/version"
-
 module Superform
   class Error < StandardError; end
-  # Your code goes here...
+
+  autoload :Rails, "superform/rails"
+
+  class DOM
+    def initialize(field:)
+      @field = field
+    end
+
+    def value
+      @field.value.to_s
+    end
+
+    def id
+      lineage.map(&:key).join("_")
+    end
+
+    def name
+      root, *names = keys
+      names.map { |name| "[#{name}]" }.unshift(root).join
+    end
+
+    def inspect
+      "<id=#{id.inspect} name=#{name.inspect} value=#{value.inspect}/>"
+    end
+
+    private
+
+    def keys
+      lineage.map do |node|
+        # If the parent of a field is a field, the name should be nil.
+        node.key unless node.parent.is_a? Field
+      end
+    end
+
+    def lineage
+      Enumerator.produce(@field, &:parent).take_while(&:itself).reverse
+    end
+  end
+
+  class Node
+    attr_reader :key, :parent
+
+    def initialize(key, parent:)
+      @key = key
+      @parent = parent
+    end
+  end
+
+  class Namespace < Node
+    include Enumerable
+
+    attr_reader :object
+
+    def initialize(key, parent:, object: nil, field_class: Field)
+      super(key, parent: parent)
+      @object = object
+      @field_class = field_class
+      @children = Hash.new
+      yield self if block_given?
+    end
+
+    def namespace(key, &block)
+      create_child(key, self.class, object: object_for(key: key), &block)
+    end
+
+    def field(key)
+      create_child(key, @field_class, object: object)
+    end
+
+    def collection(key, &block)
+      create_child(key, NamespaceCollection, &block)
+    end
+
+    def serialize
+      each_with_object Hash.new do |child, hash|
+        hash[child.key] = child.serialize
+      end
+    end
+
+    def each(&)
+      @children.values.each(&)
+    end
+
+    def assign(hash)
+      each do |child|
+        child.assign hash[child.key]
+      end
+      self
+    end
+
+    def self.root(*args, **kwargs, &block)
+      new(*args, parent: nil, **kwargs, &block)
+    end
+    private
+
+    def create_child(key, child_class, **options, &block)
+      fetch(key) { child_class.new(key, parent: self, **options, &block) }
+    end
+
+    def fetch(key, &build)
+      @children[key] ||= build.call
+    end
+
+    def object_for(key:)
+      @object.send(key) if @object.respond_to? key
+    end
+  end
+
+  class Field < Node
+    attr_reader :dom
+
+    def initialize(key, parent:, object: nil, value: nil)
+      super key, parent: parent
+      @object = object
+      @value = value
+      @dom = DOM.new(field: self)
+    end
+
+    def value
+      if @object and @object.respond_to? @key
+        @object.send @key
+      else
+        @value
+      end
+    end
+    alias :serialize :value
+
+    def assign(value)
+      if @object and @object.respond_to? "#{@key}="
+        @object.send "#{@key}=", value
+      else
+        @value = value
+      end
+    end
+    alias :value= :assign
+
+    # Wraps a field that's an array of values with a bunch of fields
+    # that are indexed with the array's index.
+    def collection(&)
+      @collection ||= FieldCollection.new(field: self, &)
+    end
+  end
+
+  class FieldCollection
+    include Enumerable
+
+    def initialize(field:, &)
+      @field = field
+      @index = 0
+      each(&) if block_given?
+    end
+
+    def each(&)
+      values.each do |value|
+        yield build_field(value: value)
+      end
+    end
+
+    def field
+      build_field
+    end
+
+    def values
+      Array(@field.value)
+    end
+
+    private
+
+    def build_field(**kwargs)
+      @field.class.new(@index += 1, parent: @field, **kwargs)
+    end
+  end
+
+  class NamespaceCollection < Node
+    include Enumerable
+
+    def initialize(key, parent:, &template)
+      super(key, parent: parent)
+      @template = template
+      @namespaces = enumerate(parent_collection)
+    end
+
+    def serialize
+      map(&:serialize)
+    end
+
+    def assign(array)
+      # The problem with zip-ing the array is if I need to add new
+      # elements to it and wrap it in the namespace.
+      zip(array) do |namespace, hash|
+        namespace.assign hash
+      end
+    end
+
+    def each(&)
+      @namespaces.each(&)
+    end
+
+    private
+
+    def enumerate(enumerator)
+      Enumerator.new do |y|
+        enumerator.each.with_index do |object, key|
+          y << build_namespace(key, object: object)
+        end
+      end
+    end
+
+    def build_namespace(index, **kwargs)
+      parent.class.new(index, parent: self, **kwargs, &@template)
+    end
+
+    def parent_collection
+      @parent.object.send @key
+    end
+  end
 end
+
+def Superform(...)
+  Superform::Namespace.root(...)
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: superform
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Brad Gessler
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-06-24 00:00:00.000000000 Z
-dependencies: []
+date: 2023-07-21 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'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: A better way to customize and build forms for your Rails application
 email:
 - bradgessler@gmail.com
@@ -21,10 +35,16 @@ files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/generators/superform/install/USAGE
+- lib/generators/superform/install/install_generator.rb
+- lib/generators/superform/install/templates/application_form.rb
 - lib/superform.rb
+- lib/superform/rails.rb
 - lib/superform/version.rb
 - sig/superform.rbs
 homepage: https://github.com/rubymonolith/superform