formalist 0.3.0 → 0.4.0

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

@@ -0,0 +1,40 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+require "formalist/rich_text/embedded_form_compiler"
+
+module Formalist
+  class Elements
+    class RichTextArea < Field
+      attribute :box_size, Types::String.enum("single", "small", "normal", "large", "xlarge"), default: "normal"
+      attribute :inline_formatters, Types::Array
+      attribute :block_formatters, Types::Array
+      attribute :embeddable_forms, Types::Dependency.constrained(respond_to: :to_h)
+
+      # FIXME: it would be tidier to have a reader method for each attribute
+      def attributes
+        super.merge(embeddable_forms: embeddable_forms_config)
+      end
+
+      def input
+        input_compiler.(@input)
+      end
+
+      private
+
+      # Replace the form objects with their AST
+      def embeddable_forms_config
+        @attributes[:embeddable_forms].to_h.map { |key, attrs|
+          [key, attrs.merge(form: attrs[:form].to_ast)]
+        }.to_h
+      end
+
+      # TODO: make compiler configurable somehow?
+      def input_compiler
+        RichText::EmbeddedFormCompiler.new(@attributes[:embeddable_forms])
+      end
+    end
+
+    register :rich_text_area, RichTextArea
+  end
+end

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

@@ -0,0 +1,20 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class SearchMultiSelectionField < Field
+      attribute :selector_label, Types::String
+      attribute :render_option_as, Types::String
+      attribute :render_selection_as, Types::String
+      attribute :search_url, Types::String
+      attribute :search_per_page, Types::Int
+      attribute :search_params, Types::Hash
+      attribute :search_threshold, Types::Int
+      attribute :selections, Types::Array
+    end
+
+    register :search_multi_selection_field, SearchMultiSelectionField
+  end
+end

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

@@ -0,0 +1,20 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class SearchSelectionField < Field
+      attribute :selector_label, Types::String
+      attribute :render_option_as, Types::String
+      attribute :render_selection_as, Types::String
+      attribute :search_url, Types::String
+      attribute :search_per_page, Types::Int
+      attribute :search_params, Types::Hash
+      attribute :search_threshold, Types::Int
+      attribute :selection, Types::Hash
+    end
+
+    register :search_selection_field, SearchSelectionField
+  end
+end

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

@@ -0,0 +1,16 @@
+require "formalist/element"
+require "formalist/elements"
+require "formalist/types"
+
+module Formalist
+  class Elements
+    class TagsField < Field
+      attribute :search_url, Types::String
+      attribute :search_per_page, Types::Int
+      attribute :search_params, Types::Hash
+      attribute :search_threshold, Types::Int
+    end
+
+    register :tags_field, TagsField
+  end
+end

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

@@ -6,6 +6,14 @@ module Formalist
   class Elements
     class UploadField < Field
       attribute :presign_url, Types::String
+      attribute :presign_options, Types::Hash
+      attribute :render_uploaded_as, Types::String
+      attribute :upload_prompt, Types::String
+      attribute :upload_action_label, Types::String
+      attribute :max_file_size, Types::String
+      attribute :max_file_size_message, Types::String
+      attribute :permitted_file_type_message, Types::String
+      attribute :permitted_file_type_regex, Types::String
     end
 
     register :upload_field, UploadField

data/lib/formalist/elements/standard.rb

@@ -6,8 +6,12 @@ require "formalist/elements/standard/multi_selection_field"
 require "formalist/elements/standard/multi_upload_field"
 require "formalist/elements/standard/number_field"
 require "formalist/elements/standard/radio_buttons"
+require "formalist/elements/standard/rich_text_area"
+require "formalist/elements/standard/search_selection_field"
+require "formalist/elements/standard/search_multi_selection_field"
 require "formalist/elements/standard/select_box"
 require "formalist/elements/standard/selection_field"
+require "formalist/elements/standard/tags_field"
 require "formalist/elements/standard/text_area"
 require "formalist/elements/standard/text_field"
 require "formalist/elements/standard/upload_field"

data/lib/formalist/form/validity_check.rb

@@ -0,0 +1,54 @@
+module Formalist
+  class Form
+    class ValidityCheck
+      def call(form_ast)
+        form_ast.map { |node| visit(node) }.all?
+      end
+      alias_method :[], :call
+
+      private
+
+      def visit(node)
+        name, nodes = node
+
+        send(:"visit_#{name}", nodes)
+      end
+
+      def visit_attr(node)
+        _name, _type, errors, _attributes, children = node
+
+        errors.empty? && children.map { |child| visit(child) }.all?
+      end
+
+      def visit_compound_field(node)
+        _type, _attributes, children = node
+
+        children.map { |child| visit(child) }.all?
+      end
+
+      def visit_field(node)
+        _name, _type, _input, errors, _attributes = node
+
+        errors.empty?
+      end
+
+      def visit_group(node)
+        _type, _attributes, children = node
+
+        children.map { |child| visit(child) }.all?
+      end
+
+      def visit_many(node)
+        _name, _type, errors, _attributes, _child_template, children = node
+
+        errors.empty? && children.map { |child| visit(child) }.all?
+      end
+
+      def visit_section(node)
+        _name, _type, _attributes, children = node
+
+        children.map { |child| visit(child) }.all?
+      end
+    end
+  end
+end

