protos-protoform 0.0.1

data/lib/protoform/namespace.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Protoform
+  # 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:)
+      @object = object
+      @field_class = field_class
+      @children = {}
+      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
+    # Protoform :user, object: User.new do |form|
+    #   form.namespace :permission do |permission|
+    #     form.field :role
+    #   end
+    # end
+    # ```
+    def namespace(key, &block)
+      create_child(
+        key:,
+        child_class: self.class,
+        field_class: @field_class,
+        object: object_for(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
+    # Protoform :user, object: User.new do |form|
+    #   form.field :email
+    #   form.field :name
+    # end
+    # ```
+    def field(key)
+      create_child(
+        key:,
+        child_class: @field_class,
+        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
+    # Protoform :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, &block)
+      create_child(
+        key:,
+        child_class: NamespaceCollection,
+        field_class: @field_class,
+        &block
+      )
+    end
+
+    # Creates a Hash of Hashes and Arrays that represent the fields and
+    # collections of the Protoform. 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(&block)
+      @children.values.each(&block)
+    end
+
+    # Assigns a hash to the current namespace and children namespace.
+    def assign(hash)
+      tap do
+        each do |child|
+          child.assign hash[child.key] if hash.key? child.key
+        end
+      end
+    end
+
+    # Creates a root Namespace, which is essentially a form.
+    def self.root(*args, **kwargs, &block)
+      new(*args, parent: nil, **kwargs, &block)
+    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)
+      if (child = @children.fetch(key, nil))
+        # ensure that found children are also yielded
+        child.tap { yield child if block }
+      else
+        # new children added to hash and block passed to constructor
+        @children[key] = child_class.new(
+          key,
+          parent: self,
+          **kwargs,
+          &block
+        )
+      end
+    end
+  end
+end

data/lib/protoform/namespace_collection.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Protoform
+  class NamespaceCollection < Node
+    include Enumerable
+
+    def initialize(key, parent:, field_class:, &template)
+      super(key, parent:)
+      @template = template
+      @field_class = field_class
+      @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(&block)
+      @namespaces.each(&block)
+    end
+
+    private
+
+    def enumerate(enumerator)
+      Enumerator.new do |y|
+        enumerator.each.with_index do |object, key|
+          y << build_namespace(key, object:)
+        end
+      end
+    end
+
+    def build_namespace(index, **kwargs)
+      parent.class.new(
+        index,
+        parent: self,
+        field_class: @field_class,
+        **kwargs,
+        &@template
+      )
+    end
+
+    def parent_collection
+      raise_missing_object unless @parent.respond_to? :object
+      @parent.object.send(@key).tap do |value|
+        raise_invalid_enumerator(value) unless value.respond_to? :each
+      end
+    end
+
+    def raise_invalid_enumerator(value)
+      raise(
+        ArgumentError,
+        <<~ERROR
+          #{@parent.object.class} did not return something that responds to
+          :each for #{@key}. #{self.class} requires the model to return
+          something that can be enumerated for #{@key}.
+          Got #{value.class}: #{value.inspect} instead.
+        ERROR
+      )
+    end
+
+    def raise_missing_object
+      raise(
+        ArgumentError,
+        "Parent of a #{self.class} must respond to :object, " \
+        "#{@parent.class} does not"
+      )
+    end
+  end
+end

data/lib/protoform/node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Protoform
+  # 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

data/lib/protoform/rails/components/button.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Button < FieldComponent
+        def view_template(&content)
+          content ||= proc { button_text }
+          button(**attrs, &content)
+        end
+
+        private
+
+        def button_text
+          attrs.fetch(:value, dom.value).titleize
+        end
+
+        def default_attrs
+          {
+            id: dom.id,
+            name: dom.name,
+            value: dom.value
+          }
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/checkbox.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Checkbox < 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", **attrs)
+        end
+
+        private
+
+        def default_attrs
+          {
+            id: dom.id,
+            name: dom.name,
+            checked: field.value
+          }
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Component < Protoform::Rails::Component
+        param :field
+
+        def dom
+          field.dom
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/field_component.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class FieldComponent < Component
+        private
+
+        def default_attrs
+          {
+            id: dom.id,
+            name: dom.name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/input.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Input < FieldComponent
+        option :type, reader: false, default: -> { inferred_type }
+
+        def view_template
+          input(**attrs)
+        end
+
+        private
+
+        def default_attrs
+          {
+            id: dom.id,
+            name: dom.name,
+            type: @type
+          }.tap do |hash|
+            hash[:value] = field.value unless @type.to_sym == :file
+          end
+        end
+
+        def inferred_type
+          case field.value
+          when URI
+            "url"
+          when Integer
+            "number"
+          when Date, DateTime
+            "date"
+          when Time
+            "time"
+          else
+            "text"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/label.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Label < Component
+        def view_template(&content)
+          content ||= proc { field.key.to_s.titleize }
+          label(**attrs, &content)
+        end
+
+        private
+
+        def default_attrs
+          {
+            for: dom.id
+          }
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/select.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Select < FieldComponent
+        option :collection, default: -> { [] }
+        option :include_blank, default: -> { true }
+        option :multiple, reader: false, default: -> { false }
+
+        def view_template(&options)
+          name = @multiple ? "#{attrs[:name]}[]" : attrs[:name]
+
+          if @multiple
+            input(
+              name:,
+              type: :hidden,
+              value: ""
+            )
+          end
+
+          if options
+            select(multiple: @multiple, **attrs, name:, &options)
+          else
+            select(multiple: @multiple, **attrs, name:) do
+              blank_option
+              options(*@collection)
+            end
+          end
+        end
+
+        def options(*collection)
+          map_options(collection).each do |key, value|
+            option(
+              selected: selected_value_for(key) ? "selected" : false,
+              value: key
+            ) { value }
+          end
+        end
+
+        def blank_option(&block)
+          option(selected: field.value.nil?, &block)
+        end
+
+        def true_option(&block)
+          option(selected: field.value == true, value: true.to_s, &block)
+        end
+
+        def false_option(&block)
+          option(selected: field.value == false, value: false.to_s, &block)
+        end
+
+        protected
+
+        def selected_value_for(key)
+          case field.value
+          when String, Symbol
+            field.value.to_s == key.to_s
+          when Array
+            field.value.include?(key)
+          else
+            field.value == key
+          end
+        end
+
+        def map_options(collection)
+          OptionMapper.new(collection)
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/components/textarea.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    module Components
+      class Textarea < FieldComponent
+        def view_template(&content)
+          content ||= proc { dom.value }
+          textarea(**attrs, &content)
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/form/field.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    class Form
+      # 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 < Protoform::Rails::Form
+      #   class MyLabel < Protoform::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 < Protoform::Field
+        def button(...)
+          Components::Button.new(self, ...)
+        end
+
+        def input(...)
+          Components::Input.new(self, ...)
+        end
+
+        def checkbox(...)
+          Components::Checkbox.new(self, ...)
+        end
+
+        def label(...)
+          Components::Label.new(self, ...)
+        end
+
+        def textarea(...)
+          Components::Textarea.new(self, ...)
+        end
+
+        def select(*collection, **attributes, &block)
+          Components::Select.new(
+            self,
+            collection:,
+            **attributes,
+            &block
+          )
+        end
+
+        def title
+          key.to_s.titleize
+        end
+      end
+    end
+  end
+end

data/lib/protoform/rails/form.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Protoform
+  module Rails
+    Component = ::ApplicationComponent
+    # A Protos::Component class that accepts a model and sets
+    # a `Protoform::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
+      param :model, reader: false
+      option :helpers, reader: false, default: -> {}
+      option :action, reader: false, default: -> {}
+      option :method, reader: false, default: -> {}
+      option :namespace, reader: false, default: -> do
+        Namespace.root(key, object: @model, field_class: self.class::Field)
+      end
+
+      def field(...)
+        @namespace.field(...)
+      end
+
+      def collection(...)
+        @namespace.collection(...)
+      end
+
+      def namespace(...)
+        @namespace.namespace(...)
+      end
+
+      def assign(...)
+        @namespace.assign(...)
+      end
+
+      def serialize(...)
+        @namespace.serialize(...)
+      end
+
+      def around_template(&block)
+        form_tag do
+          authenticity_token_field
+          _method_field
+          super
+        end
+      end
+
+      def form_tag(&block)
+        form action:, method: form_method, **attrs, &block
+      end
+
+      def view_template(&block)
+        yield_content(&block)
+      end
+
+      def submit(value = submit_value, **attributes)
+        input(
+          **attributes.merge(
+            name: "commit",
+            type: "submit",
+            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 || (@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 action
+        @action ||= helpers.url_for(action: resource_action)
+      end
+
+      def form_method
+        @method.to_s.downcase == "get" ? "get" : "post"
+      end
+
+      private
+
+      def helpers
+        @helpers ||= super
+      end
+    end
+  end
+end