better_validations 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 451f27d06fabf944c809fe98c5942634ebb0578c054a70b82dcbcd831cafc25f
+  data.tar.gz: 661475b942ccf70af3ae9660fd812c335b4d1b5ee37bf43b05b761505cd5be1c
+SHA512:
+  metadata.gz: 270e518392f9702d5640b608b1138d4a8899f4f0fa3cf17a1f1dd22c593a869888dbcc1c405b12113e803d509a81a64b61f6749ee62430c55c49c694e1b9ce0c
+  data.tar.gz: 8e198d598f009d01e7ed7b1d33f5e243753b626d94822a4d5d889162d23046a7ad934a381b5347fdee0cdaea0a7d4f865429818e2c08dfef422c31ff9ed38a8b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Petr Bazov
+
+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,15 @@
+# README
+
+## Development
+
+1. Clone project.
+
+2. Copy `.env.example` file to `.env` file.
+
+3. Feel `.env` file by actual values of DATABASE_USER and DATABASE_PASSWORD.
+
+4. Run `rails db:create`.
+
+5. Run `rails s`.
+
+6. Open `http://localhost:3000/` in browser.

data/lib/better_validations.rb

@@ -0,0 +1,85 @@
+require_relative 'better_validations/railtie'
+
+require_relative 'better_validations/errors'
+require_relative 'better_validations/object'
+require_relative 'better_validations/list'
+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
+ActiveRecord::Base.include BetterValidations::Object
+ActiveRecord::Associations::CollectionProxy.include BetterValidations::List
+Array.include BetterValidations::List

data/lib/better_validations/errors.rb

@@ -0,0 +1,59 @@
+module BetterValidations::Errors
+  extend ActiveSupport::Concern
+  included do
+    # Returns the same hash as a 'messages' method
+    # but if an error is happened with a nested object
+    # it will be stored in a nested hash under the key without a dot symbol
+    # instead of an array under the key with dot symbol.
+    #
+    # Example:
+    # object.errors.messages == {
+    #   field_one: ["can't be blank"],
+    #   "nested_object.field_one": ["can't be blank"],
+    #   "nested_object.field_two": ["can't be blank"]
+    # }
+    # object.errors.detailed_messages == {
+    #   field_one: ["can't be blank"],
+    #   nested_object: {
+    #     field_one: ["can't be blank"],
+    #     field_two: ["can't be blank"]
+    #   }
+    # }
+    def detailed_messages(wrap_attributes_to: nil)
+      return @messages if @messages.blank?
+
+      # Split errors to field errors and nested objects errors.
+      # A dot symbol means that the error is happened with a nested object.
+      nested_messages, field_messages = @messages.partition do |field, _|
+        base_field_name = field.to_s.split('.').first.to_sym
+        @base.class.reflect_on_association(base_field_name)
+      end.map(&:to_h)
+
+      if wrap_attributes_to.present? && field_messages.present?
+        field_messages = { wrap_attributes_to => field_messages }
+      end
+
+      detailed_messages = field_messages
+      return detailed_messages if nested_messages.blank?
+
+      # Parse nested messages to structure with nested objects and merge.
+      detailed_messages.merge(
+        parse_nested_messages(nested_messages, wrap_attributes_to)
+      )
+    end
+
+    # Converts nested messages to detailed structure with nested objects
+    def parse_nested_messages(nested_messages, wrap_attributes_to)
+      # Get names of all relations with errors
+      relations = nested_messages.keys
+                                 .map { |field| field.to_s.split('.').first }
+                                 .uniq
+
+      # Collect messages from nested objects
+      relations.map do |relation|
+        object = @base.relation_for_nested_messages(relation)
+        [relation.to_sym, object.detailed_errors_messages(wrap_attributes_to)]
+      end.to_h
+    end
+  end
+end

data/lib/better_validations/list.rb

@@ -0,0 +1,24 @@
+module BetterValidations::List
+  extend ActiveSupport::Concern
+  included do
+    # A helper method to get messages from the active record collection
+    def detailed_errors_messages(wrap_attributes_to)
+      select { |object| object.errors.messages.present? }.map do |object|
+        messages = object.detailed_errors_messages(wrap_attributes_to)
+
+        # Add service information about the object in order
+        # to distinguish objects in collection from each other
+
+        unless object.id.nil?
+          messages = messages.merge(id: object.id)
+        end
+
+        unless object.client_id.nil?
+          messages = messages.merge(client_id: object.client_id)
+        end
+
+        messages
+      end
+    end
+  end
+end

data/lib/better_validations/nested_validator.rb