data/lib/formalist/form.rb

@@ -1,32 +1,64 @@
-require "dry-configurable"
+require "dry/configurable"
+require "dry/core/constants"
 require "formalist/elements"
-require "formalist/form/definition_context"
-require "formalist/element/permitted_children"
-require "formalist/form/result"
+require "formalist/definition"
 
 module Formalist
   class Form
     extend Dry::Configurable
+    include Dry::Core::Constants
 
     setting :elements_container, Elements
 
-    # @api private
-    def self.elements
-      @elements ||= []
+    class << self
+      attr_reader :definition
+
+      def define(&block)
+        @definition = block
+      end
+    end
+
+    attr_reader :elements
+    attr_reader :input
+    attr_reader :errors
+    attr_reader :dependencies
+
+    def initialize(elements: Undefined, input: {}, errors: {}, **dependencies)
+      @input = input
+      @errors = errors
+
+      @elements =
+      if elements == Undefined
+        Definition.new(self, self.class.config, &self.class.definition).elements
+      else
+        elements
+      end
+
+      @dependencies = dependencies
+    end
+
+    def fill(input: {}, errors: {})
+      return self if input == @input && errors = @errors
+
+      self.class.new(
+        elements: @elements.map { |element| element.fill(input: input, errors: errors) },
+        input: input,
+        errors: errors,
+        **@dependencies,
+      )
     end
 
-    # @api public
-    def self.define(&block)
-      @elements = DefinitionContext.new(
-        container: config.elements_container,
-        permissions: Element::PermittedChildren.all
-      ).call(&block).elements
+    def with(**new_dependencies)
+      self.class.new(
+        elements: @elements,
+        input: @input,
+        errors: @errors,
+        **@dependencies.merge(new_dependencies)
+      )
     end
 
-    # @api public
-    def build(input = {}, messages = {})
-      elements = self.class.elements.map { |el| el.resolve(self) }
-      Result.new(input, messages, elements)
+    def to_ast
+      elements.map(&:to_ast)
     end
   end
 end

data/lib/formalist/rich_text/embedded_form_compiler.rb

@@ -0,0 +1,86 @@
+require "json"
+
+module Formalist
+  module RichText
+
+    # Our input data looks like this example, which consists of 3 elements:
+    #
+    # 1. A text line
+    # 2. embedded form data
+    # 3. Another text line
+    #
+    # [
+    #   ["block",["unstyled","b14hd",[["inline",[[],"Before!"]]]]],
+    #   ["block",["atomic","48b4f",[["entity",["formalist","1","IMMUTABLE",{"name":"image_with_caption","label":"Image with caption","data":{"image_id":"5678","caption":"Large panda"}},[["inline",[[],"¶"]]]]]]]],
+    #   ["block",["unstyled","aivqi",[["inline",[[],"After!"]]]]]
+    # ]
+    #
+    # We want to intercept the embededed form data and transform them into full
+    # form ASTs, complete with validation messages.
+
+    class EmbeddedFormCompiler
+      attr_reader :embedded_forms
+
+      def initialize(embedded_form_collection)
+        @embedded_forms = embedded_form_collection
+      end
+
+      def call(ast)
+        return ast if ast.nil?
+
+        ast = ast.is_a?(String) ? JSON.parse(ast) : ast
+
+        ast.map { |node| visit(node) }
+      end
+      alias_method :[], :call
+
+      private
+
+      def visit(node)
+        name, nodes = node
+
+        handler = :"visit_#{name}"
+
+        if respond_to?(handler, true)
+          send(handler, nodes)
+        else
+          [name, nodes]
+        end
+      end
+
+      # We need to visit blocks in order to get to the formalist entities nested within them
+      def visit_block(node)
+        type, id, children = node
+
+        ["block", [type, id, children.map { |child| visit(child) }]]
+      end
+
+      def visit_entity(node)
+        type, key, mutability, entity_data, children = node
+
+        return ["entity", node] unless type == "formalist"
+
+        embedded_form = embedded_forms[entity_data["name"]]
+
+        compiled_entity_data = entity_data.merge(
+          "label" => embedded_form.label,
+          "form" => prepare_form_ast(embedded_form, entity_data["data"])
+        )
+
+        ["entity", [type, key, mutability, compiled_entity_data, children]]
+      end
+
+      def prepare_form_ast(embedded_form, data)
+        # Run the raw data through the validation schema
+        validation = embedded_form.schema.(data)
+
+        # And then through the embedded form's input processor (which may add
+        # extra system-generated information necessary for the form to render
+        # fully)
+        input = embedded_form.input_processor.(validation.to_h)
+
+        embedded_form.form.fill(input: input, errors: validation.messages).to_ast
+      end
+    end
+  end
+end

data/lib/formalist/rich_text/embedded_forms_container/mixin.rb

