error_normalizer 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4035feeceb8c759e702989ff2d013b40a935fcf4b4ca2afe79b9742738ff39a6
-  data.tar.gz: f7235ca637c3503f126ff091724d80d672462b08b6b7ade550bba1ad4ab801ef
+  metadata.gz: 6f05b5d39eabbca2f54ec830fff3ba92e575d7d1cd18fb8245a22958213e8d26
+  data.tar.gz: fea06df20e65dea4222593aa9f13c3c6a2254f4d39a5f5764362f96f84243e16
 SHA512:
-  metadata.gz: 252e4a3d03e3c1a1f190c77774fa0ca2ac23adb6ca5bd02afc93a9e7cc4fbe819c63fee1c98c6fee7d9d0a4a485032773a2b56f935b16b8c7d958a17bb9cc7da
-  data.tar.gz: e50077ea3edd89c7c091aa92138f54fd49bc41ac1f0670fbed866c829e63f7094be1b646613f058ff6ea1775713564af7fec106f0c84b85f4a2083dac6dd0e4e
+  metadata.gz: d59e524a3e46879e56b675b94b10434336b1433e3db00298a5b42a011fbe32d6ec3e8f7f1315785ed502732436e5057060afeecc83753864d380416c97ef79e6
+  data.tar.gz: 47e566c3b25befa7d1b22e5f5fde257466b69d6e5f657c5f227dc661fe487a938a801008a83802b372fb945618f1e54ed0060a3fe985e6d8087fa5b0c6c9c5cd

data/.rubocop.yml

@@ -20,6 +20,9 @@ Style/FrozenStringLiteralComment:
 Style/ModuleFunction:
   Enabled: false
 
+Style/LambdaCall:
+  Enabled: false
+
 #################### Naming ##########################
 
 Naming/AccessorMethodName:

data/Gemfile.lock

@@ -8,6 +8,8 @@ GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
     concurrent-ruby (1.0.5)
     diff-lcs (1.3)
     dry-configurable (0.7.0)
@@ -37,11 +39,20 @@ GEM
       dry-equalizer (~> 0.2)
       dry-logic (~> 0.4, >= 0.4.0)
       dry-types (~> 0.13.1)
+    i18n (1.1.1)
+      concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.1)
+    method_source (0.9.1)
     parallel (1.12.1)
     parser (2.5.1.2)
       ast (~> 2.4.0)
     powerpack (0.1.2)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
     rainbow (3.0.0)
     rake (10.4.2)
     rspec (3.8.0)
@@ -75,9 +86,11 @@ DEPENDENCIES
   bundler (~> 1.16)
   dry-validation (~> 0.12.2)
   error_normalizer!
+  i18n (~> 1)
+  pry-byebug (~> 3.6)
   rake (~> 10.0)
   rspec (~> 3.0)
   rubocop (= 0.59.2)
 
 BUNDLED WITH
-   1.16.6
+   1.17.1

data/README.md

@@ -28,6 +28,8 @@ Each error object **must have** 4 required fields: `key`, `type`, `message` and
 
 ## Usage
 
