formalist 0.2.2 → 0.2.3

data/lib/formalist/display_adapters.rb

@@ -1,16 +0,0 @@
-require "dry-container"
-require "formalist/display_adapters/default"
-require "formalist/display_adapters/radio"
-require "formalist/display_adapters/select"
-require "formalist/display_adapters/textarea"
-
-module Formalist
-  class DisplayAdapters
-    extend Dry::Container::Mixin
-
-    register DEFAULT_DISPLAY_ADAPTER, Default.new
-    register "radio", Radio.new
-    register "select", Select.new
-    register "textarea", Textarea.new
-  end
-end

data/lib/formalist/form/definition/attr.rb

@@ -1,20 +0,0 @@
-require "formalist/form/result/attr"
-
-module Formalist
-  class Form
-    module Definition
-      class Attr
-        attr_reader :name, :children
-
-        def initialize(name, children)
-          @name = name
-          @children = children
-        end
-
-        def call(input, rules, errors)
-          Result::Attr.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition/component.rb

@@ -1,31 +0,0 @@
-require "formalist/form/result/component"
-
-module Formalist
-  class Form
-    module Definition
-      class Component
-        ALLOWED_CHILDREN = %w[field].freeze
-
-        attr_reader :config
-        attr_reader :children
-
-        def initialize(config = {}, children = [])
-          unless children.all? { |c| ALLOWED_CHILDREN.include?(Inflecto.underscore(c.class.name).split("/").last) }
-            raise ArgumentError, "children must be +#{ALLOWED_CHILDREN.join(', ')}+"
-          end
-
-          @config = config
-          @children = children
-        end
-
-        def with(new_config = {})
-          self.class.new(config.merge(new_config), children)
-        end
-
-        def call(input, rules, errors)
-          Result::Component.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition/field.rb

@@ -1,29 +0,0 @@
-require "formalist/form/result/field"
-
-module Formalist
-  class Form
-    module Definition
-      class Field
-        attr_reader :name
-        attr_reader :type
-        attr_reader :display_variant
-        attr_reader :config
-
-        def initialize(name, type, display_variant, config)
-          @name = name
-          @type = type
-          @display_variant = display_variant
-          @config = config
-        end
-
-        def to_display_variant(display_variant, new_config = {})
-          self.class.new(name, type, display_variant, config.merge(new_config))
-        end
-
-        def call(input, rules, errors)
-          Result::Field.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition/group.rb

@@ -1,31 +0,0 @@
-require "formalist/form/result/group"
-
-module Formalist
-  class Form
-    module Definition
-      class Group
-        ALLOWED_CHILDREN = %w[
-          attr
-          component
-          field
-          many
-        ].freeze
-
-        attr_reader :config, :children
-
-        def initialize(config = {}, children = [])
-          unless children.all? { |c| ALLOWED_CHILDREN.include?(Inflecto.underscore(c.class.name).split("/").last) }
-            raise ArgumentError, "children must be +#{ALLOWED_CHILDREN.join(', ')}+"
-          end
-
-          @config = config
-          @children = children
-        end
-
-        def call(input, rules, errors)
-          Result::Group.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition/many.rb

@@ -1,41 +0,0 @@
-require "formalist/form/result/many"
-
-module Formalist
-  class Form
-    module Definition
-      class Many
-        ALLOWED_CHILDREN = %w[
-          attr
-          component
-          group
-          field
-        ].freeze
-
-        DEFAULT_CONFIG = {
-          allow_create: true,
-          allow_update: true,
-          allow_destroy: true,
-          allow_reorder: true
-        }.freeze
-
-        attr_reader :name
-        attr_reader :config
-        attr_reader :children
-
-        def initialize(name, config = {}, children = [])
-          unless children.all? { |c| ALLOWED_CHILDREN.include?(Inflecto.underscore(c.class.name).split("/").last) }
-            raise ArgumentError, "children must be +#{ALLOWED_CHILDREN.join(', ')}+"
-          end
-
-          @name = name
-          @config = DEFAULT_CONFIG.merge(config)
-          @children = children
-        end
-
-        def call(input, rules, errors)
-          Result::Many.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition/section.rb