@@ -0,0 +1,42 @@
+require "dry-container"
+require "formalist/rich_text/embedded_forms_container/registration"
+
+module Formalist
+  module RichText
+    class EmbeddedFormsContainer
+      module Mixin
+        def self.included(base)
+          base.class_eval do
+            include ::Dry::Container::Mixin
+            include Methods
+          end
+        end
+
+        def self.extended(base)
+          base.class_eval do
+            extend ::Dry::Container::Mixin
+            extend Methods
+          end
+        end
+
+        module Methods
+          def resolve(key)
+            super(key.to_s)
+          end
+
+          def register(key, **attrs)
+            super(key.to_s, Registration.new(attrs))
+          end
+
+          def to_h
+            keys.each_with_object({}) { |key, output|
+              output[key] = self[key].to_h
+            }
+          end
+
+          # TODO: methods to return filtered sets of registrations
+        end
+      end
+    end
+  end
+end

data/lib/formalist/rich_text/embedded_forms_container/registration.rb

@@ -0,0 +1,30 @@
+module Formalist
+  module RichText
+    class EmbeddedFormsContainer
+      class Registration
+        DEFAULT_INPUT_PROCESSOR = -> input { input }.freeze
+
+        attr_reader :label
+        attr_reader :form
+        attr_reader :schema
+        attr_reader :input_processor
+
+        def initialize(label:, form:, schema:, input_processor: DEFAULT_INPUT_PROCESSOR)
+          @label = label
+          @form = form
+          @schema = schema
+          @input_processor = input_processor
+        end
+
+        def to_h
+          {
+            label: label,
+            form: form,
+            schema: schema,
+            input_processor: input_processor,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/formalist/rich_text/embedded_forms_container.rb

@@ -0,0 +1,9 @@
+require "formalist/rich_text/embedded_forms_container/mixin"
+
+module Formalist
+  module RichText
+    class EmbeddedFormsContainer
+      include Mixin
+    end
+  end
+end

data/lib/formalist/rich_text/rendering/embedded_form_renderer.rb

@@ -0,0 +1,25 @@
+module Formalist
+  module RichText
+    module Rendering
+      class EmbeddedFormRenderer
+        attr_reader :container
+        attr_reader :options
+
+        def initialize(container = {}, **options)
+          @container = container
+          @options = options
+        end
+
+        def call(form_data)
+          type, data = form_data.values_at(:name, :data)
+
+          if container.key?(type)
+            container[type].(data, options)
+          else
+            ""
+          end
+        end
+      end
+    end
+  end
+end

data/lib/formalist/rich_text/rendering/html_compiler.rb

@@ -0,0 +1,100 @@
+module Formalist
+  module RichText
+    module Rendering
+      class HTMLCompiler
+        EMBEDDED_FORM_TYPE = "formalist".freeze
+        LIST_ITEM_TYPES = %w[unordered-list-item ordered-list-item].freeze
+
+        attr_reader :html_renderer
+        attr_reader :embedded_form_renderer
+
+        def initialize(html_renderer:, embedded_form_renderer:)
+          @html_renderer = html_renderer
+          @embedded_form_renderer = embedded_form_renderer
+        end
+
+        def call(ast)
+          html_renderer.nodes(wrap_lists(ast)) do |node|
+            visit(node)
+          end
+        end
+
+        private
+
+        def visit(node)
+          type, content = node
+
+          send(:"visit_#{type}", content)
+        end
+
+        def visit_block(data)
+          type, key, children = data
+
+          html_renderer.block(type, key, wrap_lists(children)) do |child|
+            visit(child)
+          end
+        end
+
+        def visit_wrapper(data)
+          type, children = data
+
+          html_renderer.wrapper(type, children) do |child|
+            visit(child)
+          end
+        end
+
+        def visit_inline(data)
+          styles, text = data
+
+          html_renderer.inline(styles, text)
+        end
+
+        def visit_entity(data)
+          type, key, _mutability, data, children = data
+
+          # FIXME
+          # Temporary fix to handle data that comes through with keys as
+          # strings instead of symbols
+          data = data.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+          if type == EMBEDDED_FORM_TYPE
+            embedded_form_renderer.(data)
+          else
+            html_renderer.entity(type, key, data, wrap_lists(children)) do |child|
+              visit(child)
+            end
+          end
+        end
+
+        def wrap_lists(nodes)
+          chunked = nodes.chunk do |node|
+            type, content = node
+
+            if type == "block"
+              content[0] # return the block's own type
+            else
+              type
+            end
+          end
+
+          chunked.inject([]) { |output, (type, chunk)|
+            if list_item?(type)
+              output << convert_to_wrapper_node(type, chunk)
+            else
+              # Flatten again by appending chunk onto array
+              output + chunk
+            end
+          }
+        end
+
+        def convert_to_wrapper_node(type, children)
+          ["wrapper", [type, children]]
+        end
+
+        def list_item?(type)
+          LIST_ITEM_TYPES.include?(type)
+        end
+      end
+    end
+  end
+end