better_validations 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55aaacdd314e854a95aca72c83634ece746a7c31a7d3e58301a5fda92c9b2707
-  data.tar.gz: 70e39fd14316c98bcbfb600cbc7b1e16591104a799009413cff04c6288d16fe8
+  metadata.gz: 91cfccd8caeadd3b09908be75b68575ecdb340635b659308698ab69a44d6e182
+  data.tar.gz: 8a52a8bf9234772fe4f8a300db88052ef0ad41f3646cd7a7dd2b8b196cc7ad7f
 SHA512:
-  metadata.gz: 1ac1927d091c9a93cb365bd7b2cd795194a4146a981f049f4400f086a69d1c34d5c5a8388aee7dee6dde887820a42ca9bbfad21a14617267dfb0201279f4d143
-  data.tar.gz: e2a946a5cbddc28a853ca4666d669cc7adee771ad2ce9adf3e482691b6db7a29f047f5ed407ef27f2a2de1fbbfdb0588c9650ee8037ba246d897f9302f229053
+  metadata.gz: b0320860ee577c911f99d5ed1c7c05cc271a585dfb9cabec70a05fb0981e02a879f709a6802e56c5ba64d116b204cc6457786b4dbd89fe6bcdfdca8a329d0c72
+  data.tar.gz: 7475544cf746a002b080aa021bef5e3975d2a45df99e9d37a1c3b6eb6cf08145d5fd96086efa20c8df93f5cdba521a4f1d3694c025c918dbdd835e332b4fc3da

data/README.md

