phlexi-form 0.2.0

data/lib/phlexi/form/structure/field_builder.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module Phlexi
+  module Form
+    module Structure
+      class FieldBuilder < Node
+        include Phlex::Helpers
+        include FieldOptions::Validators
+        include FieldOptions::Labels
+        include FieldOptions::Hints
+        include FieldOptions::Errors
+        include FieldOptions::Type
+        include FieldOptions::Collection
+        include FieldOptions::Placeholder
+        include FieldOptions::Required
+        include FieldOptions::Autofocus
+        include FieldOptions::Disabled
+        include FieldOptions::Readonly
+        include FieldOptions::Length
+        include FieldOptions::MinMax
+        include FieldOptions::Pattern
+        include FieldOptions::Multiple
+        include FieldOptions::Limit
+
+        attr_reader :dom, :options, :object, :attributes
+        attr_accessor :value
+        alias_method :serialize, :value
+        alias_method :assign, :value=
+
+        def initialize(key, parent:, object: nil, value: :__i_form_builder_nil_value_i__, attributes: {}, **options)
+          key = :"#{key}"
+          super(key, parent: parent)
+
+          @object = object
+          @value = if value != :__i_form_builder_nil_value_i__
+            value
+          else
+            object.respond_to?(key) ? object.send(key) : nil
+          end
+          @attributes = attributes
+          @options = options
+          @dom = Structure::DOM.new(field: self)
+        end
+
+        def label_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          label_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :label)
+          Components::Label.new(self, class: label_class, **attributes)
+        end
+
+        def input_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          input_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :input)
+          Components::Input.new(self, class: input_class, **attributes)
+        end
+
+        def checkbox_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          checkbox_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :checkbox)
+          Components::Checkbox.new(self, class: checkbox_class, **attributes)
+        end
+
+        def collection_checkboxes_tag(**attributes, &)
+          attributes = self.attributes.deep_merge(attributes)
+          collection_checkboxes_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :collection_checkboxes)
+          Components::CollectionCheckboxes.new(self, class: collection_checkboxes_class, **attributes, &)
+        end
+
+        def radio_button_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          radio_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :radio)
+          Components::RadioButton.new(self, class: radio_class, **attributes)
+        end
+
+        def collection_radio_buttons_tag(**attributes, &)
+          attributes = self.attributes.deep_merge(attributes)
+          collection_radio_buttons_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :collection_radio_buttons)
+          Components::CollectionRadioButtons.new(self, class: collection_radio_buttons_class, **attributes, &)
+        end
+
+        def textarea_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          textarea_class = attributes.delete(:class) || themed_input(attributes.delete(:theme) || :textarea)
+          Components::Textarea.new(self, class: textarea_class, **attributes)
+        end
+
+        def select_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          select_class = attributes.delete(:class) || themed_input(attributes.delete(:theme) || :select)
+          Components::Select.new(self, class: select_class, **attributes)
+        end
+
+        def hint_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          hint_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :hint)
+          Components::Hint.new(self, class: hint_class, **attributes)
+        end
+
+        def error_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          error_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :error)
+          Components::Error.new(self, class: error_class, **attributes)
+        end
+
+        def full_error_tag(**attributes)
+          attributes = self.attributes.deep_merge(attributes)
+          error_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :error)
+          Components::FullError.new(self, class: error_class, **attributes)
+        end
+
+        def wrapped(inner: {}, **attributes, &)
+          attributes = self.attributes.deep_merge(attributes)
+          wrapper_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :wrapper)
+          inner[:class] = inner.delete(:class) || themed(inner.delete(:theme) || :inner_wrapper)
+          Components::Wrapper.new(self, class: wrapper_class, inner:, **attributes, &)
+        end
+
+        # Wraps a field that's an array of values with a bunch of fields
+        #
+        # @example Usage
+        #
+        # ```ruby
+        # Phlexi::Form.new User.new do
+        #   render field(:email).input_tag
+        #   render field(:name).input_tag
+        #   field(:roles).multi([["Admin", "admin"], ["Editor", "editor"]]) do |a|
+        #     render a.label_tag
+        #     render a.input_tag # => name="user[roles][]"
+        #   end
+        # end
+        # ```
+        # The object within the block is a `FieldCollection` object
+        def multi(range = nil, &)
+          range ||= Array(collection)
+          FieldCollection.new(field: self, range:, &)
+        end
+
+        private
+
+        def themed(component)
+          tokens(resolve_theme(component), resolve_validity_theme(component)).presence if component
+        end
+
+        def themed_input(input_component)
+          themed(input_component) || themed(:input) if input_component
+        end
+
+        def resolve_theme(property)
+          options[property] || theme[property]
+        end
+
+        def resolve_validity_theme(property)
+          validity_property = if has_errors?
+            # Apply invalid class if the object has errors
+            :"invalid_#{property}"
+          elsif (object.respond_to?(:persisted?) && object.persisted?) && (object.respond_to?(:errors) && !object.errors.empty?)
+            # The object is persisted, has been validated, and there are errors (not empty), but this field has no errors
+            # Apply valid class
+            :"valid_#{property}"
+          else
+            :"neutral_#{property}"
+          end
+
+          resolve_theme(validity_property)
+        end
+
+        def theme
+          @theme ||= {
+            # # label themes
+            # label: "md:w-1/6 mt-2 block mb-2 text-sm font-medium",
+            # invalid_label: "text-red-700 dark:text-red-500",
+            # valid_label: "text-green-700 dark:text-green-500",
+            # neutral_label: "text-gray-700 dark:text-white",
+            # # input themes
+            # input: "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700",
+            # invalid_input: "bg-red-50 border-red-500 dark:border-red-500 text-red-900 dark:text-red-500 placeholder-red-700 dark:placeholder-red-500 focus:ring-red-500 focus:border-red-500",
+            # valid_input: "bg-green-50 border-green-500 dark:border-green-500 text-green-900 dark:text-green-400 placeholder-green-700 dark:placeholder-green-500 focus:ring-green-500 focus:border-green-500",
+            # neutral_input: "border-gray-300 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white focus:ring-primary-500 focus:border-primary-500",
+            # # hint themes
+            # hint: "mt-2 text-sm text-gray-500 dark:text-gray-200",
+            # # error themes
+            # error: "mt-2 text-sm text-red-600 dark:text-red-500",
+            # # wrapper themes
+            # wrapper: "flex flex-col md:flex-row items-start space-y-2 md:space-y-0 md:space-x-2 mb-4",
+            # inner_wrapper: "md:w-5/6 w-full",
+          }.freeze
+        end
+
+        def reflection = nil
+
+        def has_value?
+          value.present?
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/structure/field_collection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Structure
+      class FieldCollection
+        include Enumerable
+
+        class Builder
+          attr_reader :key
+
+          def initialize(key, field)
+            @key = key.to_s
+            @field = field
+          end
+
+          def field(**)
+            @field.class.new(key, attributes: @field.attributes, **, parent: @field).tap do |field|
+              yield field if block_given?
+            end
+          end
+        end
+
+        def initialize(field:, range:, &)
+          @field = field
+          @range = case range
+          when Range, Array
+            range
+          when Integer
+            1..range
+          else
+            range.to_a
+          end
+          each(&) if block_given?
+        end
+
+        def each(&)
+          @range.each do |key|
+            yield Builder.new(key, @field)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/structure/namespace.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Structure
+      # 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 < Structure::Node
+        include Enumerable
+
+        attr_reader :builder_klass, :object
+
+        def initialize(key, parent:, object: nil, builder_klass: Field)
+          super(key, parent: parent)
+          @object = object
+          @builder_klass = builder_klass
+          @children = {}
+          yield self if block_given?
+        end
+
+        def field(key, **attributes)
+          create_child(key, attributes.delete(:builder_klass) || builder_klass, object: object, **attributes).tap do |field|
+            yield field if block_given?
+          end
+        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.nest_one :permission do |permission|
+        #     form.field :role
+        #   end
+        # end
+        # ```
+        def nest_one(key, object: nil, &)
+          object ||= object_for(key: key)
+          create_child(key, self.class, object:, builder_klass:, &)
+        end
+
+        # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
+        # an enumerable or array of `Address` classes:
+        #
+        # ```ruby
+        # Phlexi::Form.new User.new do |form|
+        #   render form.field(:email).input_tag
+        #   render form.field(:name).input_tag
+        #   form.nest_many :addresses do |address|
+        #     render address.field(:street).input_tag
+        #     render address.field(:state).input_tag
+        #     render address.field(:zip).input_tag
+        #   end
+        # end
+        # ```
+        # The object within the block is a `Namespace` object that maps each object within the enumerable
+        # to another `Namespace` or `Field`.
+        def nest_many(key, collection: nil, &)
+          collection ||= Array(object_for(key: key))
+          create_child(key, NamespaceCollection, collection:, &)
+        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({}) 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
+    end
+  end
+end