@@ -1,23 +0,0 @@
-require "formalist/form/result/section"
-
-module Formalist
-  class Form
-    module Definition
-      class Section
-        attr_reader :name
-        attr_reader :config
-        attr_reader :children
-
-        def initialize(name, config = {}, children = [])
-          @name = name
-          @config = config
-          @children = children
-        end
-
-        def call(input, rules, errors)
-          Result::Section.new(self, input, rules, errors)
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/definition.rb

@@ -1,37 +0,0 @@
-require "formalist/form/definition_context"
-
-module Formalist
-  class Form
-    module Definition
-      def attr(name, &block)
-        elements << [:attr, [name, define_children(&block)]]
-      end
-
-      def component(display: DEFAULT_DISPLAY_ADAPTER, **config, &block)
-        elements << [:component, [display, config, define_children(&block)]]
-      end
-
-      def field(name, type:, display: DEFAULT_DISPLAY_ADAPTER, **config)
-        elements << [:field, [name, type, display, config]]
-      end
-
-      def group(**config, &block)
-        elements << [:group, [config, define_children(&block)]]
-      end
-
-      def many(name, **config, &block)
-        elements << [:many, [name, config, define_children(&block)]]
-      end
-
-      def section(name, **config, &block)
-        elements << [:section, [name, config, define_children(&block)]]
-      end
-
-      private
-
-      def define_children(&block)
-        block ? DefinitionContext.new(&block).elements : []
-      end
-    end
-  end
-end

data/lib/formalist/form/result/attr.rb

@@ -1,82 +0,0 @@
-require "formalist/validation/collection_rules_compiler"
-require "formalist/validation/value_rules_compiler"
-require "formalist/validation/predicate_list_compiler"
-
-module Formalist
-  class Form
-    class Result
-      class Attr
-        attr_reader :definition, :input, :value_rules, :value_predicates, :collection_rules, :errors
-        attr_reader :children
-
-        def initialize(definition, input, rules, errors)
-          value_rules_compiler = Validation::ValueRulesCompiler.new(definition.name)
-          value_predicates_compiler = Validation::PredicateListCompiler.new
-          collection_rules_compiler = Validation::CollectionRulesCompiler.new(definition.name)
-
-          @definition = definition
-          @input = input.fetch(definition.name, {})
-          @value_rules = value_rules_compiler.(rules)
-          @value_predicates = value_predicates_compiler.(@value_rules)
-          @collection_rules = collection_rules_compiler.(rules)
-          @errors = errors.fetch(definition.name, [])[0] || []
-          @children = build_children
-        end
-
-        # Converts the attribute into an array format for including in a
-        # form's abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:attr, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Attribute name
-        # 1. Validation rules (if any)
-        # 1. Validation error messages (if any)
-        # 1. Child form elements
-        #
-        # @example "metadata" attr
-        #   attr.to_ast # =>
-        #   # [:attr, [
-        #   #   :metadata,
-        #   #   [
-        #   #     [:predicate, [:hash?, []]],
-        #   #   ],
-        #   #   ["metadata is missing"],
-        #   #   [
-        #   #     ...child elements...
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the attribute as an array.
-        def to_ast
-          # Errors, if the attr hash is present and its members have errors:
-          # {:meta=>[[{:pages=>[["pages is missing"], nil]}], {}]}
-
-          # Errors, if the attr hash hasn't been provided
-          # {:meta=>[["meta is missing"], nil]}
-
-          local_errors = errors[0].is_a?(Hash) ? [] : errors
-
-          [:attr, [
-            definition.name,
-            value_predicates,
-            local_errors,
-            children.map(&:to_ast),
-          ]]
-        end
-
-        private
-
-        def build_children
-          child_errors = errors[0].is_a?(Hash) ? errors[0] : {}
-          definition.children.map { |el| el.(input, collection_rules, child_errors) }
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/result/component.rb

@@ -1,51 +0,0 @@
-module Formalist
-  class Form
-    class Result
-      class Component
-        attr_reader :definition, :input, :rules, :errors
-        attr_reader :children
-
-        def initialize(definition, input, rules, errors)
-          @definition = definition
-          @input = input
-          @rules = rules
-          @errors = errors
-          @children = definition.children.map { |el| el.(input, rules, errors) }
-        end
-
-        # Converts the component into an array format for including in a
-        # form's abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:component, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Component configuration
-        # 1. Child form elements
-        #
-        # @example
-        #   component.to_ast # =>
-        #   # [:component, [
-        #   #   [
-        #   #     [:some_config_name, :some_config_value]
-        #   #   ],
-        #   #   [
-        #   #     ...child elements...
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the component as an array.
-        def to_ast
-          [:component, [
-            definition.config.to_a,
-            children.map(&:to_ast),
-          ]]
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/result/field.rb