@@ -1,4 +1,235 @@
-# README
+# Better Validations
+
+[![Gem Version](https://badge.fury.io/rb/better_validations.svg)](https://badge.fury.io/rb/better_validations)
+
+Better Validations is an extension for default Rails validations with useful features.
+
+## Table of contents
+
+- [Installation](#installation)
+- [Features](#features)
+  - [Structured error messages](#structured-error-messages)
+  - [Nested validations](#nested-validations)
+  - [Merge error messages from multiple validators](#merge-error-messages-from-multiple-validators)
+- [Best practices](#best-practices)
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'better_validations'
+```
+
+Run:
+
+```bash
+bundle install
+```
+
+## Features
+
+### Structured error messages
+
+Better Validations provides a way to get error messages from an active record keeping structure of nested objects represented by relations such as `belongs_to`, `has_one`, `has_many` instead of a flat structure. Just call:
+
+```ruby
+active_record.errors.detailed_messages
+```
+
+This calling returns a hash such as:
+
+```ruby
+{
+  attribute_one: ['Error 1', 'Error 2'],
+  attribute_two: ['Error 3'],
+  nested_object: {
+    attribute_three: ['Error 4']
+  },
+  nested_objects: [
+    {
+      attribute_four: ['Error 5']
+    }
+  ]
+}
+```
+
+Instead of default `active_record.errors.messages`:
+
+```ruby
+{
+  attribute_one: ['Error 1', 'Error 2'],
+  attribute_two: ['Error 3'],
+  'nested_object.attribute_three': ['Error 4'],
+  'nested_objects.attribute_four': ['Error 5']
+}
+```
+
+You can wrap attributes in some key by passing optional `wrap_attributes_to` argument in all levels of nesting:
+
+```ruby
+active_record.errors.detailed_messages(
+  wrap_attributes_to: :fields
+)
+
+{
+  fields: {
+    attribute_one: ['Error 1', 'Error 2'],
+    attribute_two: ['Error 3']
+  },
+  nested_object: {
+    fields: {
+      attribute_three: ['Error 4']
+    }
+  },
+  nested_objects: [
+    {
+      fields: {
+        attribute_four: ['Error 5']
+      }
+    }
+  ]
+}
+```
+
+This is useful if you have validations both on the relation and in the nested object of this relation:
+
+```ruby
+# Try to create an object with a nested list where must be at least 2 elements
+object = SomeModel.create(nested_objects_attributes: [{ attribute_one: nil }])
+object.errors.detailed_messages(wrap_attributes_to: :fields)
+
+{
+  fields: {
+    nested_objects: ['too few nested objects. Must be at least 2']
+  },
+  nested_objects: [
+    {
+      fields: {
+        attribute_one: "can't be blank"
+      }
+    }
+  ]
+}
+```
+
+**Note!** The order of objects in a nested list returned by `detailed_messages` can be different from the order in a passed nested attributes. You can match objects by identifiers or pass a `client_id` attribute for objects that have not yet been created:
+
+```ruby
+object.update(nested_objects_attributes: [
+  {
+    id: 1,
+    client_id: 'identifier_one'
+    attribute_one: nil,
+    attribute_two: 'filled'
+  },
+  {
+    client_id: 'identifier_two',
+    attribute_one: 'filled',
+    attribute_two: nil
+  }
+])
+
+object.errors.detailed_messages
+
+{
+  nested_objects: [
+    {
+      {
+        id: 1,
+        client_id: 'identifier_one'
+        attribute_one: ["can't be blank"]
+      },
+      {
+        client_id: 'identifier_two',
+        attribute_two: ["can't be blank"]
+      }
+    }
+  ]
+}
+```
+
+### Nested validations
+
+Better Validation provides the ability to validate nested objects in separated validators with included `ActiveModel::Validations`.
+
+Just include `BetterValidations::Validator` instead of `ActiveModel::Validations` and you will can to validate nested objects with the other validator by calling a `validate_nested` method:
+
+```ruby
+class SomeModelValidator
+  include BetterValidations::Validator
+  attr_accessor :nested_object
+  validate_nested :nested_object, NestedObjectValidator
+end
+
+class NestedObjectValidator
+  include BetterValidations::Validator
+  attr_accessor :attribute_one
+  validates_presence_of :attribute_one
+end
+
+validator = SomeModelValidator.new(nested_object: { attribute_one: nil })
+validator.valid? # false
+validator.errors.detailed_messages
+
+{ nested_object: { attribute_one: ["can't be blank"] } }
+```
+
+You also can validate active record object or `ActionController::Parameters` with nested objects by passing them to the validator:
+
+```ruby
+object = SomeModel.new(nested_object: NestedObject.new(attribute_one: nil))
+# OR
+object = ActionController::Parameters.new(nested_object: { attribute_one: nil })
+
+validator = SomeModelValidator.new(object)
+```
+
+### Merge error messages from multiple validators
+
+Better Validations provides the ability to merge validators in order to get merged detailed errors.
+
+Useful when you needs to get errors from multiple validators or if a part of validations implemented inside a model. Usage:
+
+```ruby
+validator = validator_one.merge(validator_two, object, ...)
+validator.valid?
+validator.errors.detailed_messages
+```
+
+## Best practices
+
+### Base class for all validators
+
+Create a base `ApplicationValidator` class for all validators in the project. By analogy with `ApplicationRecord` and `ApplicationController`:
+
+```ruby
+class ApplicationValidator
+  include BetterValidations::Validator
+end
+
+class SomeModelValidator < ApplicationValidator
+end
+```
+
+This will allow you to easily add common functionality to the validators. For example, add automatic  parsing of keys with `_attributes` suffix to validator properties in order to support format of `accepts_nested_attributes_for` parameters:
+
+```ruby
+class ApplicationValidator
+  include BetterValidations::Validator
+
+  def self.validate_nested(nested_name, validator_class)
+    define_attributes_accessor(nested_name)
+    bind_validator(nested_name, validator_class)
+  end
+
+  def self.define_attributes_accessor(nested_name)
+    setter_name = "#{nested_name}_attributes="
+    define_method(setter_name) { |value| set_value(nested_name, value) }
+  end
+end
+
+```
 
 ## Development
 
@@ -8,8 +239,8 @@
 
 3. Feel `.env` file by actual values of DATABASE_USER and DATABASE_PASSWORD.
 
-4. Run `rails db:create`.
+4. Run `rails db:create` to create a database.
 
-5. Run `rails s`.
+5. Run `rails db:migrate` to run migrations for test models.
 
-6. Open `http://localhost:3000/` in browser.
+6. Run `rspec` to check tests.

data/lib/better_validations.rb

@@ -7,76 +7,7 @@ require_relative 'better_validations/nested_validator'
 require_relative 'better_validations/validator'
 require_relative 'better_validations/validators_list'
 
-# 1. A module provides a way to get error messages from an active record
-# keeping structure of nested objects represented by relations
-# such as belongs_to, has_one, has_many instead of a flat structure. Just call:
-#
-#   active_record.errors.detailed_messages
-#
-# This calling returns a hash such as:
-#
-#   { field_one: ['Error 1', 'Error 2'],
-#     field_two: ['Error'],
-#     nested_object: { field: ['Error'] },
-#     nested_list: [{ field: ['Error'] }] }
-#
-# A "detailed_messages" method has a "wrap_attributes_to" parameter.
-# You can use it to wrap all attributes except relations by passed key:
-#
-#  active_record.errors.detailed_messages(wrap_attributes_to: :fields)
-#  { fields: { field_one: ['Error'], field_two: ['Error'] },
-#    nested_object: { fields: { field: ['Error'] } } }
-#
-# This module also provides other features.
-#
-# 2. Ability to validate nested objects in separated validators with
-# included ActiveModel::Validations.
-#
-# Just include BetterValidations::Validator instead of ActiveModel::Validations
-# and you will can to validate nested objects with the other validator by
-# calling a "validate_nested" method:
-#
-#   class UserValidator
-#     include BetterValidations::Validator
-#
-#     attr_accessor :email, :password, :personal_info
-#
-#     validates_presence_of :email, :password
-#     validate_nested :personal_info, PersonalInfoValidator
-#   end
-#
-#   class PersonalInfoValidator
-#     include BetterValidations::Validator
-#
-#     attr_accessor :first_name, :last_name
-#     validates_presence_of :first_name, :last_name
-#   end
-#
-# After that you can validate active record object, hash or
-# ActionController::Parameters by passing them to the validator.
-# Keys "#{field}" and "#{field}_attributes" are synonyms and fills
-# a "#{field}=" attr_accessor:
-#
-#   user = User.new(email: '', personal_info_attributes: { first_name: '' })
-#   user = User.new(personal_info: PersonalInfo.new(last_name: ''))
-#   user = { email: '', personal_info_attributes: { last_name: '' } }
-#   user = { email: '', personal_info: { last_name: '' } }
-#   user = ActionController::Parameters.new(email: '')
-#
-#   validator = UserValidator.new(user)
-#   validator.valid?
-#   validator.errors.detailed_messages
-#
-# 3. Ability to merge validators in order to get merged detailed errors.
-# Useful when you needs to get errors from multiple validators
-# or if a part of validations implemented inside a model. Usage:
-#
-#   validator = validator_one.merge(validator_two, validator_three, object)
-#   validator.valid?
-#   validator.errors.detailed_messages
-#
 module BetterValidations
-  # Your code goes here...
 end
 
 ActiveModel::Errors.include BetterValidations::Errors

data/lib/better_validations/errors.rb

@@ -40,17 +40,7 @@ module BetterValidations::Errors
     end
 
     def split_messages(messages)
-      messages.partition do |field, _|
-        base_field_name = field.to_s.split('.').first.to_sym
-
-        if @base.class.respond_to?(:reflect_on_association)
-          @base.class.reflect_on_association(base_field_name)
-        else
-          @base.class._validators[base_field_name]&.any? do |validator|
-            validator.is_a? BetterValidations::NestedValidator
-          end
-        end
-      end.map(&:to_h)
+      messages.partition { |field, _| field.to_s.include?('.') }.map(&:to_h)
     end
 
     # Converts nested messages to detailed structure with nested objects

data/lib/better_validations/version.rb

@@ -1,3 +1,3 @@
 module BetterValidations
-  VERSION = '0.1.2'.freeze
+  VERSION = '0.1.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: better_validations
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Petr Bazov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-14 00:00:00.000000000 Z
+date: 2020-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails