error_normalizer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a2b14320f32c8b5b9709d2a7963941ff27cebe857533a3a38401e4ccb08709a
+  data.tar.gz: 5d9f38f16ea5aac77e3a0318eb4cacac7b9aab5d24574e8d55c5c3de4b3cb08f
+SHA512:
+  metadata.gz: ea13a01344de75bd4161ff70a70f268aaa2d6b393273f14e000da2b8213ca61eae426d12e97acdbe06eaf9f2dbbe4fa3d4427214e47ad46558de8422105dd058
+  data.tar.gz: 58fd33623c68e76af2bf94fbd7ec1cd8dea6a17baae99315bfddc687862c00e6f9dbdf38d3ebd6f83f69cb06b6c5232986548bac98c9e4ddb15baf4e4e118136

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,90 @@
+# Common configuration.
+AllCops:
+  TargetRubyVersion: 2.5
+  TargetRailsVersion: 5.1
+
+#################### Style ###########################
+
+Style/Documentation:
+  Enabled: true
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/EmptyMethod:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/ModuleFunction:
+  Enabled: false
+
+#################### Naming ##########################
+
+Naming/AccessorMethodName:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+#################### Metrics #########################
+
+Metrics/AbcSize:
+  Max: 15
+
+Metrics/BlockLength:
+  CountComments: false
+  Max: 25
+  Exclude:
+    - 'error_normalizer.gemspec'
+    - 'spec/**/*_spec.rb'
+
+Metrics/BlockNesting:
+  CountBlocks: false
+  Max: 3
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 100
+
+# Avoid complex methods.
+Metrics/CyclomaticComplexity:
+  Max: 6
+
+Metrics/LineLength:
+  Max: 100
+  # To make it possible to copy or click on URIs in the code, we allow lines
+  # containing a URI to be longer than Max.
+  AllowHeredoc: true
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+  # The IgnoreCopDirectives option causes the LineLength rule to ignore cop
+  # directives like '# rubocop: enable ...' when calculating a line's length.
+  IgnoreCopDirectives: true
+  # The IgnoredPatterns option is a list of !ruby/regexp and/or string
+  # elements. Strings will be converted to Regexp objects. A line that matches
+  # any regular expression listed in this option will be ignored by LineLength.
+  IgnoredPatterns: []
+
+Metrics/MethodLength:
+  CountComments: false
+  Max: 12
+
+Metrics/ModuleLength:
+  CountComments: false
+  Max: 200
+
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+
+Metrics/PerceivedComplexity:
+  Max: 7
+
+##################### Layout ##########################
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in error_normalizer.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,83 @@
+PATH
+  remote: .
+  specs:
+    error_normalizer (0.1.0)
+      dry-configurable (~> 0.7.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.0)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    dry-configurable (0.7.0)
+      concurrent-ruby (~> 1.0)
+    dry-container (0.6.0)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+    dry-core (0.4.7)
+      concurrent-ruby (~> 1.0)
+    dry-equalizer (0.2.1)
+    dry-inflector (0.1.2)
+    dry-logic (0.4.2)
+      dry-container (~> 0.2, >= 0.2.6)
+      dry-core (~> 0.2)
+      dry-equalizer (~> 0.2)
+    dry-types (0.13.2)
+      concurrent-ruby (~> 1.0)
+      dry-container (~> 0.3)
+      dry-core (~> 0.4, >= 0.4.4)
+      dry-equalizer (~> 0.2)
+      dry-inflector (~> 0.1, >= 0.1.2)
+      dry-logic (~> 0.4, >= 0.4.2)
+    dry-validation (0.12.2)
+      concurrent-ruby (~> 1.0)
+      dry-configurable (~> 0.1, >= 0.1.3)
+      dry-core (~> 0.2, >= 0.2.1)
+      dry-equalizer (~> 0.2)
+      dry-logic (~> 0.4, >= 0.4.0)
+      dry-types (~> 0.13.1)
+    jaro_winkler (1.5.1)
+    parallel (1.12.1)
+    parser (2.5.1.2)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    rainbow (3.0.0)
+    rake (10.4.2)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    rubocop (0.59.2)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.10.0)
+    unicode-display_width (1.4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  dry-validation (~> 0.12.2)
+  error_normalizer!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  rubocop (= 0.59.2)
+
+BUNDLED WITH
+   1.16.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 dikond
+
+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,187 @@
+# Hola :call_me_hand:
+
+This gem was born out of need to have a establish a single universal error format to be consumed by frontend (JS), Android and iOS clients.
+
+## API error format
+
+In our projects we have a convention, that in case of a failed request (422) backend shall return a JSON response which conforms to the following schema:
+
+    {
+      errors: [{
+        key: 'has_already_been_taken',
+        type: 'params',
+        message: 'has already been taken',
+        payload: {
+          path: 'user.email'
+        }
+      }]
+    }
+
+Each error object **must have** 4 required fields: `key`, `type`, `message` and `payload`.
+
+- `key` is a concise error code that will be used in a user-friendly translations
+- `type` may be `params`, `custom` or something else
+  - `params` means that some parameter that the backend received was wrong
+  - `custom` covers everything else from the business validation composed from several parameters to something really special
+- `message` is a "default" or "fallback" error message in plain English that may be used if client does not have translation for the error code
+- `payload` contains other useful data that assists client error handling. For example, in case of `type: "params"` we can provide a _path_ to the invalid paramter.
+
+## Usage
+
+### dry-validation
+
+GIVEN following [dry-validation](https://dry-rb.org/gems/dry-validation/) schema
+
+    schema = Dry::Validation.Schema do
+      required(:name).filled(size?: 3..15)
+      required(:email).filled(format?: /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i)
+      optional(:credit_card).filled(:bool?)
+      optional(:cash).filled(:bool?)
+
+      rule(payment: [:credit_card, :cash]) do |card, cash|
+        card.eql?(true) ^ cash.eql?(true)
+      end
+    end
+
+AND following input
+
+    errors = schema.call(name: 'DK', email: 'dk<@>dark.net').errors
+    # {:name=>["length must be within 3 - 15"], :credit_card=>["must be filled"]}
+
+THEN we can convert given errors to API error format
+
+    ErrorNormalizer.normalize(errors)
+    # [{
+    #   :key=>"length_must_be_within",
+    #   :message=>"length must be within 3 - 15",
+    #   :payload=>{:path=>"name", :range=>["3", "15"]},
+    #   :type=>"params"
+    # }, {
+    #   :key=>"is_in_invalid_format",
+    #   :message=>"is in invalid format",
+    #   :payload=>{:path=>"email"},
+    #   :type=>"params"
+    # }, {
+    #   :key=>"must_be_equal_to",
+    #   :message=>"must be equal to true",
+    #   :payload=>{:path=>"payment", :value=>"true"},
+    #   :type=>"params"
+    # }]
+
+For more information about supported errors and how they would be parsed please check the spec.
+
+#### Type-inference feature
+
+**TL;DR:** Add `_rule` to the [custom validation block](https://dry-rb.org/gems/dry-validation/custom-validation-blocks/) names (adding this to the [high-level rules](https://dry-rb.org/gems/dry-validation/high-level-rules/) won't harm either, praise the consistency!).
+
+**Long version**: When you're using [custom validation blocks](https://dry-rb.org/gems/dry-validation/custom-validation-blocks/) the error output is slightly diffenet. Instead of attribute name it will have a rule name as a key. For example, GIVEN this schema
+
+    schema = Dry::Validation.Schema do
+      configure do
+        def self.messages
+          super.merge(en: { errors: { email_required: 'provide email' } })
+        end
+      end
+
+      required(:email).maybe(:str?)
+      required(:newsletter).value(:bool?)
+
+      validate(email_required: %i[newsletter email]) do |newsletter, email|
+        if newsletter == true
+          !email.nil?
+        else
+          true
+        end
+      end
+    end
+
+AND the following input
+
+    errors = schema.call(newsletter: true, email: nil).errors
+    # { email_required: ['provide email'] }
+
+THEN we will get following format after normalization
+
+    ErrorNormalizer.normalie(errors)
+    # [{
+    #   key: 'provide_email',
+    #   message: 'provide email',
+    #   payload: { path: 'email_required' }, # should be empty to not confuse ppl
+    #   type: 'params' # should be "rule" or "custom" but definately not "params"
+    # }]
+
+The solution to this problem would be to use _type inference from the rule name_ feature. Just add a `_rule` to the name of a custom block validation, like this
+
+    validate(email_required_rule: %i[newsletter email]) do |newsletter, email|
+      false
+    end
+
+Now validation will produce errors like this
+
+    { email_required_rule: ['provide email'] }
+
+But we can easily spot keys which end with `_rule` and normalize such erros appropiately to the following format
+
+    ErrorNormalizer.normalize(email_required_rule: ['provide email'])
+    # [{
+    #   key: 'provide_email',
+    #   message: 'provide email',
+    #   payload: {},
+    #   type: 'rule'
+    # }]
+
+You can customize rule name match pattern, type name or turn off this feature completely by specifying it in configuration block
+
+    ErrorNormalizer.configure do |config|
+      config.infer_type_from_rule_name = true
+      config.rule_matcher = /_rule\z/
+      config.type_name = 'rule'
+    end
+
+### ActiveModel::Validations
+
+ActiveModel errors aren't fully supported. By that I mean errors will be converted to the single format, however you won't see really unique error `key` or `payload` with additional info.
+
+GIVEN we have a model like this
+
+    class TestUser
+      include ActiveModel::Validations
+
+      attr_reader :name, :email
+      def initialize(name:, email:)
+        @name = name
+        @email = email
+      end
+
+      validates :name, presence: true, length: { in: 3..15 }
+      validates :email, presence: true, format: { with: /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i }
+    end
+
+AND initialzied object with invalid data
+
+    user = TestUser.new(name: 'DK', email: 'dk<@>dark.net').tap(&:validate)
+
+THEN we can normalize object errors to API error format
+
+    ErrorNormalizer.normalize(user.errors.to_hash)
+    # [{
+    #   :key=>"is_too_short_minimum_is_3_characters",
+    #   :message=>"is too short (minimum is 3 characters)",
+    #   :payload=>{:path=>"name"},
+    #   :type=>"params"
+    # }, {
+    #   :key=>"is_invalid",
+    #   :message=>"is invalid",
+    #   :payload=>{:path=>"email"},
+    #   :type=>"params"
+    # }]
+
+## TODO
+
+- plugin to make full error translation
+- configure Gitlab CI
+- parse ActiveModel error mesasges
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/error_normalizer.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/error_normalizer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'error_normalizer'
+  spec.version       = ErrorNormalizer::VERSION
+  spec.authors       = ['Denis Kondratenko']
+  spec.email         = ['di.kondratenko@gmail.com']
+
+  spec.summary       = 'Normalize dry-validation and ActiveModel errors to the universal format'
+  spec.homepage      = 'https://gitlab.yalantis.com/web/error_normalizer'
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'dry-configurable', '~> 0.7.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'dry-validation', '~> 0.12.2'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop', '0.59.2'
+end

data/lib/error_normalizer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'dry-configurable'
+require 'error_normalizer/version'
+require 'error_normalizer/normalizer'
+
+#
+# Intended to normalize errors to the single format:
+#
+#     {
+#       key: 'has_already_been_taken',
+#       type: 'params',
+#       message: 'has already been taken',
+#       payload: {
+#         path: 'user.email'
+#       }
+#     }
+#
+# We shall be able to automatically convert dry-validation output to this format
+# and since we're using rails also automatically convert ActiveModel::Errors.
+#
+class ErrorNormalizer
+  extend Dry::Configurable
+
+  setting :infer_type_from_rule_name, true
+  setting :rule_matcher, /_rule\z/
+  setting :type_name, 'rule'
+
+  #
+  # Normalize errors to flat array of structured errors.
+  #
+  # @param input [Hash]
+  # @param opts [Hash] for list of supported options check ErrorNormalizer::Normalizer#new
+  # @return [Array<Hash>]
+  #
+  def self.normalize(input, **opts)
+    defaults = config.to_hash
+    Normalizer.new(input, defaults.merge(opts)).normalize.to_a
+  end
+end

data/lib/error_normalizer/error.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class ErrorNormalizer
+  # Error struct which makes cosmetic normalization
+  # upon calling either #to_hash and #to_json.
+  # Supports case equality check (#===) for hash structs.
+  #
+  # @example
+  #   Error.new('not_plausible', message: "can't recognize your phone", path: 'user.phone')
+  #   Error.new('not_authorized').to_hash
+  #   #=> { key: 'not_authorized', message: 'not authorized', type: 'params', payload: {} }
+  #
+  #   # case equality works with hashes
+  #   err = { key: 'err', message: 'err', type: 'custom', payload: {} }
+  #   message =
+  #     case err
+  #     when Error
+  #       'YEP'
+  #     else
+  #       'NOPE'
+  #     end
+  #   puts message #=> 'YEP'
+  #
+  class Error
+    def initialize(error_key, message: nil, type: 'params', **payload)
+      @key = error_key
+      @message = message
+      @type = type
+      @payload = payload
+    end
+
+    def self.===(other)
+      return true if other.is_a?(Error)
+      return false unless other.is_a?(Hash)
+
+      h = other.transform_keys(&:to_s)
+      h.key?('key') & h.key?('message') && h.key?('payload') && h.key?('type')
+    end
+
+    def to_hash
+      {
+        key: @key,
+        message: message,
+        payload: payload,
+        type: @type
+      }
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    private
+
+    def message
+      @message || @key.tr('_', ' ')
+    end
+
+    def payload
+      @payload.delete_if { |_k, v| v.nil? || v.empty? }
+    end
+  end
+end

data/lib/error_normalizer/message_parser.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class ErrorNormalizer
+  #
+  # Parse error messages and extract payload metadata.
+  #
+  # ActiveModel ignored for now because we don't plan to use its validations.
+  # In case message isn't recognized we set error to be a simple
+  # normalized message (no spaces and special characters).
+  #
+  # Here are the links to AM::Errors and Dry::Validation list of error messages:
+  #   - Dry: https://github.com/dry-rb/dry-validation/blob/8417e8/config/errors.yml
+  #   - AM: https://github.com/svenfuchs/rails-i18n/blob/70b38b/rails/locale/en-US.yml#L111
+  #
+  class MessageParser
+    VALUE_MATCHERS = [
+      /\A(?<err>must not include) (?<val>.+)/,
+      /\A(?<err>must be equal to) (?<val>.+)/,
+      /\A(?<err>must not be equal to) (?<val>.+)/,
+      /\A(?<err>must be greater than) (?<val>\d+)/,
+      /\A(?<err>must be greater than or equal to) (?<val>\d+)/,
+      /\A(?<err>must include) (?<val>.+)/,
+      /\A(?<err>must be less than) (?<val>\d+)/,
+      /\A(?<err>must be less than or equal to) (?<val>\d+)/,
+      /\A(?<err>size cannot be greater than) (?<val>\d+)/,
+      /\A(?<err>size cannot be less than) (?<val>\d+)/,
+      /\A(?<err>size must be) (?<val>\d+)/,
+      /\A(?<err>length must be) (?<val>\d+)/
+    ].freeze
+
+    LIST_MATCHERS = [
+      /\A(?<err>must not be one of): (?<val>.+)/,
+      /\A(?<err>must be one of): (?<val>.+)/,
+      /\A(?<err>size must be within) (?<val>.+)/,
+      /\A(?<err>length must be within) (?<val>.+)/
+    ].freeze
+
+    def initialize(message)
+      @message = message
+      @key = nil
+      @payload = {}
+    end
+
+    def parse
+      parse_value_message
+      return to_a if @key
+
+      parse_list_message
+      return to_a if @key
+
+      @key = to_key(@message)
+      to_a
+    end
+
+    def to_a
+      [@key, @message, @payload]
+    end
+
+    private
+
+    def parse_value_message
+      VALUE_MATCHERS.each do |matcher|
+        data = matcher.match(@message)
+        next if data.nil?
+
+        @key = to_key(data[:err])
+        @payload[:value] = data[:val]
+
+        break
+      end
+    end
+
+    def parse_list_message
+      LIST_MATCHERS.each do |matcher|
+        data = matcher.match(@message)
+        next if data.nil?
+
+        @key = to_key(data[:err])
+        @payload.merge!(parse_list_payload(data[:val]))
+
+        break
+      end
+    end
+
+    def to_key(msg)
+      msg.downcase.tr(' ', '_').gsub(/[^a-z0-9_]/, '')
+    end
+
+    def parse_list_payload(str)
+      if str.include?(' - ')
+        { range: str.split(' - ') }
+      else
+        { list: str.split(', ') }
+      end
+    end
+  end
+end

data/lib/error_normalizer/normalizer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+require_relative 'message_parser'
+
+class ErrorNormalizer
+  #
+  # Responsible for converting input to the array of normalized errors.
+  #
+  # @example
+  #   errors = { phone: ['not plausible'] }
+  #   ErrorNormalizer::Normalizer.new(errors, namespace: 'customer').normalize
+  #   # [{
+  #   #   key: 'not_plausible',
+  #   #   message: 'not plausible',
+  #   #   payload: { path: 'customer.phone' },
+  #   #   type: 'params'
+  #   # }]
+  #
+  class Normalizer
+    UnsupportedInputType = Class.new(StandardError)
+
+    attr_reader :errors
+
+    def initialize(input, namespace: nil, **config)
+      @input = input
+      @namespace = namespace
+      @errors = []
+      @config = config
+    end
+
+    def add_error(error, path: nil, **options)
+      @errors <<
+        case error
+        when Error
+          error
+        when Symbol, String
+          parse_error(error, path, options)
+        end
+    end
+
+    def normalize
+      case @input
+      when Hash
+        normalize_hash(@input.dup)
+      when ActiveModel::Errors
+        normalize_hash(@input.to_hash)
+      else
+        raise "Don't know how to normalize errors"
+      end
+
+      self
+    end
+
+    def to_a
+      @errors.map(&:to_hash)
+    end
+
+    private
+
+    def normalize_hash(input) # rubocop:disable AbcSize
+      return add_error(input) if input.is_a?(Error)
+
+      input.each do |key, value|
+        if messages_ary?(value)
+          options = prepare_error_options(key)
+          value.each { |msg| add_error(msg, options) }
+        elsif value.is_a?(Hash)
+          ns = namespaced_path(key)
+          Normalizer.new(value, namespace: ns).normalize.errors.each { |e| add_error(e) }
+        else
+          raise UnsupportedInputType
+        end
+      end
+    end
+
+    def messages_ary?(ary)
+      return false unless ary.is_a? Array
+
+      ary.all? { |v| v.is_a? String }
+    end
+
+    def parse_error(err_message, path, options)
+      result = MessageParser.new(err_message).parse
+      key, msg, payload = result.to_a
+
+      Error.new(key, message: msg, path: namespaced_path(path), **payload, **options)
+    end
+
+    def namespaced_path(path)
+      return if path.nil?
+      return path.to_s if @namespace.nil?
+
+      [@namespace, path].compact.join('.')
+    end
+
+    def prepare_error_options(key)
+      type = 'params'
+      payload = {}
+
+      if @config[:infer_type_from_rule_name] && @config[:rule_matcher].match?(key)
+        type = @config[:type_name]
+      else
+        payload = { path: key }
+      end
+
+      payload.merge!(type: type)
+    end
+  end
+end

data/lib/error_normalizer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ErrorNormalizer
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: error_normalizer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denis Kondratenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-configurable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.59.2
+description: 
+email:
+- di.kondratenko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- error_normalizer.gemspec
+- lib/error_normalizer.rb
+- lib/error_normalizer/error.rb
+- lib/error_normalizer/message_parser.rb
+- lib/error_normalizer/normalizer.rb
+- lib/error_normalizer/version.rb
+homepage: https://gitlab.yalantis.com/web/error_normalizer
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Normalize dry-validation and ActiveModel errors to the universal format
+test_files: []