action_form 0.1.0

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/action_form/base.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module ActionForm
+  # Base class for ActionForm components that provides form building functionality
+  # and integrates with Phlex for HTML rendering.
+  class Base < ::Phlex::HTML
+    include ActionForm::SchemaDSL
+    include ActionForm::ElementsDSL
+    include ActionForm::Rendering
+
+    attr_reader :elements_instances, :scope, :object, :html_options, :errors
+
+    class << self
+      attr_writer :elements, :scope
+
+      def subform_class
+        ActionForm::Subform
+      end
+
+      def scope(scope = nil)
+        return @scope unless scope
+
+        @scope = scope
+      end
+
+      def inherited(subclass)
+        super
+        subclass.elements = elements.dup
+        subclass.scope = scope.dup
+      end
+    end
+
+    def initialize(object: nil, scope: self.class.scope, params: nil, **html_options)
+      super()
+      @object = object
+      @scope ||= scope
+      @params = @scope && params.respond_to?(@scope) ? params.public_send(@scope) : params
+      @html_options = html_options
+      @elements_instances = []
+      build_from_object
+    end
+
+    def build_from_object
+      self.class.elements.each do |name, element_definition|
+        if element_definition < ActionForm::SubformsCollection
+          @elements_instances << build_many_subforms(name, element_definition)
+          @elements_instances.last << build_subform_template(name, element_definition.subform_definition)
+        elsif element_definition < ActionForm::Subform
+          @elements_instances << build_subform(name, element_definition)
+        elsif element_definition < ActionForm::Element
+          @elements_instances << element_definition.new(name, @params || @object, parent_name: @scope)
+        end
+      end
+    end
+
+    def view_template
+      render_form do
+        render_elements
+        render_submit
+      end
+    end
+
+    def render_in(view_context)
+      @_view_context = view_context
+      view_context.render html: call.html_safe
+    end
+
+    def helpers
+      @_view_context
+    end
+
+    private
+
+    def build_many_subforms(name, collection_definition)
+      collection = collection_definition.new(name)
+      Array(subform_value(name)).each.with_index do |item, index|
+        collection << build_subform(name, collection_definition.subform_definition, value: item, index: index)
+      end
+      collection
+    end
+
+    def subform_html_name(name, index: nil)
+      if index
+        @scope ? "#{@scope}[#{name}][#{index}]" : "[#{name}][#{index}]"
+      else
+        @scope ? "#{@scope}[#{name}]" : name
+      end
+    end
+
+    def subform_value(name)
+      @object.public_send(name)
+    end
+
+    def build_subform(name, form_definition, value: subform_value(name), index: nil)
+      html_name = subform_html_name(name, index: index)
+      form_definition.new(name: name, scope: html_name, model: value, index: index).tap do |subform|
+        subform.helpers = helpers
+      end
+    end
+
+    def build_subform_template(name, form_definition)
+      html_name = subform_html_name(name, index: "NEW_RECORD")
+      elements_keys = form_definition.elements.keys.push(:persisted?)
+      value = Struct.new(*elements_keys).new
+      form_definition.new(name: name, scope: html_name, model: value, template: true).tap do |subform|
+        subform.helpers = helpers
+      end
+    end
+  end
+end