+[DOCUMENTATION](https://www.rubydoc.info/gems/error_normalizer/)
+
 ### dry-validation
 
 GIVEN following [dry-validation](https://dry-rb.org/gems/dry-validation/) schema
@@ -138,6 +140,70 @@ You can customize rule name match pattern, type name or turn off this feature co
       config.type_name = 'rule'
     end
 
+#### I18n support
+
+##### Full message translation
+
+This feature enables to define localization for schema attributes (think of `path` that you get in `payload`), translate it with I18n and concatenate it with the error messages.
+
+    schema = Dry::Validation.Schema do
+      required(:user).schema do
+        required(:favorite_pet).filled(size?: 3..8)
+        required(:vessel).schema do
+          required(:factory).filled(excluded_from?: ['Bilgewater', 'Shipwreck'])
+        end
+      end
+    end
+
+AND following input
+
+    errors = schema.(user: { favorite_pet: 'Zuckerberg', vessel: { factory: 'Bilgewater' } }).errors
+    #=> {:user=>{:favorite_pet=>["length must be within 3 - 8"], :company=>{:name=>["must not be one of: Bilgewater, Shipwreck"]}}}
+
+AND following translations loaded in `I18n`
+
+    en:
+      schemas:
+        user:
+          '@': cap
+          favorite_pet: parrot
+          vessel:
+            '@': ship
+            factory: dockyard
+
+THEN we can convert it to fully translated errors
+
+    ErrorNormalizer.normalize(errors, i18n_messages: true)
+    # [{
+    #   :key=>"length_must_be_within",
+    #   :message=>"Cap parrot length must be within 3 - 8",
+    #   :payload=>{:path=>"user.favorite_pet", :range=>["3", "15"]},
+    #   :type=>"params"
+    # }, {
+    #   :key=>"must_not_be_one_of",
+    #   :message=>"Cap ship dockyard must not be one of: Bilgewater, Shipwreck",
+    #   :payload=>{:path=>"user.vessel.factory", :list=>["Bilgewater", "Shipwreck"]},
+    #   :type=>"params"
+    # }]
+
+You can configure this behaviour globally:
+
+    ErrorNormalizer.configure do |config|
+      config.i18n_messages = true
+    end
+
+For the i18n lookup rules go check [SchemaPathTranslator documentation](https://www.rubydoc.info/gems/error_normalizer/ErrorNormalizer/SchemaPathTranslator).
+
+##### Non-english error messages
+
+If you want to support error messages for the other languages you'll need to define and register localized message parser. You can register it in configuration block:
+
+    ErrorNormalizer.configure do |config|
+      config.message_parsers << RussianMessageParser
+    end
+
+For message parser implementation please check the [documentation](https://www.rubydoc.info/gems/error_normalizer/ErrorNormalizer/MessageParser) and the source code of `ErrorNormalizer::MessageParser::English`.
+
 ### 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.
@@ -178,9 +244,9 @@ THEN we can normalize object errors to API error format
 
 ## TODO
 
-- plugin to make full error translation
 - configure Gitlab CI
 - parse ActiveModel error mesasges
+- support array of errors as an input
 
 ## License
 

data/error_normalizer.gemspec

@@ -20,9 +20,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'dry-configurable', '~> 0.7.0'
+  spec.add_development_dependency 'i18n', '~> 1'
 
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'dry-validation', '~> 0.12.2'
+  spec.add_development_dependency 'pry-byebug', '~> 3.6'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop', '0.59.2'

data/lib/error_normalizer/error.rb

@@ -2,9 +2,14 @@
 
 class ErrorNormalizer
   #
-  # Error struct which makes cosmetic normalization
-  # upon calling either {Error#to_hash} or {Error#to_json}.
-  # Provides case equality check {Error.===} to support plain Hash structs.
+  # Struct which makes cosmetic normalization on calling
+  # either {Error#to_hash} or {Error#to_json}.
+  #
+  # Translates message with path via i18n if
+  # corresponding options is passed (see {Error#initialize}).
+  #
+  # Provides case equality check ({Error.===})
+  # to support plain Hash structs.
   #
   # @example
   #   Error.new('not_plausible', message: "can't recognize your phone", path: 'user.phone')
@@ -23,10 +28,11 @@ class ErrorNormalizer
   #   puts message #=> 'YEP'
   #
   class Error
-    def initialize(error_key, message: nil, type: 'params', **payload)
+    def initialize(error_key, message: nil, type: 'params', i18n_messages: nil, **payload)
       @key = error_key
       @message = message
       @type = type
+      @i18n_messages = i18n_messages
       @payload = payload
     end
 
@@ -40,11 +46,23 @@ class ErrorNormalizer
       h.key?('key') && h.key?('message') && h.key?('payload') && h.key?('type')
     end
 
+    # Translate message with path via i18n.
+    # Delegates path translation to {SchemaPathTranslator}.
+    # @return [String]
+    def full_message
+      return message unless @i18n_messages && @type == 'params'
+
+      path = payload[:path]
+      return if path.nil?
+
+      translate_path(path)
+    end
+
     # @return [Hash] error Hash representation
     def to_hash
       {
         key: @key,
-        message: message,
+        message: full_message,
         payload: payload,
         type: @type
       }
@@ -64,5 +82,12 @@ class ErrorNormalizer
     def payload
       @payload.delete_if { |_k, v| v.nil? || v.empty? }
     end
+
+    def translate_path(path)
+      require 'error_normalizer/schema_path_translator' # do not load if not needed
+
+      path_translation = SchemaPathTranslator.new(path).translate
+      "#{path_translation} #{message}"
+    end
   end
 end

data/lib/error_normalizer/message_parser/english.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'error_normalizer/message_parser'
+
+class ErrorNormalizer
+  class MessageParser
+    #
+    # Parser tailored for dry-validation default error messages.
+    #
+    class English < MessageParser
+      locale :en
+
+      value_matcher :must_not_include, /\A(?<err>must not include) (?<val>.+)/
+      value_matcher :must_be_equal_to, /\A(?<err>must be equal to) (?<val>.+)/
+      value_matcher :must_not_be_equal_to, /\A(?<err>must not be equal to) (?<val>.+)/
+      value_matcher :must_be_greater_than, /\A(?<err>must be greater than) (?<val>\d+)/
+      value_matcher :must_be_greater_than_or_equal_to, /\A(?<err>must be greater than or equal to) (?<val>\d+)/
+      value_matcher :must_include, /\A(?<err>must include) (?<val>.+)/
+      value_matcher :must_be_less_than, /\A(?<err>must be less than) (?<val>\d+)/
+      value_matcher :must_be_less_than_or_equal_to, /\A(?<err>must be less than or equal to) (?<val>\d+)/
+      value_matcher :size_cannot_be_greater_than, /\A(?<err>size cannot be greater than) (?<val>\d+)/
+      value_matcher :size_cannot_be_less_than, /\A(?<err>size cannot be less than) (?<val>\d+)/
+      value_matcher :size_must_be, /\A(?<err>size must be) (?<val>\d+)/
+      value_matcher :length_must_be, /\A(?<err>length must be) (?<val>\d+)/
+
+      list_matcher :must_not_be_one_of, /\A(?<err>must not be one of): (?<val>.+)/
+      list_matcher :must_be_one_of, /\A(?<err>must be one of): (?<val>.+)/
+      list_matcher :size_must_be_within, /\A(?<err>size must be within) (?<val>.+)/
+      list_matcher :length_must_be_within, /\A(?<err>length must be within) (?<val>.+)/
+    end
+  end
+end

data/lib/error_normalizer/message_parser.rb

@@ -2,7 +2,20 @@
 
 class ErrorNormalizer
   #
-  # Parse error messages and extract payload metadata.
+  # Base implementation of the error message parser.
+  # Message parsers attempt to extract key, message and payload from the given message.
+  # Instances of {MessageParser} can't parse errors on its own because it does not define
+  # any error matchers but it defines all necessary parse logic
+  # since it doesn't depend on the locale.
+  #
+  # You can easily define your own parser by inheriting from {MessageParser}:
+  #
+  #   class RussianMessageParser < ErrorNormalizer::MessageParser
+  #     locale :ru
+  #
+  #     value_matcher :must_be_equal_to, /(?<err>должен быть равным) (?<val>.+)/u
+  #     list_matcher :must_be_on_of, /\A(?<err>должен быть одним из): (?<val>.+)/u
+  #   end
   #
   # 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
@@ -13,34 +26,66 @@ class ErrorNormalizer
   # - {https://github.com/svenfuchs/rails-i18n/blob/70b38b/rails/locale/en-US.yml#L111 ActiveModel::Errors}
   #
   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
+    AlreadyDefinedError = Class.new(StandardError)
+
+    class << self
+      # Get or set parser locale
+      # @return [Symbol]
+      def locale(i18n_locale = nil)
+        return @locale if i18n_locale.nil?
+
+        @locale = i18n_locale.intern
+      end
+
+      # Define message value matcher with a corresponding error key.
+      # Value matchers add a "value" property to the error payload.
+      # @param key [Symbol] set the error key for a given matcher
+      # @param matcher [Regexp] match and extract error and payload via regexp named groups
+      # @return [void]
+      def value_matcher(key, matcher)
+        raise ArgumentError, 'matcher should be a Regexp' unless matcher.is_a?(Regexp)
+
+        key = key.to_s
+        @value_matchers ||= {}
+
+        raise AlreadyDefinedError if @value_matchers.key?(key)
+
+        @value_matchers[key] = matcher
+      end
+
+      # Define message list matcher with a corresponding error key.
+      # List matchers add a "list" or "range" property to the error payload.
+      # @param key [Symbol] set the error key for a given matcher
+      # @param matcher [Regexp] match and extract error and payload via regexp named groups
+      # @return [void]
+      def list_matcher(key, matcher)
+        raise ArgumentError, 'matcher should be a Regexp' unless matcher.is_a?(Regexp)
+
+        key = key.to_s
+        @list_matchers ||= {}
+
+        raise AlreadyDefinedError if @list_matchers.key?(key)
+
+        @list_matchers[key] = matcher
+      end
+
+      # @return [Hash] value matchers
+      attr_reader :value_matchers
+
+      # @return [Hash] list matchers
+      attr_reader :list_matchers
+    end
 
     def initialize(message)
+      @locale = self.class.locale
       @message = message
       @key = nil
       @payload = {}
     end
 
+    # @return [String] parser locale
+    attr_reader :locale
+
     # Parse error message
     # @return (see #to_a)
     def parse
@@ -50,7 +95,7 @@ class ErrorNormalizer
       parse_list_message
       return to_a if @key
 
-      @key = to_key(@message)
+      @key = normalize_message(@message)
       to_a
     end
 
@@ -62,30 +107,31 @@ class ErrorNormalizer
     private
 
     def parse_value_message
-      VALUE_MATCHERS.each do |matcher|
+      self.class.value_matchers.each do |(key, matcher)|
         data = matcher.match(@message)
         next if data.nil?
 
-        @key = to_key(data[:err])
-        @payload[:value] = data[:val]
+        @key = key
+        @payload[:value] = data[:val] if data.names.include?('val')
 
         break
       end
     end
 
     def parse_list_message
-      LIST_MATCHERS.each do |matcher|
+      self.class.list_matchers.each do |(key, matcher)|
         data = matcher.match(@message)
         next if data.nil?
 
-        @key = to_key(data[:err])
-        @payload.merge!(parse_list_payload(data[:val]))
+        @key = key
+        @payload.merge!(parse_list_payload(data[:val])) if data.names.include?('val')
 
         break
       end
     end
 
-    def to_key(msg)
+    # TODO: fine tune for UTF-8 messages
+    def normalize_message(msg)
       msg.downcase.tr(' ', '_').gsub(/[^a-z0-9_]/, '')
     end
 

data/lib/error_normalizer/normalizer.rb

@@ -63,6 +63,7 @@ class ErrorNormalizer
 
     private
 
+    # TODO: support arrays of errors as input
     def normalize_hash(input) # rubocop:disable AbcSize
       return add_error(input) if input.is_a?(Error)
 
@@ -72,7 +73,7 @@ class ErrorNormalizer
           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) }
+          Normalizer.new(value, namespace: ns, **@config).normalize.errors.each { |e| add_error(e) }
         else
           raise UnsupportedInputTypeError
         end
@@ -86,8 +87,8 @@ class ErrorNormalizer
     end
 
     def parse_error(err_message, path, options)
-      result = MessageParser.new(err_message).parse
-      key, msg, payload = result.to_a
+      options[:i18n_messages] = @config[:i18n_messages] if options[:i18n_messages].nil?
+      key, msg, payload = *pick_message_parser.new(err_message).parse
 
       Error.new(key, message: msg, path: namespaced_path(path), **payload, **options)
     end
@@ -111,5 +112,18 @@ class ErrorNormalizer
 
       payload.merge!(type: type)
     end
+
+    def pick_message_parser # rubocop:disable AbcSize
+      find_by_locale = ->(locale) { ->(parser) { parser.locale == locale } }
+
+      msg_parser = @config[:message_parsers].find(&find_by_locale.(I18n.locale))
+      return msg_parser unless msg_parser.nil?
+
+      warn "No message parser with #{I18n.locale} found, falling back to #{I18n.default_locale}"
+      msg_parser = @config[:message_parsers].find(&find_by_locale.(I18n.default_locale))
+      return msg_parser unless msg_parser.nil?
+
+      raise 'No message parser found' if msg_parser.nil?
+    end
   end
 end

data/lib/error_normalizer/schema_path_translator.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class ErrorNormalizer
+  #
+  # Find I18n locale for the given path.
+  #
+  class SchemaPathTranslator
+    def initialize(path)
+      @path = path
+      @namespace = 'schemas' # TODO: make it configurable
+    end
+
+    # Take the path and try to translate each part of it.
+    # Given the path: "user.account.status" lookup path (and translation) will looks like:
+    #
+    #   schemas.user.@
+    #   schemas.user
+    #   user.@
+    #   user
+    #   +
+    #   schemas.user.account.@
+    #   schemas.user.account
+    #   schemas.account.@
+    #   schemas.account
+    #   account.@
+    #   account
+    #   +
+    #   schemas.user.account.status.@
+    #   schemas.user.account.status
+    #   schemas.status.@
+    #   schemas.tatus
+    #   status.@
+    #   tatus
+    #
+    # @return [String] translated path
+    #
+    def translate
+      tokens = @path.split('.')
+
+      translated_tokens = []
+      tokens.each.with_index do |token, i|
+        translated_tokens << translate_token(token, i, tokens)
+      end
+
+      translated_tokens.join(' ').capitalize
+    end
+
+    private
+
+    def translate_token(token, token_idx, all_tokens)
+      translation = nil
+      full_path = all_tokens[0..token_idx].join('.')
+
+      lookup = build_lookup(token, full_path)
+      lookup.each { |path| break translation = I18n.t(path) if I18n.exists?(path) }
+
+      translation || token
+    end
+
+    def build_lookup(token, full_path)
+      Set.new.tap do |lookup|
+        lookup << "#{@namespace}.#{full_path}.@"
+        lookup << "#{@namespace}.#{full_path}"
+        lookup << "#{@namespace}.#{token}.@"
+        lookup << "#{@namespace}.#{token}"
+        lookup << "#{full_path}.@"
+        lookup << full_path
+        lookup << "#{token}.@"
+        lookup << token
+      end
+    end
+  end
+end

data/lib/error_normalizer/version.rb

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

data/lib/error_normalizer.rb

@@ -3,6 +3,7 @@
 require 'dry-configurable'
 require 'error_normalizer/version'
 require 'error_normalizer/normalizer'
+require 'error_normalizer/message_parser/english'
 
 #
 # This class provides high-level API to normalize errors to the single format:
@@ -22,6 +23,8 @@ class ErrorNormalizer
   setting :infer_type_from_rule_name, true
   setting :rule_matcher, /_rule\z/
   setting :type_name, 'rule'
+  setting :i18n_messages, false
+  setting :message_parsers, [ErrorNormalizer::MessageParser::English]
 
   #
   # Normalize errors to flat array of structured errors.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: error_normalizer
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Denis Kondratenko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-07 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.12.2
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -113,7 +141,9 @@ files:
 - lib/error_normalizer.rb
 - lib/error_normalizer/error.rb
 - lib/error_normalizer/message_parser.rb
+- lib/error_normalizer/message_parser/english.rb
 - lib/error_normalizer/normalizer.rb
+- lib/error_normalizer/schema_path_translator.rb
 - lib/error_normalizer/version.rb
 homepage: https://gitlab.yalantis.com/public-repo/error_normalizer/
 licenses: