formalist 0.2.2 → 0.2.3

data/lib/formalist/elements/field.rb

@@ -0,0 +1,73 @@
+require "formalist/element"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class Field < Element
+      permitted_children :none
+
+      # @api private
+      attr_reader :name
+
+      attribute :label, Types::String
+      attribute :hint, Types::String
+      attribute :placeholder, Types::String
+      attribute :inline, Types::Bool
+      attribute :validation, Types::Validation
+
+      # @api private
+      attr_reader :predicates
+
+      # @api private
+      def initialize(*args, attributes, children, input, errors)
+        super
+
+        @name = Types::ElementName.(args.first)
+        @input = input[@name] if input
+        @errors = errors[@name].to_a
+      end
+
+      # Converts the field into an abstract syntax tree.
+      #
+      # It takes the following format:
+      #
+      # ```
+      # [:field, [params]]
+      # ```
+      #
+      # With the following parameters:
+      #
+      # 1. Field name
+      # 2. Custom form element type (or `:field` otherwise)
+      # 3. Associated form input data
+      # 4. Error messages
+      # 5. Form element attributes
+      #
+      # @see Formalist::Element::Attributes#to_ast "Form element attributes" structure
+      #
+      # @example "email" field
+      #   field.to_ast
+      #   # => [:field, [
+      #     :email,
+      #     :field,
+      #     "jane@doe.org",
+      #     [],
+      #     [:object, []],
+      #   ]]
+      #
+      # @return [Array] the field as an abstract syntax tree.
+      def to_ast
+        # errors looks like this
+        # {:field_name => [["pages is missing", "another error message"], nil]}
+
+        [:field, [
+          name,
+          type,
+          input,
+          errors,
+          Element::Attributes.new(attributes).to_ast,
+        ]]
+      end
+    end
+  end
+end

data/lib/formalist/elements/group.rb

@@ -0,0 +1,50 @@
+require "formalist/element"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class Group < Element
+      permitted_children :attr, :compound_field, :field, :many
+
+      attribute :label, Types::String
+
+      def initialize(*args, attributes, children, input, errors)
+        super
+        @children = children.map { |definition| definition.(input, errors) }
+      end
+
+      # Converts the group into an abstract syntax tree.
+      #
+      # It takes the following format:
+      #
+      # ```
+      # [:group, [params]]
+      # ```
+      #
+      # With the following parameters:
+      #
+      # 1. Custom form element type (or `:group` otherwise)
+      # 2. Form element attributes
+      # 3. Child form elements
+      #
+      # @see Formalist::Element::Attributes#to_ast "Form element attributes" structure
+      #
+      # @example
+      #   group.to_ast
+      #   # => [:group, [
+      #     :group,
+      #     [:object, []],
+      #     [...child elements...]
+      #   ]]
+      #
+      # @return [Array] the group as an abstract syntax tree.
+      def to_ast
+        [:group, [
+          type,
+          Element::Attributes.new(attributes).to_ast,
+          children.map(&:to_ast),
+        ]]
+      end
+    end
+  end
+end

data/lib/formalist/elements/many.rb

@@ -0,0 +1,125 @@
+require "formalist/element"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class Many < Element
+      permitted_children :attr, :compound_field, :group, :field
+
+      # @api private
+      attr_reader :name
+
+      attribute :label, Types::String
+      attribute :action_label, Types::String
+      attribute :placeholder, Types::String
+      attribute :validation, Types::Validation
+
+      # @api private
+      attr_reader :child_template
+
+      # @api private
+      def initialize(*args, attributes, children, input, errors)
+        super
+
+        @name = Types::ElementName.(args.first)
+        @input = input.fetch(name, [])
+        @errors = errors[@name]
+        @child_template = build_child_template(children)
+        @children = build_children(children)
+      end
+
+      # Until we can put defaults on `Types::Bool`, supply them here
+      # @api private
+      def attributes
+        {
+          allow_create: true,
+          allow_update: true,
+          allow_destroy: true,
+          allow_reorder: true,
+        }.merge(super)
+      end
+
+      # Converts a collection of "many" repeating elements into an abstract
+      # syntax tree.
+      #
+      # It takes the following format:
+      #
+      # ```
+      # [:many, [params]]
+      # ```
+      #
+      # With the following parameters:
+      #
+      # 1. Collection name
+      # 2. Custom form element type (or `:many` otherwise)
+      # 3. Collection-level error messages
+      # 4. Form element attributes
+      # 5. Child element "template" (i.e. the form elements comprising a
+      #    single entry in the collection of "many" elements, without any user
+      #    data associated)
+      # 6. Child elements, one for each of the entries in the input data (or
+      #    none, if there is no or empty input data)
+      #
+      # @see Formalist::Element::Attributes#to_ast "Form element attributes" structure
+      #
+      # @example "locations" collection
+      #   many.to_ast
+      #   # => [:many, [
+      #     :locations,
+      #     :many,
+      #     ["locations size cannot be less than 3"],
+      #     [:object, [
+      #       [:allow_create, [:value, [true]]],
+      #       [:allow_update, [:value, [true]]],
+      #       [:allow_destroy, [:value, [true]]],
+      #       [:allow_reorder, [:value, [true]]]
+      #     ]],
+      #     [
+      #       [:field, [:name, :field, nil, [], [], [:object, []]]],
+      #       [:field, [:address, :field, nil, [], [], [:object, []]]]
+      #     ],
+      #     [
+      #       [
+      #         [:field, [:name, :field, "Icelab Canberra", [], [], [:object, []]]],
+      #         [:field, [:address, :field, "Canberra, ACT, Australia", [], [], [:object, []]]]
+      #       ],
+      #       [
+      #         [:field, [:name, :field, "Icelab Melbourne", [], [], [:object, []]]],
+      #         [:field, [:address, :field, "Melbourne, VIC, Australia", [], [], [:object, []]]]
+      #       ]
+      #     ]
+      #   ]]
+      #
+      # @return [Array] the collection as an abstract syntax tree.
+      def to_ast
+        local_errors = errors.is_a?(Array) ? errors : []
+
+        [:many, [
+          name,
+          type,
+          local_errors,
+          Element::Attributes.new(attributes).to_ast,
+          child_template.map(&:to_ast),
+          children.map { |el_list| el_list.map(&:to_ast) },
+        ]]
+      end
+
+      private
+
+      def build_child_template(definitions)
+        definitions.map { |el| el.({}, {})}
+      end
+
+      def build_children(definitions)
+        # Child errors look like this: {0=>{:summary=>["must be filled"]}
+        child_errors = errors.is_a?(Hash) ? errors : {}
+
+        input.each_with_index.map { |child_input, index|
+          errors = child_errors.fetch(index, {})
+
+          definitions.map { |el| el.(child_input, errors) }
+        }
+      end
+    end
+  end
+end

data/lib/formalist/elements/section.rb

@@ -0,0 +1,58 @@
+require "formalist/element"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class Section < Element
+      permitted_children :all
+
+      # @api private
+      attr_reader :name
+
+      attribute :label, Types::String
+
+      def initialize(*args, attributes, children, input, errors)
+        super
+
+        @name = Types::ElementName.(args.first)
+        @children = children.map { |definition| definition.(input, errors) }
+      end
+
+      # Converts the section into an abstract syntax tree.
+      #
+      # It takes the following format:
+      #
+      # ```
+      # [:section, [params]]
+      # ```
+      #
+      # With the following parameters:
+      #
+      # 1. Section name
+      # 2. Custom form element type (or `:section` otherwise)
+      # 3. Form element attributes
+      # 4. Child form elements
+      #
+      # @see Formalist::Element::Attributes#to_ast "Form element attributes" structure
+      #
+      # @example "content" section
+      #   section.to_ast
+      #   # => [:section, [
+      #     :content,
+      #     :section,
+      #     [:object, []],
+      #     [...child elements...]
+      #   ]]
+      #
+      # @return [Array] the section as an abstract syntax tree.
+      def to_ast
+        [:section, [
+          name,
+          type,
+          Element::Attributes.new(attributes).to_ast,
+          children.map(&:to_ast),
+        ]]
+      end
+    end
+  end
+end