data/lib/action_form/element.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module ActionForm
+  # Represents a form element with input/output configuration and HTML attributes
+  # rubocop:disable Metrics/ClassLength
+  class Element
+    attr_reader :name, :input_options, :output_options, :html_name, :html_id, :select_options, :tags, :errors_messages
+    attr_accessor :helpers
+
+    def initialize(name, object, parent_name: nil)
+      @name = name
+      @object = object
+      @html_name = build_html_name(name, parent_name)
+      @html_id = build_html_id(name, parent_name)
+      @tags = self.class.tags_list.dup
+      @errors_messages = extract_errors_messages(object, name)
+      tags.merge!(errors: errors_messages.any?)
+    end
+
+    class << self
+      def label_options
+        @label_options ||= [{ text: nil, display: true }, {}]
+      end
+
+      def select_options
+        @select_options ||= []
+      end
+
+      def output_options
+        @output_options ||= {}
+      end
+
+      def input_options
+        @input_options ||= {}
+      end
+
+      def tags_list
+        @tags_list ||= {}
+      end
+
+      def input(type:, **options)
+        @input_options = { type: type }.merge(options)
+        tags_list.merge!(input: type)
+      end
+
+      def output(type:, **options)
+        @output_options = { type: type }.merge(options)
+        tags_list.merge!(output: type)
+      end
+
+      def options(collection)
+        @select_options = collection
+        tags_list.merge!(options: true)
+      end
+
+      def label(text: nil, display: true, **html_options)
+        @label_options = [{ text: text, display: display }, html_options]
+      end
+
+      def tags(**tags_list)
+        tags_list.merge!(tags_list)
+      end
+    end
+
+    def label_text
+      self.class.label_options.first[:text] || name.to_s.tr("_", " ").capitalize
+    end
+
+    def label_html_attributes
+      { for: html_id }.merge(self.class.label_options.last)
+    end
+
+    def html_value
+      if input_type == :checkbox
+        value ? "1" : "0"
+      elsif detached?
+        self.class.input_options[:value]
+      elsif object.is_a?(EasyParams::Base)
+        object.public_send(name)
+      else
+        value.to_s
+      end
+    end
+
+    def html_checked
+      return unless input_type == :checkbox
+
+      value
+    end
+
+    def input_html_attributes # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
+      attrs = self.class.input_options.dup
+      attrs[:name] ||= html_name
+      attrs[:id] ||= html_id
+      attrs[:value] ||= html_value
+      attrs[:checked] ||= html_checked
+      attrs[:disabled] ||= disabled?
+      attrs[:readonly] ||= readonly?
+      unless input_tag?
+        attrs.delete(:type)
+        attrs.delete(:value)
+      end
+      attrs
+    end
+
+    def value
+      return unless object
+
+      object.public_send(name)
+    end
+
+    def render?
+      true
+    end
+
+    def detached?
+      false
+    end
+
+    def disabled?
+      false
+    end
+
+    def readonly?
+      false
+    end
+
+    def input_type
+      self.class.input_options[:type].to_sym
+    end
+
+    private
+
+    attr_reader :object
+
+    def input_tag?
+      !%i[select textarea].include?(input_type)
+    end
+
+    def build_html_name(name, parent_name)
+      parent_name ? "#{parent_name}[#{name}]" : name
+    end
+
+    def build_html_id(name, parent_name)
+      parent_name.to_s.split(/\[|\]/).reject(&:blank?).push(name).compact.join("_")
+    end
+
+    def extract_errors_messages(object, name)
+      (object.respond_to?(:errors) && object&.errors&.messages_for(name)) || []
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end

data/lib/action_form/elements_dsl.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActionForm
+  # Provides a DSL for defining form elements with input and output configurations.
+  # This module allows form classes to define elements using a simple block syntax.
+  # Elements can be configured with input types, output formats, labels and other options.
+  #
+  # @example
+  #   class UserForm < ActionForm::Base
+  #     element :name do
+  #       input type: :text
+  #       label text: "Full Name"
+  #     end
+  #   end
+  module ElementsDSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods # rubocop:disable Style/Documentation
+      def elements
+        @elements ||= {}
+      end
+
+      # TODO: add support for outputless elements
+      def element(name, &block)
+        elements[name] = Class.new(ActionForm::Element)
+        elements[name].class_eval(&block)
+      end
+
+      def many(name, default: nil, &block)
+        subform_definition = Class.new(ActionForm::SubformsCollection)
+        subform_definition.host_class = self
+        subform_definition.class_eval(&block) if block
+        elements[name] = subform_definition
+        elements[name].default = default if default
+      end
+
+      def subform(name, default: nil, &block)
+        elements[name] = Class.new(subform_class)
+        elements[name].class_eval(&block)
+        elements[name].default = default if default
+      end
+    end
+  end
+end

data/lib/action_form/input.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActionForm
+  # Represents a form element with input/output configuration and HTML attributes
+  class Input < Phlex::HTML
+    attr_reader :element, :html_attributes
+
+    def initialize(element, **html_attributes)
+      super()
+      @element = element
+      @html_attributes = html_attributes
+    end
+
+    def view_template
+      if %i[checkbox radio select textarea].include?(element.input_type)
+        send("render_#{element.input_type}")
+      else
+        input(**mix(element.input_html_attributes, html_attributes))
+      end
+    end
+
+    private
+
+    def render_checkbox # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      if element.class.select_options.any?
+        element.class.select_options.each do |value, label_text|
+          checkbox_id = "#{element.html_id}_#{value}"
+          checkbox_attrs = element.input_html_attributes.merge(
+            value: value,
+            id: checkbox_id,
+            name: "#{element.html_name}[]",
+            checked: Array(element.value).include?(value)
+          )
+
+          input(**mix(checkbox_attrs, html_attributes))
+          label(**element.label_html_attributes, for: checkbox_id) { label_text }
+        end
+      else
+        input(name: element.html_name, type: "hidden", value: "0", autocomplete: "off")
+        input(**mix(element.input_html_attributes, html_attributes), type: "checkbox", value: "1")
+      end
+    end
+
+    def render_radio
+      element.class.select_options.each do |value, label_text|
+        label(**element.label_html_attributes) { label_text }
+        input(**mix(element.input_html_attributes, html_attributes), type: "radio", value: value,
+                                                                     checked: value == element.value)
+      end
+    end
+
+    def render_select
+      select(**mix(element.input_html_attributes, html_attributes)) do
+        element.class.select_options.each do |value, label_text|
+          option(value: value, selected: option_selected?(value)) { label_text }
+        end
+      end
+    end
+
+    def render_textarea
+      textarea(**mix(element.input_html_attributes, html_attributes)) { element.value }
+    end
+
+    def option_selected?(value)
+      if element.class.input_options[:multiple]
+        Array(element.value).include?(value)
+      else
+        value == element.value
+      end
+    end
+  end
+end

data/lib/action_form/rails/base.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "ostruct"
+
+module ActionForm
+  module Rails
+    # RailsForm class for ActionForm that handles Rails-specific form rendering.
+    # It integrates with Rails form helpers and provides a Rails-friendly interface
+    # for building forms.
+    class Base < ActionForm::Base
+      include ActionForm::Rails::Rendering
+
+      def self.subform_class
+        ActionForm::Rails::Subform
+      end
+
+      attr_reader :namespaced_model
+
+      def initialize(model: nil, scope: self.class.scope, params: nil, **html_options)
+        @namespaced_model = model
+        @object = model.is_a?(Array) ? Array(model).last : model
+        @scope = scope.nil? && @object.nil? ? nil : (scope || param_key)
+        super(object: @object, scope: @scope, params: params, **html_options)
+      end
+
+      class << self
+        def resource_model(model = nil)
+          return @resource_model unless model
+
+          @resource_model = model
+          @scope = model.model_name.param_key.to_sym
+        end
+
+        def params_definition(scope: self.scope)
+          return super unless scope
+
+          @params_definitions ||= Hash.new do |h, key|
+            h[key] = begin
+              klass = super
+              Class.new(params_class) { has scope, klass }
+            end
+          end
+          @params_definitions[scope]
+        end
+
+        def many(name, default: nil, &block)
+          super
+          elements[name].subform_definition.add_primary_key_element
+          elements[name].subform_definition.add_delete_element
+        end
+
+        def subform(name, default: nil, &block)
+          super
+          elements[name].add_primary_key_element
+        end
+      end
+
+      def view_template
+        render_form do
+          render_elements
+          render_submit
+        end
+      end
+
+      def with_params(form_params)
+        self.class.new(model: @namespaced_model, scope: @scope, params: form_params, **html_options)
+      end
+
+      private
+
+      def subform_html_name(name, index: nil)
+        if index
+          @scope ? "#{@scope}[#{name}_attributes][#{index}]" : "[#{name}_attributes][#{index}]"
+        else
+          @scope ? "#{@scope}[#{name}_attributes]" : "#{name}_attributes"
+        end
+      end
+
+      def subform_value(name)
+        if @params
+          @params.send("#{name}_attributes")
+        else
+          @object.public_send(name)
+        end
+      end
+
+      def model_name
+        @object&.model_name
+      end
+
+      def param_key
+        model_name.param_key.to_sym
+      end
+
+      def resource_action
+        return :search if @object.nil?
+
+        @object.persisted? ? :update : :create
+      end
+
+      def http_method
+        return "get" if @object.nil?
+
+        @object.persisted? ? "patch" : "post"
+      end
+
+      def html_action
+        html_options[:action] ||= helpers.polymorphic_path(@namespaced_model)
+      end
+
+      def html_method
+        html_options[:method] = html_options[:method].to_s.downcase == "get" ? "get" : "post"
+      end
+    end
+  end
+end