@@ -0,0 +1,48 @@
+class BetterValidations::NestedValidator < ActiveModel::EachValidator
+  attr_reader :validator_class
+
+  def initialize(options)
+    @validator_class = options.delete(:validator_class)
+    super
+  end
+
+  def validate_each(record, attr_name, value)
+    return if value.nil?
+
+    validator = init_validator(value)
+    cache_validator(record, attr_name, validator)
+    return if validator_valid?(validator)
+
+    record.errors.add(error_key(attr_name), error_text)
+  end
+
+  protected
+
+  def init_validator(value)
+    # A value can be a single object or a list of objects
+    if value.is_a?(Enumerable)
+      value.map { |object| validator_class.new(object) }
+    else
+      validator_class.new(value)
+    end
+  end
+
+  def cache_validator(record, attr_name, validator)
+    record.nested_object_validators[attr_name.to_sym] = validator
+  end
+
+  def validator_valid?(validator)
+    validators = validator.is_a?(Enumerable) ? validator : [validator]
+    validators.map(&:valid?).all?
+  end
+
+  def error_key(attr_name)
+    # Create a key with a dot to tell a framework that an error happened in
+    # a nested object
+    "#{attr_name}.attributes".to_sym
+  end
+
+  def error_text
+    I18n.t('errors.messages.invalid')
+  end
+end

data/lib/better_validations/object.rb

@@ -0,0 +1,28 @@
+module BetterValidations::Object
+  extend ActiveSupport::Concern
+  included do
+
+    # A helper method to get messages without a reference to 'errors'
+    def detailed_errors_messages(wrap_attributes_to)
+      errors.detailed_messages(wrap_attributes_to: wrap_attributes_to)
+    end
+
+    # Define a 'client_id' attribute for ActiveRecord::Base that can
+    # be used to identify objects in the error response.
+    def client_id
+      @client_id
+    end
+
+    # A setter for 'client_id' attribute. Client can pass this attribute
+    # to API and fill it to identify objects in the error response.
+    def client_id=(value)
+      @client_id = value
+    end
+
+    # Returns relation object for providing nested messages.
+    # By default it is the object itself.
+    def relation_for_nested_messages(relation)
+      public_send(relation)
+    end
+  end
+end

data/lib/better_validations/railtie.rb

@@ -0,0 +1,4 @@
+module BetterValidations
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/better_validations/validator.rb

@@ -0,0 +1,114 @@
+module BetterValidations::Validator
+  extend ActiveSupport::Concern
+  included do
+    include ActiveModel::Validations
+    include BetterValidations::Object
+
+    # A system accessors required by BetterValidations::Object
+    attr_accessor :id, :client_id
+
+    # A hash with cached instances of nested validators by field.
+    # Filled by instances of a BetterValidations::NestedValidator class
+    # in the process of validation.
+    attr_accessor :nested_object_validators
+
+    # A validation object as a possible data source
+    attr_reader :validation_object
+
+    # A helper method to validate nested object/list
+    # represented by other validator.
+    #
+    # Example of usage in a User model for validating nested PersonalInfo:
+    # validate_nested :personal_info, PersonalInfoValidator
+    def self.validate_nested(nested_name, validator_class)
+      bind_validator(nested_name, validator_class)
+    end
+
+    # Calls a validates_with method to save information about
+    # the validating object to the validator and run validations.
+    def self.bind_validator(nested_name, validator_class)
+      validates_with BetterValidations::NestedValidator,
+                     attributes: [nested_name],
+                     validator_class: validator_class
+    end
+
+    # Returns a structure of validators such as:
+    # { field: { kind: true }, nested: { field: { kind: true } } }
+    # where "kind" is a validator kind such as "presence".
+    def self.structure
+      validators_by_field_name.reduce({}) do |structure, (field, validator)|
+        validations = (structure[field] || {}).merge(validator_hash(validator))
+        structure.merge(field => validations)
+      end
+    end
+
+    # Returns an array:
+    # [[:field_one, validator], [:field_two, validator]]
+    # fields can duplicate if have multiple validators.
+    def self.validators_by_field_name
+      validators.map do |validator|
+        validator.attributes.map { |attribute| [attribute, validator] }
+      end.flatten(1)
+    end
+
+    # Returns a hash such as:
+    # { kind: true }
+    # where "kind" is a validator kind such as "presence".
+    def self.validator_hash(validator)
+      kind = validator.kind
+      kind == :nested ? validator.validator_class.structure : { kind => true }
+    end
+
+    # Attributes - Hash, ActionController::Parameters or ActiveRecord::Base
+    def initialize(attributes = {})
+      assign_attributes(attributes)
+    end
+
+    def assign_attributes(attributes)
+      prepare_attributes(attributes).each { |key, value| set_value(key, value) }
+    end
+
+    def merge(*validators)
+      BetterValidations::ValidatorsList.new(*([self] + validators))
+    end
+
+    # Override to define a start value and getter by name
+    def nested_object_validators(name = nil)
+      return nested_object_validators[name.to_sym] unless name.nil?
+
+      @nested_object_validators ||= {}
+    end
+
+    # The method is overriden for providing a validator object instead of
+    # an active record to collecting error messages.
+    def relation_for_nested_messages(relation)
+      nested_object_validators(relation.to_sym)
+    end
+
+    protected
+
+    def prepare_attributes(attributes)
+      if attributes.is_a? ActiveRecord::Base
+        @validation_object = attributes
+        attributes = convert_active_record_to_attributes(attributes)
+      end
+
+      attributes
+    end
+
+    def convert_active_record_to_attributes(object)
+      attribute_names.reduce({}) do |hash, name|
+        hash.merge(name => object.public_send(name))
+      end
+    end
+
+    def attribute_names
+      (self.class.validators.map(&:attributes).flatten + [:client_id, :id]).uniq
+    end
+
+    def set_value(key, value)
+      setter = "#{key}=".to_sym
+      public_send(setter, value) if respond_to?(setter)
+    end
+  end
+end

