formalist 0.2.2 → 0.2.3

data/lib/formalist/form/validated_result.rb

@@ -1,35 +0,0 @@
-require "forwardable"
-
-module Formalist
-  class Form
-    class ValidatedResult
-      extend Forwardable
-
-      def_delegators :@result,
-        :input,
-        :schema,
-        :elements,
-        :validation,
-        :output
-
-      # @api private
-      attr_reader :result
-
-      def initialize(result)
-        @result = result
-      end
-
-      def success?
-        validation.success?
-      end
-
-      def messages
-        validation.messages
-      end
-
-      def to_ast
-        elements.map { |el| el.(output, schema.rules.map(&:to_ary), messages).to_ast }
-      end
-    end
-  end
-end

data/lib/formalist/output_compiler.rb

@@ -1,43 +0,0 @@
-module Formalist
-  class OutputCompiler
-    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 => value.to_s}
-    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
-  end
-end

data/lib/formalist/validation/collection_rules_compiler.rb

@@ -1,77 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,96 +0,0 @@
-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
-
-        # Support names that show as keypaths, e.g. [:reviews, :rating]
-        name = name.last if name.is_a?(Array)
-
-        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/spec/integration/display_adapters_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe "Display adapters" do
-  let(:schema) {
-    Class.new(Dry::Validation::Schema) do
-      key(:temperature_unit)
-    end.new
-  }
-
-  subject(:form) {
-    Class.new(Formalist::Form) do
-      field :temperature_unit, type: "string", display: "select", option_values: [%w[c c], %w[f f]]
-    end.new(schema)
-  }
-
-  it "outputs an AST" do
-    expect(form.build({}).to_ast).to eq [
-      [:field, [
-        :temperature_unit,
-        "string",
-        "select",
-        nil,
-        [],
-        [],
-        [
-          [:option_values, [["c", "c"], ["f", "f"]]]
-        ]
-      ]]
-    ]
-  end
-
-  it "supports custom disply adapters in a provided container" do
-    adapter_class = Class.new do
-      def call(field)
-        field.to_display_variant("custom")
-      end
-    end
-
-    container = Class.new(Formalist::DisplayAdapters) do
-      register "custom", adapter_class.new
-    end
-
-    form = Class.new(Formalist::Form) do
-      configure do |config|
-        config.display_adapters = container
-      end
-
-      field :name, type: "string", display: "custom"
-      field :email, type: "string"
-    end.new(schema)
-
-    expect(form.build({}).to_ast).to eq [
-      [:field, [:name, "string", "custom", nil, [], [], []]],
-      [:field, [:email, "string", "default", nil, [], [], []]],
-    ]
-  end
-end

data/spec/integration/validation_spec.rb