@@ -1,77 +0,0 @@
-require "formalist/validation/value_rules_compiler"
-require "formalist/validation/predicate_list_compiler"
-
-module Formalist
-  class Form
-    class Result
-      class Field
-        attr_reader :definition, :input, :rules, :predicates, :errors
-
-        def initialize(definition, input, rules, errors)
-          rules_compiler = Validation::ValueRulesCompiler.new(definition.name)
-          predicates_compiler = Validation::PredicateListCompiler.new
-
-          @definition = definition
-          @input = input[definition.name]
-          @rules = rules_compiler.(rules)
-          @predicates = predicates_compiler.(@rules)
-          @errors = errors[definition.name].to_a[0] || []
-        end
-
-        # Converts the field into an array format for including in a form's
-        # abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:field, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Field name
-        # 1. Field type
-        # 1. Display variant name
-        # 1. Input data
-        # 1. Validation rules (if any)
-        # 1. Validation error messages (if any)
-        # 1. Field configuration
-        #
-        # @example "email" field
-        #   field.to_ast # =>
-        #   # [:field, [
-        #   #   :email,
-        #   #   "string",
-        #   #   "default",
-        #   #   "invalid email value",
-        #   #   [
-        #   #     [:and, [
-        #   #       [:predicate, [:filled?, []]],
-        #   #       [:predicate, [:format?, [/\s+@\s+\.\s+/]]]
-        #   #     ]]
-        #   #   ],
-        #   #   ["email is in invalid format"],
-        #   #   [
-        #   #     [:some_config_name, :some_config_value]
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the field as an array.
-        def to_ast
-          # errors looks like this
-          # {:field_name => [["pages is missing", "another error message"], nil]}
-
-          [:field, [
-            definition.name,
-            definition.type,
-            definition.display_variant,
-            input,
-            predicates,
-            errors,
-            definition.config.to_a,
-          ]]
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/result/group.rb

@@ -1,51 +0,0 @@
-module Formalist
-  class Form
-    class Result
-      class Group
-        attr_reader :definition, :input, :errors
-        attr_reader :children
-
-        def initialize(definition, input, rules, errors)
-          @definition = definition
-          @input = input
-          @rules = rules
-          @errors = errors
-          @children = definition.children.map { |el| el.(input, rules, errors) }
-        end
-
-        # Converts the group into an array format for including in a form's
-        # abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:group, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Group configuration
-        # 1. Child form elements
-        #
-        # @example
-        #   group.to_ast # =>
-        #   # [:group, [
-        #   #   [
-        #   #     [:some_config_name, :some_config_value]
-        #   #   ],
-        #   #   [
-        #   #     ...child elements...
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the group as an array.
-        def to_ast
-          [:group, [
-            definition.config.to_a,
-            children.map(&:to_ast),
-          ]]
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/result/many.rb

