leftovers 0.6.0 → 0.9.0

data/lib/leftovers/config_validator/error_processor.rb

@@ -1,196 +0,0 @@
-# frozen-string-literal: true
-
-::Leftovers.try_require 'did_you_mean'
-
-module Leftovers
-  module ConfigValidator
-    module ErrorProcessor # rubocop:disable Metrics/ModuleLength
-      LENGTH_TYPE = %w{minItems minLength minProperties}.freeze
-      TYPE_TYPE = %w{null string boolean integer number array object}.freeze
-      VALUE_TYPE = %w{enum const}.freeze
-      REQUIRED_TYPE = %w{required}.freeze
-
-      class << self
-        def process(errors) # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/AbcSize
-          error_data_pointers = []
-          errors = group_errors(errors)
-          errors.flat_map do |data_pointer, error_group| # rubocop:disable Metrics/BlockLength
-            next if error_data_pointers.find { |x| x.start_with?(data_pointer) }
-
-            # original_error_group = error_group.dup
-            length_errors = error_group.select { |x| LENGTH_TYPE.include?(x['type']) }
-            value_errors = error_group.select { |x| VALUE_TYPE.include?(x['type']) }
-            type_errors = error_group.select { |x| TYPE_TYPE.include?(x['type']) }
-            required_errors = error_group.select { |x| REQUIRED_TYPE.include?(x['type']) }
-            messages = []
-
-            if !type_errors.empty? && (error_group - type_errors).empty?
-              error_group -= type_errors
-              error_data_pointers << data_pointer
-              any_of = group_by_same_any_of(type_errors)
-              if any_of.length == 1
-                was_class = to_json_type(type_errors.first['data'])
-                error_types = type_errors.map { |x| x['type'] }
-
-                messages << <<~MESSAGE.chomp
-                  #{data_pointer}: must be #{an to_sentence(error_types, 'or')} (was #{an was_class})
-                MESSAGE
-                # :nocov:
-              else
-                nil
-                # :nocov:
-              end
-            elsif !required_errors.empty? && error_group.first['data'].is_a?(Hash)
-              error_data_pointers << data_pointer
-              group_by_same_any_of(required_errors).each do |_any_of_key, any_of_value|
-                required_keywords = any_of_value.flat_map { |x| x['details']['missing_keys'] }
-                error_group -= any_of_value
-                if any_of_value.length > 1
-                  messages << <<~MESSAGE
-                    #{data_pointer}: requires at least one of these keywords: #{to_sentence(required_keywords, 'or')}
-                  MESSAGE
-
-                  # :nocov:
-                else
-                  nil
-                  # :nocov:
-                  # messages << "#{data_pointer}: requires keyword: #{required_keywords.first}"
-                end
-              end
-            elsif !length_errors.empty?
-              error_data_pointers << data_pointer
-              messages << "#{data_pointer}: can't be empty"
-            end
-
-            error_group.each do |error| # rubocop:disable Metrics/BlockLength
-              type = error['type']
-              case type
-              when 'schema'
-                error_data_pointers << data_pointer
-                parent_pointer = parent(data_pointer)
-                if ::File.basename(error['schema_pointer']) == 'additionalProperties'
-                  keyword = tail(data_pointer)
-                  parent_schema_pointer = parent(error['schema_pointer'])
-                  actual_keywords = schema_hash_dig(parent_schema_pointer)['properties'].keys
-                  corrections = did_you_mean(keyword, actual_keywords)
-
-                  messages << <<~MESSAGE.chomp
-                    #{parent_pointer}: invalid property keyword: #{keyword}
-                    Valid keywords: #{to_sentence actual_keywords}
-                    #{"Did you mean? #{to_sentence corrections, 'or'}" unless corrections.empty?}
-                  MESSAGE
-                  # :nocov:
-                else
-                  nil
-                  # :nocov:
-                end
-              when 'enum'
-                next if error['data'].is_a?(Hash)
-
-                error_data_pointers << data_pointer
-                given_value = error['data']
-                valid_values = value_errors.first['schema']['enum']
-                corrections = did_you_mean(given_value, valid_values)
-                messages << <<~MESSAGE
-                  #{data_pointer}: can't be: #{given_value}
-                  Valid values: #{to_sentence valid_values, 'or'}
-                  #{"Did you mean? #{to_sentence corrections, 'or'}" unless corrections.empty?}
-                MESSAGE
-              when 'not'
-                next unless error['data'].is_a?(Hash)
-
-                error_data_pointers << data_pointer
-                if error['schema']['required']
-                  invalid_combinations = error['schema']['required'] & error['data'].keys
-                  messages << <<~MESSAGE
-                    #{data_pointer}: use only one of: #{to_sentence invalid_combinations, 'or'}
-                  MESSAGE
-                  # :nocov:
-                else
-                end
-              else
-              end
-              # :nocov:
-            end
-
-            if messages.empty?
-              error_data_pointers << data_pointer
-              "#{data_pointer} is invalid"
-            else
-              messages
-            end
-          end.compact.map(&:strip)
-        end
-
-        private
-
-        def did_you_mean(word, dictionary)
-          # :nocov:
-          if defined?(::DidYouMean::SpellChecker)
-            ::DidYouMean::SpellChecker.new(dictionary: dictionary).correct(word)
-          else
-            []
-          end
-          # :nocov:
-        end
-
-        def schema_hash_dig(schema_pointer)
-          ::Leftovers::ConfigValidator::SCHEMA_HASH.dig(
-            *schema_pointer.split('/').drop(1).map { |x| x.match?(/\A\d+\z/) ? x.to_i : x }
-          )
-        end
-
-        def parent(pointer)
-          ::File.dirname(pointer)
-        end
-
-        def tail(pointer)
-          ::File.basename(pointer)
-        end
-
-        def to_json_type(value)
-          case value
-          when Hash then 'object'
-          when Float then 'number'
-          when true, false then 'boolean'
-          when nil then 'null'
-          else value.class.name.downcase
-          end
-        end
-
-        def an(str)
-          case str[0]
-          # when nil then ""
-          when 'a', 'e', 'i', 'o', 'u' then "an #{str}"
-          else "a #{str}"
-          end
-        end
-
-        def to_sentence(ary, join_word = 'and')
-          case ary.length
-          when 1 then ary.first
-          when 2 then ary.join(" #{join_word} ")
-          else
-            ary = ary.dup
-            last = ary.pop(2)
-            [*ary, last.join(", #{join_word} ")].join(', ')
-          end
-        end
-
-        def group_errors(errors)
-          errors = errors.map do |x|
-            x.delete('root_schema')
-            x
-          end
-          errors.group_by { |x| x['data_pointer'] }.sort.reverse.to_h
-        end
-
-        def group_by_same_any_of(errors)
-          errors.group_by do |x|
-            x['schema_pointer'].match?(%r{/anyOf/\d+$}) && parent(parent(x['schema_pointer']))
-          end
-        end
-      end
-    end
-  end
-end