superform 0.5.0 → 0.6.0

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.0"
+  VERSION = "0.6.0"
 end

data/lib/superform.rb

@@ -3,304 +3,13 @@ require "zeitwerk"
 module Superform
   Loader = Zeitwerk::Loader.for_gem.tap do |loader|
     loader.ignore "#{__dir__}/generators"
+    loader.inflector.inflect(
+      'dom' => 'DOM'
+    )
     loader.setup
   end
 
   class Error < StandardError; end
-
-  # Generates DOM IDs, names, etc. for a Field, Namespace, or Node based on
-  # norms that were established by Rails. These can be used outsidef or Rails in
-  # other Ruby web frameworks since it has now dependencies on Rails.
-  class DOM
-    def initialize(field:)
-      @field = field
-    end
-
-    # Converts the value of the field to a String, which is required to work
-    # with Phlex. Assumes that `Object#to_s` emits a format suitable for the web form.
-    def value
-      @field.value.to_s
-    end
-
-    # Walks from the current node to the parent node, grabs the names, and seperates
-    # them with a `_` for a DOM ID. One limitation of this approach is if multiple forms
-    # exist on the same page, the ID may be duplicate.
-    def id
-      lineage.map(&:key).join("_")
-    end
-
-    # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got
-    # it from). All node names, except the parent node, are wrapped in a `[]` and collections
-    # are left empty. For example, `user[addresses][][street]` would be created for a form with
-    # data shaped like `{user: {addresses: [{street: "Sesame Street"}]}}`.
-    def name
-      root, *names = keys
-      names.map { |name| "[#{name}]" }.unshift(root).join
-    end
-
-    # Emit the id, name, and value in an HTML tag-ish that doesnt have an element.
-    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
-
-    # One-liner way of walking from the current node all the way up to the parent.
-    def lineage
-      Enumerator.produce(@field, &:parent).take_while(&:itself).reverse
-    end
-  end
-
-
-  # Superclass for Namespace and Field classes. Not much to it other than it has a `name`
-  # and `parent` node attribute. Think of it as a tree.
-  class Node
-    attr_reader :key, :parent
-
-    def initialize(key, parent:)
-      @key = key
-      @parent = parent
-    end
-  end
-
-  # A Namespace maps and object to values, but doesn't actually have a value itself. For
-  # example, a `User` object or ActiveRecord model could be passed into the `:user` namespace.
-  # To access the values on a Namespace, the `field` can be called for single values.
-  #
-  # Additionally, to access namespaces within a namespace, such as if a `User has_many :addresses` in
-  # ActiveRecord, the `namespace` method can be called which will return another Namespace object and
-  # set the current Namespace as the parent.
-  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
-
-    # Creates a `Namespace` child instance with the parent set to the current instance, adds to
-    # the `@children` Hash to ensure duplicate child namespaces aren't created, then calls the
-    # method on the `@object` to get the child object to pass into that namespace.
-    #
-    # For example, if a `User#permission` returns a `Permission` object, we could map that to a
-    # form like this:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.namespace :permission do |permission|
-    #     form.field :role
-    #   end
-    # end
-    # ```
-    def namespace(key, &block)
-      create_child(key, self.class, object: object_for(key: key), &block)
-    end
-
-    # Maps the `Object#proprety` and `Object#property=` to a field in a web form that can be
-    # read and set by the form. For example, a User form might look like this:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.field :email
-    #   form.field :name
-    # end
-    # ```
-    def field(key)
-      create_child(key, @field_class, object: object).tap do |field|
-        yield field if block_given?
-      end
-    end
-
-    # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
-    # an enumerable or array of `Address` classes:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.field :email
-    #   form.field :name
-    #   form.collection :addresses do |address|
-    #     address.field(:street)
-    #     address.field(:state)
-    #     address.field(:zip)
-    #   end
-    # end
-    # ```
-    # The object within the block is a `Namespace` object that maps each object within the enumerable
-    # to another `Namespace` or `Field`.
-    def collection(key, &)
-      create_child(key, NamespaceCollection, &)
-    end
-
-    # Creates a Hash of Hashes and Arrays that represent the fields and collections of the Superform.
-    # This can be used to safely update ActiveRecord objects without the need for Strong Parameters.
-    # You will want to make sure that all the fields displayed in the form are ones that you're OK updating
-    # from the generated hash.
-    def serialize
-      each_with_object Hash.new do |child, hash|
-        hash[child.key] = child.serialize
-      end
-    end
-
-    # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
-    # objects.
-    def each(&)
-      @children.values.each(&)
-    end
-
-    # Assigns a hash to the current namespace and children namespace.
-    def assign(hash)
-      each do |child|
-        child.assign hash[child.key]
-      end
-      self
-    end
-
-    # Creates a root Namespace, which is essentially a form.
-    def self.root(*, **, &)
-      new(*, parent: nil, **, &)
-    end
-
-    protected
-
-    # Calls the corresponding method on the object for the `key` name, if it exists. For example
-    # if the `key` is `email` on `User`, this method would call `User#email` if the method is
-    # present.
-    #
-    # This method could be overwritten if the mapping between the `@object` and `key` name is not
-    # a method call. For example, a `Hash` would be accessed via `user[:email]` instead of `user.send(:email)`
-    def object_for(key:)
-      @object.send(key) if @object.respond_to? key
-    end
-
-    private
-
-    # Checks if the child exists. If it does then it returns that. If it doesn't, it will
-    # build the child.
-    def create_child(key, child_class, **kwargs, &block)
-      @children.fetch(key) { @children[key] = child_class.new(key, parent: self, **kwargs, &block) }
-    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(**)
-      @field.class.new(@index += 1, parent: @field, **)
-    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, **)
-      parent.class.new(index, parent: self, **, &@template)
-    end
-
-    def parent_collection
-      @parent.object.send @key
-    end
-  end
 end
 
 def Superform(...)