@@ -1,86 +0,0 @@
-require "dry-validation"
-require "pp"
-
-RSpec.describe "Form validation" do
-  subject(:schema) {
-    Class.new(Dry::Validation::Schema) do
-      key(:title) { |title| title.filled? }
-      key(:rating) { |rating| rating.gteq?(1) & rating.lteq?(10) }
-
-      key(:reviews) do |reviews|
-        reviews.filled? & \
-        reviews.each do |review|
-          review.key(:summary) { |summary| summary.filled? }
-          review.key(:rating) { |rating| rating.gteq?(1) & rating.lteq?(10) }
-        end
-
-      end
-
-      # TODO: uncomment/fix the "meta" related sections (here and below) once
-      # we have a clarification on dryrb/dry-validation#58.
-      #
-      # key(:meta) do |meta|
-      #   meta.key(:pages) { |pages| pages.filled? }
-      # end
-    end.new
-  }
-
-  subject(:form) {
-    Class.new(Formalist::Form) do
-      field :title, type: "string"
-      field :rating, type: "int"
-
-      many :reviews do |review|
-        review.field :summary, type: "string"
-        review.field :rating, type: "int"
-      end
-
-      # attr :meta do |meta|
-      #   meta.field :pages, type: "int"
-      # end
-    end.new(schema)
-  }
-
-  it "includes validation rules and errors in the AST" do
-    input = {
-      reviews: [{summary: "Great", rating: 0}, {summary: "", rating: 1}],
-      meta: {pages: nil}
-    }
-
-    expect(form.build(input).validate.to_ast).to eq [
-      [:field, [:title, "string", "default", nil, [[:predicate, [:filled?, []]]], ["title is missing"], []]],
-      [:field, [:rating, "int", "default", nil, [[:and, [[:predicate, [:gteq?, [1]]], [:predicate, [:lteq?, [10]]]]]], ["rating is missing", "rating must be greater than or equal to 1", "rating must be less than or equal to 10"], []]],
-      [:many, [:reviews,
-        [[:predicate, [:filled?, []]]],
-        [],
-        [
-          [:allow_create, true],
-          [:allow_update, true],
-          [:allow_destroy, true],
-          [:allow_reorder, true],
-        ],
-        [
-          [:field, [:summary, "string", "default", nil, [[:predicate, [:filled?, []]]], [], []]],
-          [:field, [:rating, "int", "default", nil, [[:and, [[:predicate, [:gteq?, [1]]], [:predicate, [:lteq?, [10]]]]]], [], []]],
-        ],
-        [
-          [
-            [:field, [:summary, "string", "default", "Great", [[:predicate, [:filled?, []]]], [], []]],
-            [:field, [:rating, "int", "default", 0, [[:and, [[:predicate, [:gteq?, [1]]], [:predicate, [:lteq?, [10]]]]]], ["rating must be greater than or equal to 1"], []]],
-          ],
-          [
-            [:field, [:summary, "string", "default", "", [[:predicate, [:filled?, []]]], ["summary must be filled"], []]],
-            [:field, [:rating, "int", "default", 1, [[:and, [[:predicate, [:gteq?, [1]]], [:predicate, [:lteq?, [10]]]]]], [], []]],
-          ]
-        ],
-      ]],
-      # [:attr, [:meta,
-      #   [],
-      #   [],
-      #   [
-      #     [:field, [:pages, "int", "default", nil, [[:predicate, [:filled?, []]]], ["pages must be filled"], []]]
-      #   ],
-      # ]]
-    ]
-  end
-end

data/spec/unit/output_compiler_spec.rb

@@ -1,70 +0,0 @@
-RSpec.describe Formalist::OutputCompiler do
-  subject(:compiler) { Formalist::OutputCompiler.new }
-
-  let(:schema) {
-    Class.new(Dry::Validation::Schema) do
-      key(:title, &:str?)
-      key(:rating, &:int?)
-
-      key(:reviews) do |reviews|
-        reviews.each do |review|
-          review.key(:description, &:str?)
-          review.key(:rating, &:int?)
-        end
-      end
-
-      key(:meta) do |meta|
-        meta.key(:pages, &:int?)
-        meta.key(:publisher, &:str?)
-      end
-    end.new
-  }
-
-  let(:form) {
-    Class.new(Formalist::Form) do
-      field :title, type: "string"
-      field :rating, type: "int"
-
-      many :reviews do |review|
-        review.field :description, type: "string"
-        review.field :rating, type: "int"
-      end
-
-      attr :meta do |meta|
-        meta.section "Metadata" do |section|
-          section.group do |group|
-            group.field :pages, type: "int"
-            group.field :publisher, type: "string"
-          end
-        end
-      end
-    end.new(schema)
-  }
-
-  let(:input) {
-    {
-      title: "Aurora",
-      rating: "10",
-      reviews: [
-        {
-          description: "Wonderful",
-          rating: "10",
-        },
-        {
-          description: "Enchanting",
-          rating: "9",
-        }
-      ],
-      meta: {
-        pages: "321",
-        publisher: "Orbit",
-      },
-    }
-  }
-
-  let(:ast) { form.build(input).to_ast }
-
-  it "works" do
-    expect(compiler.call(ast)).to eq input
-  end
-end