data/lib/better_validations/validators_list.rb

@@ -0,0 +1,84 @@
+# Provides a way to merge multiple validators in order to get
+# merged errors from all of them. Usage:
+#
+#   validator = validator_one.merge(validator_two, validator_three)
+#   validator.valid?
+#   validator.errors.detailed_messages
+#
+class BetterValidations::ValidatorsList
+  def initialize(*validators)
+    @validators = validators
+  end
+
+  def errors
+    self
+  end
+
+  def valid?
+    if @invalid_validators.nil?
+      @invalid_validators = @validators.select(&:invalid?)
+    end
+
+    @invalid_validators.blank?
+  end
+
+  def invalid?
+    !valid?
+  end
+
+  def detailed_messages(wrap_attributes_to: nil)
+    (@invalid_validators || []).reduce({}) do |all_messages, validator|
+      messages = validator.errors.detailed_messages(
+        wrap_attributes_to: wrap_attributes_to
+      )
+
+      deep_merge(all_messages, messages)
+    end
+  end
+
+  def deep_merge(hash_one, hash_two)
+    # Use a standard method to do a deep merge by specify
+    # a values concatination logic
+    hash_one.deep_merge(hash_two) do |_key, this_value, other_value|
+      # Arrays has a complex logic - they must be merged
+      if this_value.is_a?(Array) || other_value.is_a?(Array)
+        merge_arrays(this_value, other_value)
+      else
+        this_value.nil? ? other_value : this_value
+      end
+    end
+  end
+
+  def merge_arrays(one, two)
+    # If we have arrays of strings it means that we have arrays of errors:
+    # ['Error 1', 'Error 2'] and ['Error 3', 'Error 4']. In this case we
+    # just concat arrays and get unique values.
+    if one.first.is_a?(String) || two.first.is_a?(String)
+      return (one + two).uniq
+    end
+
+    # Other type of arrays is an array of hashes. Each hash is
+    # an object with attributes:
+    # [{ id: 1, client_id: 2, key: "String", another_key: {} }]
+    merge_arrays_with_errors(one, two)
+  end
+
+  # Merges arrays of hashes to a single array by deep merging items
+  # with the same ":id" and ":client_id".
+  def merge_arrays_with_errors(one, two)
+    all = one + two
+    all = merge_hashes_by_key(all, :id)
+    merge_hashes_by_key(all, :client_id)
+  end
+
+  def merge_hashes_by_key(hashes, key)
+    hashes_by_id = hashes.group_by { |hash| hash[key] }
+    hashes_by_id.map do |id, hashes_with_id|
+      next hashes_with_id if id.nil?
+
+      # Merge all hashes with the same id to the single hash.
+      # Wrap to array in order to save a format (hashes_with_id is a array)
+      [hashes_with_id.reduce({}) { |result, hash| deep_merge(result, hash) }]
+    end.flatten(1)
+  end
+end

data/lib/better_validations/version.rb

@@ -0,0 +1,3 @@
+module BetterValidations
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: better_validations
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Petr Bazov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
+description: Extension for default Rails validations. Adds some useful methods.
+email:
+- petr@sequenia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/better_validations.rb
+- lib/better_validations/errors.rb
+- lib/better_validations/list.rb
+- lib/better_validations/nested_validator.rb
+- lib/better_validations/object.rb
+- lib/better_validations/railtie.rb
+- lib/better_validations/validator.rb
+- lib/better_validations/validators_list.rb
+- lib/better_validations/version.rb
+homepage: http://sequenia.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Extension for default Rails validations.
+test_files: []