data/lib/phlexi/form/structure/namespace_collection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Structure
+      class NamespaceCollection < Node
+        include Enumerable
+
+        def initialize(key, parent:, collection: nil, &)
+          super(key, parent: parent)
+
+          @namespaces = enumerate(collection)
+          each(&) if block_given?
+        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, builder_klass: parent.builder_klass, **)
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/structure/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Structure
+      # 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
+    end
+  end
+end

data/lib/phlexi/form/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    VERSION = "0.2.0"
+  end
+end

data/lib/phlexi/form.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+require "phlex"
+
+module Phlexi
+  module Form
+    Loader = Zeitwerk::Loader.new.tap do |loader|
+      loader.tag = File.basename(__FILE__, ".rb")
+      loader.inflector.inflect(
+        "phlexi-form" => "Phlexi",
+        "phlexi" => "Phlexi",
+        "dom" => "DOM"
+      )
+      loader.push_dir(File.expand_path("..", __dir__))
+      loader.ignore(File.expand_path("../generators", __dir__))
+      loader.setup
+    end
+
+    BaseComponent = (defined?(::ApplicationComponent) ? ::ApplicationComponent : Phlex::HTML)
+
+    class Error < StandardError; end
+  end
+end
+
+def Phlexi.Form(...)
+  Phlexi::Form::Base.new(...)
+end

data/lib/phlexi-form.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "phlexi/form"

data/sig/phlexi/form.rbs

@@ -0,0 +1,6 @@
+module Phlexi
+  module Form
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end