data/lib/formalist/elements/standard/check_box.rb

@@ -0,0 +1,20 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class CheckBox < Field
+      attribute :question_text, Types::String
+
+      def initialize(*)
+        super
+
+        # Ensure value is a boolean (also: default to false for nil values)
+        @input = !!@input
+      end
+    end
+
+    register :check_box, CheckBox
+  end
+end

data/lib/formalist/elements/standard/date_field.rb

@@ -0,0 +1,12 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class DateField < Field
+    end
+
+    register :date_field, DateField
+  end
+end

data/lib/formalist/elements/standard/date_time_field.rb

@@ -0,0 +1,12 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class DateTimeField < Field
+    end
+
+    register :date_time_field, DateTimeField
+  end
+end

data/lib/formalist/elements/standard/hidden_field.rb

@@ -0,0 +1,11 @@
+require "formalist/element"
+require "formalist/elements"
+
+module Formalist
+  class Elements
+    class HiddenField < Field
+    end
+
+    register :hidden_field, HiddenField
+  end
+end

data/lib/formalist/elements/standard/multi_selection_field.rb

@@ -0,0 +1,16 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class MultiSelectionField < Field
+      attribute :options, Types::SelectionsList
+      attribute :selector_label, Types::String
+      attribute :render_option_as, Types::String
+      attribute :render_selection_as, Types::String
+    end
+
+    register :multi_selection_field, MultiSelectionField
+  end
+end

data/lib/formalist/elements/standard/number_field.rb

@@ -0,0 +1,17 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class NumberField < Field
+      Number = Types::Int | Types::Float
+
+      attribute :step, Number
+      attribute :min, Number
+      attribute :max, Number
+    end
+
+    register :number_field, NumberField
+  end
+end

data/lib/formalist/elements/standard/radio_buttons.rb

@@ -0,0 +1,13 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class RadioButtons < Field
+      attribute :options, Types::OptionsList
+    end
+
+    register :radio_buttons, RadioButtons
+  end
+end

data/lib/formalist/elements/standard/select_box.rb

@@ -0,0 +1,13 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class SelectBox < Field
+      attribute :options, Types::OptionsList
+    end
+
+    register :select_box, SelectBox
+  end
+end

data/lib/formalist/elements/standard/selection_field.rb

@@ -0,0 +1,16 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class SelectionField < Field
+      attribute :options, Types::SelectionsList
+      attribute :selector_label, Types::String
+      attribute :render_option_as, Types::String
+      attribute :render_selection_as, Types::String
+    end
+
+    register :selection_field, SelectionField
+  end
+end

data/lib/formalist/elements/standard/text_area.rb

@@ -0,0 +1,15 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class TextArea < Field
+      attribute :text_size, Types::String.enum("xsmall", "small", "normal", "large", "xlarge"), default: "normal"
+      attribute :box_size, Types::String.enum("single", "small", "normal", "large", "xlarge"), default: "normal"
+      attribute :code, Types::Bool
+    end
+
+    register :text_area, TextArea
+  end
+end

data/lib/formalist/elements/standard/text_field.rb

@@ -0,0 +1,14 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class TextField < Field
+      attribute :password, Types::Bool
+      attribute :code, Types::Bool
+    end
+
+    register :text_field, TextField
+  end
+end

data/lib/formalist/elements/standard.rb

@@ -0,0 +1,11 @@
+require "formalist/elements/standard/check_box"
+require "formalist/elements/standard/date_field"
+require "formalist/elements/standard/date_time_field"
+require "formalist/elements/standard/hidden_field"
+require "formalist/elements/standard/multi_selection_field"
+require "formalist/elements/standard/number_field"
+require "formalist/elements/standard/radio_buttons"
+require "formalist/elements/standard/select_box"
+require "formalist/elements/standard/selection_field"
+require "formalist/elements/standard/text_area"
+require "formalist/elements/standard/text_field"

data/lib/formalist/elements.rb

@@ -0,0 +1,20 @@
+require "dry-container"
+require "formalist/elements/attr"
+require "formalist/elements/compound_field"
+require "formalist/elements/field"
+require "formalist/elements/group"
+require "formalist/elements/many"
+require "formalist/elements/section"
+
+module Formalist
+  class Elements
+    extend Dry::Container::Mixin
+
+    register :attr, Attr
+    register :compound_field, CompoundField
+    register :field, Field
+    register :group, Group
+    register :many, Many
+    register :section, Section
+  end
+end

data/lib/formalist/form/definition_context.rb

@@ -1,14 +1,68 @@
+require "formalist/element/definition"
+
 module Formalist
   class Form
-    # @api private
     class DefinitionContext
-      include Definition
+      DuplicateDefinitionError = Class.new(StandardError)
 
       attr_reader :elements
+      attr_reader :container
+      attr_reader :permissions
 
-      def initialize(&block)
+      def initialize(options = {})
         @elements = []
-        yield(self)
+        @container = options.fetch(:container)
+        @permissions = options.fetch(:permissions)
+      end
+
+      def with(options = {})
+        %i[container permissions].each do |attr|
+          options[attr] ||= send(attr)
+        end
+
+        self.class.new(options)
+      end
+
+      def call(&block)
+        instance_eval(&block) if block
+        self
+      end
+
+      def dep(name)
+        Element::Definition::Deferred.new(name)
+      end
+
+      def method_missing(name, *args, &block)
+        return add_element(name, *args, &block) if element_type_exists?(name)
+        super
+      end
+
+      def respond_to_missing?(name)
+        element_type_exists?(name)
+      end
+
+      private
+
+      def element_type_exists?(type)
+        container.key?(type)
+      end
+
+      def add_element(element_type, *args, &block)
+        type = container[element_type]
+        raise ArgumentError, "element +#{element_type}+ is not permitted in this context" unless permissions.permitted?(type)
+
+        # Work with top-level args and a trailing attributes hash
+        args = args.dup
+        attributes = args.last.is_a?(Hash) ? args.pop : {}
+
+        children = with(permissions: type.permitted_children).call(&block).elements
+        definition = Element::Definition.new(type, *args, attributes, children)
+
+        if elements.any? { |el| el == definition }
+          raise DuplicateDefinitionError, "element +#{element_type} #{args.map(&:inspect).join(', ')}+ is already defined in this context"
+        end
+
+        elements << definition
       end
     end
   end

data/lib/formalist/form/result.rb

@@ -1,5 +1,3 @@
-require "formalist/form/validated_result"
-
 module Formalist
   class Form
     class Result
@@ -7,39 +5,19 @@ module Formalist
       attr_reader :input
 
       # @api private
-      attr_reader :schema
+      attr_reader :messages
 
       # @api private
       attr_reader :elements
 
-      # @api public
-      attr_reader :validation
-
-      def initialize(schema, elements, input)
+      def initialize(input, messages, elements)
         @input = input
-        @schema = schema
-        @elements = elements
-        @validation = schema.(input)
-      end
-
-      def output
-        validation.output
-      end
-
-      def success?
-        true
-      end
-
-      def messages
-        {}
+        @messages = messages
+        @elements = elements.map { |el| el.(input, messages) }
       end
 
       def to_ast
-        elements.map { |el| el.(output, schema.rules.map(&:to_ary), messages).to_ast }
-      end
-
-      def validate
-        ValidatedResult.new(self)
+        elements.map(&:to_ast)
       end
     end
   end