@@ -1,123 +0,0 @@
-require "formalist/validation/collection_rules_compiler"
-require "formalist/validation/value_rules_compiler"
-require "formalist/validation/predicate_list_compiler"
-
-module Formalist
-  class Form
-    class Result
-      class Many
-        attr_reader :definition, :input, :value_rules, :value_predicates, :collection_rules, :errors
-        attr_reader :child_template, :children
-
-        def initialize(definition, input, rules, errors)
-          value_rules_compiler = Validation::ValueRulesCompiler.new(definition.name)
-          value_predicates_compiler = Validation::PredicateListCompiler.new
-          collection_rules_compiler = Validation::CollectionRulesCompiler.new(definition.name)
-
-          @definition = definition
-          @input = input.fetch(definition.name, [])
-          @value_rules = value_rules_compiler.(rules)
-          @value_predicates = value_predicates_compiler.(@value_rules)
-          @collection_rules = collection_rules_compiler.(rules)
-          @errors = errors.fetch(definition.name, [])[0] || []
-          @child_template = build_child_template
-          @children = build_children
-        end
-
-        # Converts a collection of "many" repeating elements into an array
-        # format for including in a form's abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:many, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Collection array name
-        # 1. Collection validation rules (if any)
-        # 1. Collection error messages (if any)
-        # 1. Collection configuration
-        # 1. Child element "template" (i.e. the form elements comprising a
-        #    single entry in the collection of "many" elements, without any
-        #    user data associated)
-        # 1. Child elements, one for each of the entries in the input data (or
-        #    none, if there is no or empty input data)
-        #
-        # @example "locations" collection
-        #   many.to_ast # =>
-        #   # [:many, [
-        #   #   :locations,
-        #   #   [[:predicate, [:min_size?, [3]]]],
-        #   #   ["locations size cannot be less than 3"],
-        #   #   [
-        #   #     [:allow_create, true],
-        #   #     [:allow_update, true],
-        #   #     [:allow_destroy, true],
-        #   #     [:allow_reorder, true]
-        #   #   ],
-        #   #   [
-        #   #     [:field, [:name, "string", "default", nil, [], [], []]],
-        #   #     [:field, [:address, "string", "default", nil, [], [], []]]
-        #   #   [
-        #   #     [
-        #   #       [:field, [:name, "string", "default", "Icelab Canberra", [], [], []]],
-        #   #       [:field, [:address, "string", "default", "Canberra, ACT, Australia", [], [], []]]
-        #   #     ],
-        #   #     [
-        #   #       [:field, [:name, "string", "default", "Icelab Melbourne", [], [], []]],
-        #   #       [:field, [:address, "string", "default", "Melbourne, VIC, Australia", [], [], []]]
-        #   #     ]
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the collection as an array.
-        def to_ast
-          local_errors = errors.select { |e| e.is_a?(String) }
-
-          [:many, [
-            definition.name,
-            value_predicates,
-            local_errors,
-            definition.config.to_a,
-            child_template.map(&:to_ast),
-            children.map { |el_list| el_list.map(&:to_ast) },
-          ]]
-        end
-
-        private
-
-        def build_child_template
-          template_input = {}
-          template_errors = {}
-
-          definition.children.map { |el| el.(template_input, collection_rules, template_errors)}
-        end
-
-        def build_children
-          # child errors looks like this:
-          # [
-          #   {:rating=>[["rating must be greater than or equal to 1"], 0]},
-          #   {:summary=>"Great", :rating=>0},
-          #   {:summary=>[["summary must be filled"], ""]},
-          #   {:summary=>"", :rating=>1}
-          # ]
-          #
-          # or local errors:
-          # {:links=>[["links is missing"], nil]}
-
-          child_errors = errors.each_slice(2).to_a
-
-          input.map { |child_input|
-            local_child_errors = child_errors.select { |e|
-              e[1] == child_input
-            }.to_a.dig(0, 0) || {}
-
-            definition.children.map { |el| el.(child_input, collection_rules, local_child_errors) }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/formalist/form/result/section.rb

@@ -1,54 +0,0 @@
-module Formalist
-  class Form
-    class Result
-      class Section
-        attr_reader :definition, :input, :rules, :errors
-        attr_reader :children
-
-        def initialize(definition, input, rules, errors)
-          @definition = definition
-          @input = input
-          @rules = rules
-          @errors = errors
-          @children = definition.children.map { |el| el.(input, rules, errors) }
-        end
-
-        # Converts the section into an array format for including in a form's
-        # abstract syntax tree.
-        #
-        # The array takes the following format:
-        #
-        # ```
-        # [:section, [params]]
-        # ```
-        #
-        # With the following parameters:
-        #
-        # 1. Section name
-        # 1. Section configuration
-        # 1. Child form elements
-        #
-        # @example "content" section
-        #   section.to_ast # =>
-        #   # [:section, [
-        #   #   :content,
-        #   #   [
-        #   #     [:some_config_name, :some_config_value]
-        #   #   ],
-        #   #   [
-        #   #     ...child elements...
-        #   #   ]
-        #   # ]]
-        #
-        # @return [Array] the section as an array.
-        def to_ast
-          [:section, [
-            definition.name,
-            definition.config.to_a,
-            children.map(&:to_ast),
-          ]]
-        end
-      end
-    end
-  end
-end