formalist 0.1.0

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

@@ -0,0 +1,77 @@
+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_ary # =>
+        #   # [: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_ary
+          # errors looks like this
+          # {:field_name => [["pages is missing", "another error message"], nil]}
+
+          [:field, [
+            definition.name,
+            definition.type,
+            definition.display_variant,
+            Dry::Data[definition.type].(input),
+            predicates,
+            errors,
+            definition.config.to_a,
+          ]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+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_ary # =>
+        #   # [:group, [
+        #   #   [
+        #   #     [:some_config_name, :some_config_value]
+        #   #   ],
+        #   #   [
+        #   #     ...child elements...
+        #   #   ]
+        #   # ]]
+        #
+        # @return [Array] the group as an array.
+        def to_ary
+          [:group, [
+            definition.config.to_a,
+            children.map(&:to_ary),
+          ]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,127 @@
+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_ary # =>
+        #   # [: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_ary
+          local_errors = errors.select { |e| e.is_a?(String) }
+
+          [:many, [
+            definition.name,
+            value_predicates,
+            local_errors,
+            definition.config.to_a,
+            child_template.map(&:to_ary),
+            children.map { |el_list| el_list.map(&:to_ary) },
+          ]]
+        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:
+          # {:links=>
+          #   [[{:links=>
+          #       [[{:url=>[["url must be filled"], ""]}],
+          #        {:name=>"personal", :url=>""}]}],
+          #    [{:name=>"company", :url=>"http://icelab.com.au"},
+          #     {:name=>"personal", :url=>""}]]}
+          #
+          # or local errors:
+          # {:links=>[["links is missing"], nil]}
+
+          child_errors = errors[0].is_a?(Hash) ? errors : {}
+
+          input.map { |child_input|
+            local_child_errors = child_errors.select { |e|
+              e.is_a?(Hash)
+            }.map { |e|
+              e[definition.name]
+            }.detect { |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

@@ -0,0 +1,54 @@
+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_ary # =>
+        #   # [:section, [
+        #   #   :content,
+        #   #   [
+        #   #     [:some_config_name, :some_config_value]
+        #   #   ],
+        #   #   [
+        #   #     ...child elements...
+        #   #   ]
+        #   # ]]
+        #
+        # @return [Array] the section as an array.
+        def to_ary
+          [:section, [
+            definition.name,
+            definition.config.to_a,
+            children.map(&:to_ary),
+          ]]
+        end
+      end
+    end
+  end
+end

data/lib/formalist/form/result.rb

@@ -0,0 +1,15 @@
+module Formalist
+  class Form
+    class Result
+      attr_reader :elements
+
+      def initialize(elements)
+        @elements = elements
+      end
+
+      def to_ary
+        elements.map(&:to_ary)
+      end
+    end
+  end
+end

data/lib/formalist/form.rb

@@ -0,0 +1,44 @@
+require "dry-configurable"
+require "formalist/definition_compiler"
+require "formalist/display_adapters"
+require "formalist/form/definition"
+require "formalist/form/result"
+
+module Formalist
+  class Form
+    extend Dry::Configurable
+    extend Definition
+
+    setting :display_adapters, DisplayAdapters
+
+    def self.display_adapters
+      config.display_adapters
+    end
+
+    # @api private
+    def self.elements
+      @__elements__ ||= []
+    end
+
+    # @api private
+    attr_reader :elements
+
+    # @api private
+    attr_reader :schema
+
+    def initialize(schema: nil)
+      definition_compiler = DefinitionCompiler.new(self.class.display_adapters)
+      @elements = definition_compiler.call(self.class.elements)
+      @schema = schema
+    end
+
+    def call(input = {}, options = {})
+      validate = options.fetch(:validate, true)
+
+      rules = schema ? schema.rules.map(&:to_ary) : []
+      errors = validate && schema ? schema.(input).messages : {}
+
+      Result.new(elements.map { |el| el.(input, rules, errors) })
+    end
+  end
+end

data/lib/formalist/output_compiler.rb

@@ -0,0 +1,65 @@
+require "dry-data"
+
+module Formalist
+  class OutputCompiler
+    FORM_TYPES = %w[
+      bool
+      date
+      date_time
+      decimal
+      float
+      int
+      time
+    ].freeze
+
+    def call(ast)
+      ast.map { |node| visit(node) }.inject(:merge)
+    end
+
+    private
+
+    def visit(node)
+      send(:"visit_#{node[0]}", node[1])
+    end
+
+    def visit_attr(data)
+      name, predicates, errors, children = data
+
+      {name => children.map { |node| visit(node) }.inject(:merge) }
+    end
+
+    def visit_field(data)
+      name, type, display_variant, value, predicates, errors = data
+
+      {name => coerce(value, type: type)}
+    end
+
+    def visit_group(data)
+      config, children = data
+
+      children.map { |node| visit(node) }.inject(:merge)
+    end
+
+    def visit_many(data)
+      name, predicates, errors, config, template, children = data
+
+      {name => children.map { |item| item.map { |node| visit(node) }.inject(:merge) }}
+    end
+
+    def visit_section(data)
+      name, config, children = data
+
+      children.map { |node| visit(node) }.inject(:merge)
+    end
+
+    private
+
+    def coerce(value, type:)
+      if FORM_TYPES.include?(type)
+        Dry::Data["form.#{type}"].(value)
+      else
+        Dry::Data[type].(value)
+      end
+    end
+  end
+end

data/lib/formalist/validation/collection_rules_compiler.rb

@@ -0,0 +1,77 @@
+module Formalist
+  module Validation
+    class CollectionRulesCompiler
+      attr_reader :target_name
+
+      def initialize(target_name)
+        @target_name = target_name
+      end
+
+      def call(ast)
+        ast.map { |node| visit(node) }.reduce([], :concat).each_slice(2).to_a
+      end
+
+      private
+
+      def visit(node)
+        name, nodes = node
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_set(node)
+        name, rules = node
+        return [] unless name == target_name
+
+        rules.flatten(1)
+      end
+
+      def visit_each(node)
+        name, rule = node
+        return [] unless name == target_name
+
+        visit(rule)
+      end
+
+      def visit_predicate(node)
+        name, args = node
+        [:predicate, node]
+      end
+
+      def visit_and(node)
+        left, right = node
+        flatten_logical_operation(:and, [visit(left), visit(right)])
+      end
+
+      def visit_or(node)
+        left, right = node
+        flatten_logical_operation(:or, [visit(left), visit(right)])
+      end
+
+      def visit_xor(node)
+        left, right = node
+        flatten_logical_operation(:xor, [visit(left), visit(right)])
+      end
+
+      def visit_implication(node)
+        left, right = node
+        flatten_logical_operation(:implication, [visit(left), visit(right)])
+      end
+
+      def method_missing(name, *args)
+        []
+      end
+
+      def flatten_logical_operation(name, contents)
+        contents = contents.select(&:any?)
+
+        if contents.length == 0
+          []
+        elsif contents.length == 1
+          contents.first
+        else
+          [name, contents]
+        end
+      end
+    end
+  end
+end

data/lib/formalist/validation/predicate_list_compiler.rb

@@ -0,0 +1,73 @@
+module Formalist
+  module Validation
+    class PredicateListCompiler
+      IGNORED_PREDICATES = [:key?].freeze
+
+      def call(ast)
+        ast.map { |node| visit(node) }.reduce([], :concat).each_slice(2).to_a
+      end
+
+      private
+
+      def visit(node)
+        name, nodes = node
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_key(node)
+        name, predicate = node
+
+        visit(predicate)
+      end
+
+      def visit_val(node)
+        name, predicate = node
+
+        visit(predicate)
+      end
+
+      def visit_predicate(node)
+        name, args = node
+        return [] if IGNORED_PREDICATES.include?(name)
+
+        [:predicate, node]
+      end
+
+      def visit_and(node)
+        left, right = node
+        flatten_logical_operation(:and, [visit(left), visit(right)])
+      end
+
+      def visit_or(node)
+        left, right = node
+        flatten_logical_operation(:or, [visit(left), visit(right)])
+      end
+
+      def visit_xor(node)
+        left, right = node
+        flatten_logical_operation(:xor, [visit(left), visit(right)])
+      end
+
+      def visit_implication(node)
+        left, right = node
+        flatten_logical_operation(:implication, [visit(left), visit(right)])
+      end
+
+      def method_missing(name, *args)
+        []
+      end
+
+      def flatten_logical_operation(name, contents)
+        contents = contents.select(&:any?)
+
+        if contents.length == 0
+          []
+        elsif contents.length == 1
+          contents.first
+        else
+          [name, contents]
+        end
+      end
+    end
+  end
+end

data/lib/formalist/validation/value_rules_compiler.rb

@@ -0,0 +1,92 @@
+module Formalist
+  module Validation
+    class ValueRulesCompiler
+      attr_reader :target_name
+
+      def initialize(target_name)
+        @target_name = target_name
+      end
+
+      def call(ast)
+        ast.map { |node| visit(node) }.reduce([], :concat).each_slice(2).to_a
+      end
+
+      private
+
+      def visit(node)
+        name, nodes = node
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_key(node)
+        # We can ignore "key" checks - we'll only pick up rules for keys we
+        # know will exist, since they're attached to fields.
+        []
+      end
+
+      def visit_val(node)
+        name, predicate = node
+        return [] unless name == target_name
+
+        # Skip the "val" prefix
+
+        [:val, [name, visit(predicate)]]
+      end
+
+      # def visit_set(node)
+      #   name, rules = node
+      #   return [] unless name == target_name
+
+      #   rules.flatten(1)
+      # end
+
+      # def visit_each(node)
+      #   name, rule = node
+      #   return [] unless name == target_name
+
+      #   visit(rule)
+      # end
+
+      def visit_predicate(node)
+        name, args = node
+        [:predicate, node]
+      end
+
+      def visit_and(node)
+        left, right = node
+        flatten_logical_operation(:and, [visit(left), visit(right)])
+      end
+
+      def visit_or(node)
+        left, right = node
+        flatten_logical_operation(:or, [visit(left), visit(right)])
+      end
+
+      def visit_xor(node)
+        left, right = node
+        flatten_logical_operation(:xor, [visit(left), visit(right)])
+      end
+
+      def visit_implication(node)
+        left, right = node
+        flatten_logical_operation(:implication, [visit(left), visit(right)])
+      end
+
+      def method_missing(name, *args)
+        []
+      end
+
+      def flatten_logical_operation(name, contents)
+        contents = contents.select(&:any?)
+
+        if contents.length == 0
+          []
+        elsif contents.length == 1
+          contents.first
+        else
+          [name, contents]
+        end
+      end
+    end
+  end
+end

data/lib/formalist/version.rb

@@ -0,0 +1,3 @@
+module Formalist
+  VERSION = "0.1.0".freeze
+end

data/lib/formalist.rb

@@ -0,0 +1,7 @@
+module Formalist
+  DEFAULT_DISPLAY_ADAPTER = "default".freeze
+end
+
+require "dry-validation"
+require "formalist/form"
+require "formalist/output_compiler"

data/spec/examples.txt

@@ -0,0 +1,8 @@
+example_id                                       | status | run_time        |
+------------------------------------------------ | ------ | --------------- |
+./spec/integration/display_adapters_spec.rb[1:1] | passed | 0.00016 seconds |
+./spec/integration/display_adapters_spec.rb[1:2] | passed | 0.00024 seconds |
+./spec/integration/form_spec.rb[1:1]             | passed | 0.00021 seconds |
+./spec/integration/new_spec.rb[1:1]              | passed | 0.00063 seconds |
+./spec/integration/validation_spec.rb[1:1]       | passed | 0.00435 seconds |
+./spec/unit/output_compiler_spec.rb[1:1]         | passed | 0.00049 seconds |