formalism 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 704ad27d3b6f2c48ceb930195acedcc634642e14d76cdf396c8c005ca8af067f
+  data.tar.gz: c38eb79190667e0576bcb0e30bbc5564246ef9d14d6f9d0b4de657857ee4aa33
+SHA512:
+  metadata.gz: b5838dc86618cae1f6674154ff496e5f2856665daa9b840122430da9425054c3c17c1329fc96091ef2798a1681b78ea4aa526f2c9b7bab2654ca9233b91fb196
+  data.tar.gz: b40a969a78b0f1e820ae9b1fbe1d1cafad933f35155cc2ac5a972475a1d6e8eb5851b6d1d3ba049c2c7e25659edf1a9bd72ccad9715643e979d95f2c5c05c7fe

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## master (unreleased)
+
+## 0.2.0 (2020-09-23)
+
+## 0.1.0 (2020-07-09)
+
+## 0.0.0 (2020-07-09)
+
+*   Initial version

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Alexander Popov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,310 @@
+# Formalism
+
+[![Cirrus CI - Base Branch Build Status](https://img.shields.io/cirrus/github/AlexWayfer/formalism?style=flat-square)](https://cirrus-ci.com/github/AlexWayfer/formalism)
+[![Codecov branch](https://img.shields.io/codecov/c/github/AlexWayfer/formalism/master.svg?style=flat-square)](https://codecov.io/gh/AlexWayfer/formalism)
+[![Code Climate](https://img.shields.io/codeclimate/maintainability/AlexWayfer/formalism.svg?style=flat-square)](https://codeclimate.com/github/AlexWayfer/formalism)
+[![Depfu](https://img.shields.io/depfu/AlexWayfer/benchmark_toys?style=flat-square)](https://depfu.com/repos/github/AlexWayfer/formalism)
+[![Inline docs](https://inch-ci.org/github/AlexWayfer/formalism.svg?branch=master)](https://inch-ci.org/github/AlexWayfer/formalism)
+[![license](https://img.shields.io/github/license/AlexWayfer/formalism.svg?style=flat-square)](https://github.com/AlexWayfer/formalism/blob/master/LICENSE.txt)
+[![Gem](https://img.shields.io/gem/v/formalism.svg?style=flat-square)](https://rubygems.org/gems/formalism)
+
+Ruby gem for forms with validations and nesting.
+
+## Why
+
+I need for service-like objects.
+
+I've explored these projects:
+
+*   [Reform](https://github.com/trailblazer/reform)
+*   [Mutations](https://github.com/cypriss/mutations)
+*   [Interactor](https://github.com/collectiveidea/interactor)
+*   [dry-rb](https://github.com/dry-rb)
+
+But nothing of them supports all features I need for:
+
+*   nesting (into unlimited levels) of themselves;
+*   simple syntax;
+*   custom validations and coercions;
+*   unified output.
+
+So, I've tried to combine these all into one library and got Formalism.
+
+### Why here are forms and what about service objects?
+
+I've discovered that form object, only with validations,
+are useless without service objects. So, I've combined them:
+service objects include validations.
+
+### If these are service objects, why they called forms?
+
+Because if we're combining them — it's more like forms with logic inside for me
+than service objects built-in forms. Even in HTML we're writing `<form>`.
+So, Formalism can accept all data from any-difficult `<form>` and process it,
+also with nested forms (for example, if you have some request form
+with contact data and want to pass contacts into something like user form).
+
+### And if I need for simple service object without validation?
+
+You can use `Formalism::Action`, a parent of `Formalism::Form`.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'formalism'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+Or install it yourself as:
+
+```shell
+gem install formalism
+```
+
+## Usage
+
+### Basic example
+
+```ruby
+class FindArtistForm < Formalism::Form
+  field :name
+
+  private
+
+  def validate
+    if name.to_s.empty?
+      errors.add 'Name is not provided'
+    end
+  end
+
+  def execute
+    Artist.first(fields_and_nested_forms)
+  end
+end
+
+class CreateAlbumForm < Formalism::Form
+  field :name, String
+  fiels :tags, Array, of: String
+  nested :artist, FindArtistForm
+
+  private
+
+  def validate
+    if name.to_s.empty?
+      errors.add 'Name is not provided'
+    end
+  end
+
+  def execute
+    Album.create(fields_and_nested_forms)
+  end
+end
+
+form = CreateAlbumForm.new(
+  name: 'Hits', tags: %w[Indie Rock Hits], artist: { name: 'Alex' }
+)
+form.run
+```
+
+### Running
+
+Usually you need to initialize a form and execute `#run` method.
+Internally, it runs `#valid?` (public) and `#execute` (private) methods.
+`#valid?` runs `#validate` (private) of a form itself and nested forms.
+`#run` can be redefined for database transaction, for example.
+
+Also you can call `.run` with arguments for `#initialize`,
+it's the alias for `#initialize` + `#run`.
+
+#### Form outcome
+
+Any call of `run` returns `Form::Outcome` instance which has `#success?`,
+`#result` and `#errors` methods. Result is a result of `#execute` method.
+Be careful: calling `#result` for failed outcome will raise `ValidationError`.
+
+### Field type
+
+Field receives type as the second argument.
+It's not required.
+It can be a constant, String or Symbol.
+If specified — there is a coercion to specified type,
+if not — data remains unchanged.
+
+Nested forms — their class, as constant.
+Type or `:initialize` block is required.
+
+Formalism also supports `Array` type with the optional `:of` option
+(type of elements).
+Coercion will be applied to a data itself and to its elements.
+
+#### Coercion
+
+There is built-in coercion into some types, if you try to coerce
+to undefined type — you'll get `Formalism::Form::NoCoercionError`.
+
+You can define a coercion to some type via definition of such class:
+
+```ruby
+# frozen_string_literal: true
+
+module Formalism
+  class Form < Action
+    class Coercion
+      ## Class for coercion to String
+      class String < Base
+        private
+
+        def execute
+          @value&.to_s
+        end
+      end
+    end
+  end
+end
+```
+
+### Default value
+
+`field` and `nested` accepts `:default` option.
+It can be any value, if it's an instance of `Proc` — it'll be executed
+in the form instance scope.
+
+### Different keys
+
+`field` supports `:key` option (Symbol) to receive data by a different key,
+not as a field name.
+
+### Custom initialization of nested forms
+
+By default, nested forms initialized with data by key as their name
+in parent data. So, if a parent receive `{ foo: 1, bar: { baz: 2 } }`,
+it's nested form `:bar` will receive `{ baz: 2 }`.
+
+If you want to prevent initialization at all, or pass custom arguments —
+you should use `:initialize` option which accepts a proc
+with a form class argument.
+
+If you want to just refine incoming data (add or remove) — you should define
+`#params_for_nested_*` private method, where `*` is a nested form name.
+You can use `super` inside.
+
+### Order of filling with data
+
+Fields and nested forms are filling in order of their definition.
+But sometimes you want to change this order, for example,
+if you have a nested forms in ancestors which depends on data in children forms.
+For such cases you can use `:depends_on` option, which accepts fields
+and nested forms names as Symbol or Array of symbols. They will be filled
+(and initialized) before dependent.
+
+### Merging into final data
+
+There is `Form#fields_and_nested_forms` as final data
+(after coercion, defaults, etc). But you may want to not include some fields
+or nested forms into this data. You can do it via `:merge` option,
+which can be `true`, `false` or `Proc` (executed in form's instance scope).
+
+For example:
+
+```ruby
+field :bar, merge: true
+nested :only_valid, nested_form_class, merge: ->(form) { form.valid? }
+```
+
+### Runnable
+
+You can disable `#valid?` and `#run` of forms (including nested ones)
+by setting `form.runnable = false`.
+It can be helpful for some cases, for example, with policies (permissions):
+
+```ruby
+def initialize_nested_form(name, options)
+  return unless (form = super)
+
+  form.runnable = allowed_to_change?(name)
+  form
+end
+```
+
+### Inheritance
+
+Any `class ChildForm < ParentForm` will have all fields and nested forms
+from `ParentForm`.
+
+#### Removing (inherited) field
+
+But you're able to remove (usually inherited) fields by:
+
+```ruby
+class ChildForm < ParentForm
+  remove_field :field_from_parent
+end
+```
+
+#### Modules
+
+You can define modules and use them later like this:
+
+```ruby
+module CommonFields
+  include Formalism::Form::Fields
+
+  field :base_field
+  nested :base_nested
+end
+
+class SomeForm < Formalism::Form
+  include CommonFields
+
+  field :another_field
+end
+```
+
+### Convert to params
+
+You can convert a Form back to (processed) params, for example, for view render:
+
+```ruby
+form = CreateAlbumForm.new(
+  name: 'Hits', tags: %w[Indie Rock Hits], artist: { name: 'Alex' }
+)
+
+form.to_params
+# {
+#   name: 'Hits',
+#   tags: %w[Indie Rock Hits],
+#   artist: { name: 'Alex' }
+# }
+```
+
+### Actions
+
+For actions without fields, nesting and validation you can use
+`Formalism::Action` (the parent of `Formalism::Form`).
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies.
+
+Then, run `toys rspec` to run the tests.
+
+To install this gem onto your local machine, run `toys gem install`.
+
+To release a new version, run `toys gem release %version%`.
+See how it works [here](https://github.com/AlexWayfer/gem_toys#release).
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/AlexWayfer/formalism).
+
+## License
+
+The gem is available as open source under the terms of the
+[MIT License](https://opensource.org/licenses/MIT).

data/lib/formalism.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'formalism/action'
+require_relative 'formalism/form'

data/lib/formalism/action.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'gorilla_patch/deep_dup'
+
+module Formalism
+	## Class for any action
+	class Action
+		class << self
+			def run(*args)
+				new(*args).run
+			end
+		end
+
+		attr_reader :params
+		attr_accessor :runnable
+
+		using GorillaPatch::DeepDup
+
+		def initialize(params = {})
+			@runnable = true unless defined? @runnable
+			@params = params.deep_dup || {}
+		end
+
+		def run
+			return unless runnable
+
+			execute
+		end
+	end
+end

data/lib/formalism/form.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'form/fields'
+require_relative 'form/filling'
+require_relative 'form/outcome'
+require_relative 'form/validation_error'
+
+module Formalism
+	## Class for forms
+	class Form < Action
+		include Form::Fields
+		include Filling
+
+		attr_reader :instance
+
+		def self.inherited(child)
+			super
+
+			child.fields_and_nested_forms.merge!(fields_and_nested_forms)
+		end
+
+		def initialize(params_or_instance = {})
+			if params_or_instance.is_a?(Hash)
+				super
+			else
+				super({})
+
+				@instance = params_or_instance
+			end
+
+			fill_fields_and_nested_forms
+		end
+
+		def valid?
+			return unless runnable
+
+			errors.clear
+
+			nested_forms.each_value(&:valid?)
+
+			validate
+
+			merge_errors_of_nested_forms
+
+			return false if errors.any?
+
+			true
+		end
+
+		def run
+			return unless runnable
+
+			return Outcome.new(errors) unless valid?
+
+			Outcome.new(errors, super)
+		end
+
+		protected
+
+		def errors
+			@errors ||= Set.new
+		end
+
+		private
+
+		def validate; end
+
+		def instance_respond_to?(name)
+			return false unless defined? @instance
+
+			@instance.respond_to?(name)
+		end
+
+		def instance_public_send(name)
+			return false unless defined? @instance
+
+			@instance.public_send(name)
+		end
+
+		def merge_errors_of_nested_forms
+			nested_forms.each do |name, nested_form|
+				should_be_merged = self.class.fields_and_nested_forms[name].fetch(:merge_errors, true)
+				should_be_merged = instance_exec(&should_be_merged) if should_be_merged.is_a?(Proc)
+
+				next unless should_be_merged && nested_form.errors.any?
+
+				merge_errors_of_nested_form name, nested_form
+			end
+		end
+
+		def merge_errors_of_nested_form(_name, nested_form)
+			errors.merge nested_form.errors
+		end
+	end
+end

data/lib/formalism/form/coercion.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'gorilla_patch/inflections'
+
+Dir[
+	File.join(__dir__, 'coercion', '**', '*.rb')
+]
+	.sort_by! { |file| [File.basename(file).start_with?('_') ? 1 : 2, file] }
+	.each { |file| require file }
+
+## https://github.com/bbatsov/rubocop/issues/5831
+module Formalism
+	class Form < Action
+		## Class for coercion (check, initialization)
+		class Coercion
+			def initialize(type, of = nil)
+				@type = type
+				@of = of
+			end
+
+			def check
+				## It's custom error! But cop triggers for single argument anyway.
+				# rubocop:disable Style/RaiseArgs
+				raise NoCoercionError.new(@type) unless exist?
+				# rubocop:enable Style/RaiseArgs
+
+				return unless const_name == 'Array' && @of
+
+				self.class.new(@of).check
+			end
+
+			def result_for(value)
+				coercion_class = exist? ? const_name : 'Base'
+
+				self.class.const_get(coercion_class, false).new(value, @of).result
+			end
+
+			private
+
+			using GorillaPatch::Inflections
+
+			def const_name
+				@type.to_s.camelize
+			end
+
+			def exist?
+				self.class.const_defined?(const_name, false)
+			rescue NameError
+				false
+			end
+		end
+
+		## Error for undefined type in coercion
+		class NoCoercionError < ArgumentError
+			def initialize(type)
+				super "Formalism has no coercion to #{type}"
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/_base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Base class for coercion
+			class Base
+				def initialize(value, *)
+					@value = value
+
+					type_name = self.class.name.split('::')[3..-1].join('::')
+
+					@type =
+						if Object.const_defined?(type_name, false)
+						then Object.const_get(type_name, false)
+						else type_name
+						end
+				end
+
+				def result
+					return @value unless should_be_coreced?
+
+					execute
+				end
+
+				private
+
+				def should_be_coreced?
+					@type != 'Base' && !(@type.is_a?(Class) && @value.is_a?(@type))
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/_numeric.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Base class for coercion to Numeric
+			class Numeric < Base
+				class << self
+					private
+
+					def wrap_value_regexp(content)
+						/\A\s*#{content}\s*\z/.freeze
+					end
+				end
+
+				private
+
+				def execute
+					return unless self.class::VALUE_REGEXP.match? @value.to_s
+
+					@value.public_send(self.class::CONVERSION_METHOD)
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/array.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Array
+			class Array < Base
+				def initialize(value, of = nil)
+					super
+
+					@of = of
+				end
+
+				private
+
+				def should_be_coreced?
+					true
+				end
+
+				def execute
+					result = @value.to_a
+
+					return result unless @of
+
+					result.map! { |element| Coercion.new(@of).result_for(element) }
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/boolean.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to boolean
+			class Boolean < Base
+				private
+
+				def execute
+					@value && @value.to_s != 'false' ? true : false
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/date.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Date
+			class Date < Base
+				private
+
+				def execute
+					return if @value.nil?
+
+					::Date.parse(@value)
+				rescue ArgumentError => e
+					raise unless e.message == 'invalid date'
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/float.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Float
+			class Float < Numeric
+				## https://stackoverflow.com/a/36946626/2630849
+				VALUE_REGEXP = wrap_value_regexp '[-+]?(?:\d+(?:\.\d*)?|\.\d+)'
+
+				CONVERSION_METHOD = :to_f
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/hash.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Hash
+			class Hash < Base
+				private
+
+				def execute
+					@value&.to_h
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/integer.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Integer
+			class Integer < Numeric
+				## https://stackoverflow.com/a/1235990/2630849
+				VALUE_REGEXP = wrap_value_regexp '[-+]?\d+'
+
+				CONVERSION_METHOD = :to_i
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/string.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to String
+			class String < Base
+				private
+
+				def execute
+					@value&.to_s
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/symbol.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Symbol
+			class Symbol < Base
+				private
+
+				def execute
+					@value&.to_sym
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/coercion/time.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		class Coercion
+			## Class for coercion to Time
+			class Time < Base
+				private
+
+				def execute
+					case @value
+					when ::String
+						::Time.parse @value
+					when ::Integer
+						::Time.at @value
+					end
+				rescue ArgumentError => e
+					raise unless e.message.include? 'out of range'
+				end
+			end
+		end
+	end
+end

data/lib/formalism/form/fields.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'module_methods'
+
+require_relative 'coercion'
+
+module Formalism
+	class Form < Action
+		## Extend some module or class with this module for fields
+		module Fields
+			extend ::ModuleMethods::Extension
+
+			## Module for class methods
+			module ClassMethods
+				def included(something)
+					super
+
+					fields_and_nested_forms.each do |name, options|
+						if options.key?(:form)
+							something.nested name, options[:form], **options
+						else
+							something.field name, options[:type], **options
+						end
+					end
+				end
+
+				def fields_and_nested_forms
+					@fields_and_nested_forms ||= {}
+				end
+
+				def field(name, type = nil, **options)
+					Coercion.new(type, options[:of]).check unless type.nil?
+
+					fields_and_nested_forms[name] = options.merge(type: type)
+
+					define_field_methods(name)
+				end
+
+				def nested(name, form = nil, **options)
+					unless form || options.key?(:initialize)
+						raise ArgumentError, 'Neither form class nor initialize block ' \
+							'is not present'
+					end
+
+					fields_and_nested_forms[name] = options.merge(form: form)
+
+					define_nested_form_methods(name)
+				end
+
+				private
+
+				def remove_field(name)
+					fields_and_nested_forms.delete name
+
+					undef_method name
+					undef_method "#{name}="
+				end
+
+				def define_field_methods(name)
+					module_for_accessors.instance_exec do
+						define_method(name) { fields[name] }
+
+						private
+
+						define_method("#{name}=") do |value|
+							options = self.class.fields_and_nested_forms[name]
+							coerced_value =
+								Coercion.new(*options.values_at(:type, :of)).result_for(value)
+							fields[name] = coerced_value
+						end
+					end
+				end
+
+				def define_nested_form_methods(name)
+					module_for_accessors.instance_exec do
+						define_method("#{name}_form") { nested_forms[name] }
+
+						define_method(name) { nested_forms[name].instance }
+					end
+
+					define_params_for_nested_method name
+				end
+
+				def define_params_for_nested_method(name)
+					params_method_name = "params_for_nested_#{name}"
+					params_method_defined =
+						method_defined?(params_method_name) ||
+						private_method_defined?(params_method_name)
+
+					module_for_accessors.instance_exec do
+						private
+
+						define_method(params_method_name) { @params[name] } unless params_method_defined
+					end
+				end
+
+				def module_for_accessors
+					if const_defined?(:FieldsAccessors, false)
+						mod = const_get(:FieldsAccessors)
+					else
+						mod = const_set(:FieldsAccessors, Module.new)
+						include mod
+					end
+					mod
+				end
+			end
+
+			def fields(for_merge: false)
+				@fields ||= {}
+
+				return @fields unless for_merge
+
+				select_for_merge(:fields)
+			end
+
+			def to_params
+				fields.merge(
+					nested_forms.each_with_object({}) do |(name, nested_form), result|
+						result.merge! nested_form_to_params name, nested_form
+					end
+				)
+			end
+
+			private
+
+			def nested_forms
+				@nested_forms ||= {}
+			end
+
+			def fields_and_nested_forms(for_merge: true)
+				merging_nested_forms =
+					for_merge ? select_for_merge(:nested_forms) : nested_forms
+
+				fields(for_merge: for_merge).merge(
+					merging_nested_forms
+						.map { |name, _nested_form| [name, public_send(name)] }
+						.to_h
+				)
+			end
+
+			def select_for_merge(type)
+				send(type).select do |name, value|
+					merge = self.class.fields_and_nested_forms[name].fetch(:merge, true)
+					merge.is_a?(Proc) ? instance_exec(value, &merge) : merge
+				end
+			end
+
+			def nested_form_to_params(name_of_nested_form, nested_form)
+				{ name_of_nested_form => nested_form.to_params }
+			end
+		end
+	end
+end

data/lib/formalism/form/filling.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		## Module for filling forms with data
+		module Filling
+			private
+
+			def fill_fields_and_nested_forms
+				@filled_fields_and_nested_forms = []
+
+				self.class.fields_and_nested_forms.each_key do |name|
+					fill_field_or_nested_form name
+				end
+			end
+
+			def fill_field_or_nested_form(name)
+				return if @filled_fields_and_nested_forms.include? name
+
+				options = self.class.fields_and_nested_forms[name]
+
+				fill_depends(*options[:depends_on])
+
+				if options.key?(:form)
+					fill_nested_form name, options
+				else
+					fill_field name, options
+				end
+
+				@filled_fields_and_nested_forms.push name
+			end
+
+			def fill_depends(*depends_on)
+				depends_on.each do |depends_name|
+					next unless self.class.fields_and_nested_forms.key?(depends_name)
+
+					fill_field_or_nested_form depends_name
+				end
+			end
+
+			def fill_field(name, options)
+				key = options.fetch(:key, name)
+				setter = "#{name}="
+
+				if @params.key?(key)
+					send setter, @params[key]
+				elsif instance_respond_to?(key)
+					send setter, instance_public_send(key)
+				elsif options.key?(:default) && !fields.include?(key)
+					send setter, process_default(options[:default])
+				end
+			end
+
+			def fill_nested_form(name, options)
+				return unless (form = initialize_nested_form(name, options))
+
+				nested_forms[name] = form
+			end
+
+			def process_default(default)
+				default.is_a?(Proc) ? instance_exec(&default) : default
+			end
+
+			def initialize_nested_form(name, options)
+				args =
+					if @params.key?(name) then [send("params_for_nested_#{name}")]
+					elsif instance_respond_to?(name) then [instance_public_send(name)]
+					elsif options.key?(:default) then [process_default(options[:default])]
+					else []
+					end
+
+				result =
+					instance_exec options[:form], &options.fetch(:initialize, ->(form) { form.new(*args) })
+				result.runnable = false unless runnable
+				result
+			end
+		end
+
+		private_constant :Filling
+	end
+end

data/lib/formalism/form/outcome.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Formalism
+	## https://github.com/rubocop-hq/rubocop/issues/5831
+	class Form < Action
+		## Private class for results
+		class Outcome
+			attr_reader :errors
+
+			def initialize(errors, result = nil)
+				@errors = errors
+				@result = result
+			end
+
+			def success?
+				@errors.empty?
+			end
+
+			def result
+				raise ValidationError, errors if errors.any?
+
+				@result
+			end
+		end
+
+		private_constant :Outcome
+	end
+end

data/lib/formalism/form/validation_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Formalism
+	class Form < Action
+		## When trying to get `#result` from unsuccessful outcome
+		class ValidationError < StandardError
+			attr_reader :errors
+
+			def initialize(errors)
+				@errors = errors
+				super "Outcome has errors: #{errors.to_a}"
+			end
+		end
+	end
+end

data/lib/formalism/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Formalism
+	VERSION = '0.2.0'
+end

metadata

@@ -0,0 +1,238 @@
+--- !ruby/object:Gem::Specification
+name: formalism
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alexander Popov
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gorilla_patch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: module_methods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: gem_toys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: toys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.91.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.91.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.43'
+description: 'Simple actions and complex forms with validations, nesting, etc.
+
+  '
+email: alex.wayfer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/formalism.rb
+- lib/formalism/action.rb
+- lib/formalism/form.rb
+- lib/formalism/form/coercion.rb
+- lib/formalism/form/coercion/_base.rb
+- lib/formalism/form/coercion/_numeric.rb
+- lib/formalism/form/coercion/array.rb
+- lib/formalism/form/coercion/boolean.rb
+- lib/formalism/form/coercion/date.rb
+- lib/formalism/form/coercion/float.rb
+- lib/formalism/form/coercion/hash.rb
+- lib/formalism/form/coercion/integer.rb
+- lib/formalism/form/coercion/string.rb
+- lib/formalism/form/coercion/symbol.rb
+- lib/formalism/form/coercion/time.rb
+- lib/formalism/form/fields.rb
+- lib/formalism/form/filling.rb
+- lib/formalism/form/outcome.rb
+- lib/formalism/form/validation_error.rb
+- lib/formalism/version.rb
+homepage: https://github.com/AlexWayfer/formalism
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/AlexWayfer/formalism
+  homepage_uri: https://github.com/AlexWayfer/formalism
+  changelog_uri: https://github.com/AlexWayfer/formalism/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: Forms with input data validations and nesting
+test_files: []