data/lib/action_form/rails/rendering.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionForm
+  module Rails
+    # Rendering module for ActionForm Rails integration that provides form rendering functionality.
+    # Handles rendering of forms with error messages, authenticity tokens, UTF-8 encoding,
+    # and other Rails-specific form requirements. Also provides helper methods for rendering
+    # submit buttons and form elements.
+    module Rendering
+      def render_form(&block)
+        form(**{ method: html_method, action: html_action, "accept-charset" => "UTF-8" }, **@html_options) do
+          render_utf8_input
+          render_authenticity_token
+          render_method_input
+          yield if block
+        end
+      end
+
+      def render_authenticity_token
+        input(name: "authenticity_token", type: "hidden", value: helpers.form_authenticity_token)
+      end
+
+      def render_method_input
+        input(name: "_method", type: "hidden", value: http_method, autocomplete: "off")
+      end
+
+      def render_utf8_input
+        input(name: "utf8", type: "hidden", value: "✓", autocomplete: "off")
+      end
+
+      def render_submit(**html_attributes)
+        input(name: "commit", type: "submit", value: submit_value, **html_attributes)
+      end
+
+      private
+
+      def submit_value
+        "#{resource_action.to_s.capitalize} #{model_name}"
+      end
+    end
+  end
+end

data/lib/action_form/rails/subform.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActionForm
+  module Rails
+    # Subform class for ActionForm that handles nested form structures.
+    # It allows building forms within forms, supporting has_one and has_many relationships.
+    # Includes schema and element DSL functionality for defining form elements.
+    class Subform < ActionForm::Subform
+      class << self
+        def add_primary_key_element
+          return if elements.key?(:id)
+
+          element :id do
+            input(type: :hidden, autocomplete: :off)
+            output(type: :integer)
+
+            def render?
+              object.persisted? || (object.is_a?(EasyParams::Base) && !object.id.nil?)
+            end
+          end
+        end
+
+        def add_delete_element
+          element :_destroy do
+            input(type: :hidden, autocomplete: :off, value: "0")
+            output(type: :bool)
+
+            def render?
+              object.persisted? || (object.is_a?(EasyParams::Base) && !object._destroy.nil?)
+            end
+
+            def detached?
+              true
+            end
+          end
+        end
+      end
+
+      def html_class
+        object.id.nil? ? "new_#{name}" : super
+      end
+    end
+  end
+end

data/lib/action_form/rendering.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module ActionForm
+  # Provides methods for rendering form elements and forms
+  module Rendering
+    def render_elements(elements = elements_instances) # rubocop:disable Metrics/MethodLength
+      elements.select(&:render?).each do |element|
+        element.helpers = helpers
+        if element.is_a?(SubformsCollection)
+          render_many_subforms(element)
+        elsif element.is_a?(Subform)
+          render_subform(element)
+        elsif element.input_type == :hidden
+          input(**element.input_html_attributes)
+        else
+          render_element(element)
+        end
+      end
+    end
+
+    def render_element(element)
+      render_label(element)
+      render_input(element)
+      render_inline_errors(element) if element.tags[:errors]
+    end
+
+    def render_label(element)
+      return if hide_label?(element)
+
+      label(**element.label_html_attributes) { element.label_text }
+    end
+
+    def render_input(element, **html_attributes)
+      render Input.new(element, **html_attributes)
+    end
+
+    def render_inline_errors(element)
+      div(class: "error-messages") { element.errors_messages.join(", ") }
+    end
+
+    def render_form(**html_attributes, &block)
+      form(**@html_options, **html_attributes, &block)
+    end
+
+    def render_subform(subform)
+      render(subform)
+    end
+
+    def render_many_subforms(subforms)
+      render(subforms)
+    end
+
+    def render_submit(**html_attributes)
+      input(name: "commit", type: "submit", value: "Submit", **html_attributes)
+    end
+
+    def render_remove_subform_button(**html_attributes, &block)
+      a(**html_attributes, onclick: safe("easyFormRemoveSubform(event)"), &block)
+    end
+
+    def render_new_subform_button(**html_attributes, &block)
+      a(**html_attributes, onclick: safe("easyFormAddSubform(event)"), &block)
+    end
+
+    private
+
+    def hide_label?(element)
+      return true unless element.class.label_options.first[:display]
+
+      element.input_type == :hidden ||
+        (%i[checkbox radio].include?(element.input_type) && element.class.select_options.any?)
+    end
+  end
+end