leftovers 0.6.0 → 0.7.0

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -6,7 +6,7 @@ module Leftovers
       def self.build(argument, then_processor)
         case argument
         when ::Hash
-          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
           ::Leftovers::ValueProcessors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
         when ::String
           ::Leftovers::ValueProcessors::AddPrefix.new(argument, then_processor)

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -6,7 +6,7 @@ module Leftovers
       def self.build(argument, then_processor)
         case argument
         when ::Hash
-          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :call)
+          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
           ::Leftovers::ValueProcessors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
         when ::String
           ::Leftovers::ValueProcessors::AddSuffix.new(argument, then_processor)

data/lib/leftovers/processor_builders/dynamic.rb

@@ -3,23 +3,57 @@
 module Leftovers
   module ProcessorBuilders
     module Dynamic
-      def self.build(dynamic_rules) # rubocop:disable Metrics/MethodLength
-        ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(dynamic_rules) do |dynamic|
-          call = ::Leftovers::ProcessorBuilders::Action.build(dynamic.delete(:call), :call)
-          define = ::Leftovers::ProcessorBuilders::Action.build(dynamic.delete(:define), :define)
-          matcher = ::Leftovers::MatcherBuilders::Node.build(**dynamic)
-
-          # this nonsense saves a method call and array instantiation per method
-          if call && define
-            ::Leftovers::DynamicProcessors::CallDefinition.new(matcher, call, define)
-          elsif define
-            ::Leftovers::DynamicProcessors::Definition.new(matcher, define)
-          elsif call
-            ::Leftovers::DynamicProcessors::Call.new(matcher, call)
-          # :nocov:
+      class << self
+        def build(dynamic_rules)
+          ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(dynamic_rules) do |dynamic|
+            build_processors(**dynamic)
+          end
+        end
+
+        private
+
+        def build_processors(
+          call: nil, define: nil, set_privacy: nil, set_default_privacy: nil, **matcher_rules
+        )
+          matcher = ::Leftovers::MatcherBuilders::Node.build(**matcher_rules)
+
+          ::Leftovers::ProcessorBuilders::EachDynamic.build([
+            build_call_define_processor(matcher, call, define),
+            build_set_privacy_processor(matcher, set_privacy),
+            build_set_default_privacy_processor(matcher, set_default_privacy)
+          ])
+        end
+
+        def build_action(processor_rules, return_type:)
+          ::Leftovers::ProcessorBuilders::Action.build(processor_rules, return_type)
+        end
+
+        def build_set_privacy_processor(matcher, set_privacy)
+          ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(set_privacy) do |action_values|
+            to = action_values.delete(:to)
+            action = build_action(action_values, return_type: :sym)
+
+            ::Leftovers::DynamicProcessors::SetPrivacy.new(matcher, action, to)
+          end
+        end
+
+        def build_set_default_privacy_processor(matcher, set_default_privacy)
+          ::Leftovers::DynamicProcessors::SetDefaultPrivacy.new(matcher, set_default_privacy)
+        end
+
+        def build_call_define_processor(matcher, call, define) # rubocop:disable Metrics/MethodLength
+          call_action = build_action(call, return_type: :sym)
+          define_action = build_action(define, return_type: :definition_node)
+
+          if call_action && define_action
+            # this nonsense saves a method call and array instantiation per method
+            ::Leftovers::DynamicProcessors::CallDefinition.new(matcher, call_action, define_action)
+          elsif define_action
+            ::Leftovers::DynamicProcessors::Definition.new(matcher, define_action)
+          elsif call_action
+            ::Leftovers::DynamicProcessors::Call.new(matcher, call_action)
           else
-            raise
-            # :nocov:
+            ::Leftovers::DynamicProcessors::Null
           end
         end
       end

data/lib/leftovers/processor_builders/transform.rb

@@ -19,9 +19,9 @@ module Leftovers
           ::Leftovers::ValueProcessors::Pluralize.new(then_processor)
         when 'singularize'
           ::Leftovers::ValueProcessors::Singularize.new(then_processor)
-        when 'camelize', 'camelcase'
+        when 'camelize'
           ::Leftovers::ValueProcessors::Camelize.new(then_processor)
-        when 'titleize', 'titlecase'
+        when 'titleize'
           ::Leftovers::ValueProcessors::Titleize.new(then_processor)
         when 'demodulize'
           ::Leftovers::ValueProcessors::Demodulize.new(then_processor)

data/lib/leftovers/processor_builders/transform_set.rb

@@ -21,24 +21,24 @@ module Leftovers
 
       def self.each_builder(action)
         case action
-        when :call
+        when :sym
           ::Leftovers::ProcessorBuilders::Each
-        when :define
+        when :definition_node
           ::Leftovers::ProcessorBuilders::EachForDefinitionSet
         # :nocov:
-        else raise
+        else raise "Unknown action #{action}"
           # :nocov:
         end
       end
 
       def self.build_final(action)
         case action
-        when :call
-          ::Leftovers::ValueProcessors::ReturnString
-        when :define
-          ::Leftovers::ValueProcessors::ReturnDefinition
+        when :sym
+          ::Leftovers::ValueProcessors::ReturnSym
+        when :definition_node
+          ::Leftovers::ValueProcessors::ReturnDefinitionNode
         # :nocov:
-        else raise
+        else raise "Unknown action #{action}"
           # :nocov:
         end
       end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -11,10 +11,7 @@ module Leftovers
 
       def process(str, node, method_node)
         definitions = @then_processors.map do |then_processor|
-          processed = then_processor.process(str, node, method_node)
-          return if processed == :keep # rubocop:disable Lint/NonLocalExitFromIterator
-
-          processed
+          then_processor.process(str, node, method_node)
         end
 
         definitions.flatten!
@@ -22,7 +19,7 @@ module Leftovers
 
         return definitions.first if definitions.length <= 1
 
-        ::Leftovers::DefinitionSet.new(definitions)
+        ::Leftovers::DefinitionNodeSet.new(definitions)
       end
     end
   end

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -14,7 +14,7 @@ module Leftovers
         return unless positional_arguments
 
         positional_arguments.map do |argument_node|
-          str = argument_node.to_s if argument_node.string_or_symbol?
+          str = argument_node.to_s if argument_node.string_or_symbol_or_def?
 
           @then_processor.process(str, argument_node, method_node)
         end

data/lib/leftovers/value_processors/return_definition_node.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    module ReturnDefinitionNode
+      def self.process(str, node, _method_node)
+        return unless str
+        return if str.empty?
+
+        Leftovers::DefinitionNode.new(node, name: str.to_sym)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/{return_string.rb → return_sym.rb}

@@ -2,7 +2,7 @@
 
 module Leftovers
   module ValueProcessors
-    module ReturnString
+    module ReturnSym
       def self.process(str, _node, _method_node)
         return unless str
         return if str.empty?

data/lib/leftovers/value_processors.rb

@@ -28,8 +28,8 @@ module Leftovers
     autoload(:Pluralize, "#{__dir__}/value_processors/pluralize")
     autoload(:PositionalArgument, "#{__dir__}/value_processors/positional_argument")
     autoload(:ReplaceValue, "#{__dir__}/value_processors/replace_value")
-    autoload(:ReturnDefinition, "#{__dir__}/value_processors/return_definition")
-    autoload(:ReturnString, "#{__dir__}/value_processors/return_string")
+    autoload(:ReturnDefinitionNode, "#{__dir__}/value_processors/return_definition_node")
+    autoload(:ReturnSym, "#{__dir__}/value_processors/return_sym")
     autoload(:Singularize, "#{__dir__}/value_processors/singularize")
     autoload(:Split, "#{__dir__}/value_processors/split")
     autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")

data/lib/leftovers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leftovers
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/lib/leftovers.rb

@@ -6,11 +6,13 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   autoload(:AST, "#{__dir__}/leftovers/ast")
   autoload(:CLI, "#{__dir__}/leftovers/cli")
   autoload(:Collector, "#{__dir__}/leftovers/collector")
-  autoload(:ConfigValidator, "#{__dir__}/leftovers/config_validator")
+  autoload(:ConfigLoader, "#{__dir__}/leftovers/config_loader")
   autoload(:Config, "#{__dir__}/leftovers/config")
+  autoload(:Definition, "#{__dir__}/leftovers/definition")
   autoload(:DefinitionNode, "#{__dir__}/leftovers/definition_node")
+  autoload(:DefinitionNodeSet, "#{__dir__}/leftovers/definition_node_set")
   autoload(:DefinitionSet, "#{__dir__}/leftovers/definition_set")
-  autoload(:Definition, "#{__dir__}/leftovers/definition")
+  autoload(:DefinitionToAdd, "#{__dir__}/leftovers/definition_to_add")
   autoload(:ERB, "#{__dir__}/leftovers/erb")
   autoload(:FileCollector, "#{__dir__}/leftovers/file_collector")
   autoload(:FileList, "#{__dir__}/leftovers/file_list")
@@ -31,6 +33,19 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   autoload(:ValueProcessors, "#{__dir__}/leftovers/value_processors")
   autoload(:VERSION, "#{__dir__}/leftovers/version")
 
+  MEMOIZED_IVARS = %i{
+    @config
+    @collector
+    @reporter
+    @leftovers
+    @try_require_cache
+    @stdout
+    @stderr
+    @parallel
+    @pwd
+    @progress
+  }.freeze
+
   class << self
     attr_accessor :parallel, :progress
     attr_writer :reporter
@@ -82,16 +97,10 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
       reporter.report(only_test: only_test, none: none)
     end
 
-    def reset # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-      remove_instance_variable(:@config) if defined?(@config)
-      remove_instance_variable(:@collector) if defined?(@collector)
-      remove_instance_variable(:@reporter) if defined?(@reporter)
-      remove_instance_variable(:@leftovers) if defined?(@leftovers)
-      remove_instance_variable(:@try_require_cache) if defined?(@try_require_cache)
-      remove_instance_variable(:@stdout) if defined?(@stdout)
-      remove_instance_variable(:@stderr) if defined?(@stderr)
-      remove_instance_variable(:@parallel) if defined?(@parallel)
-      remove_instance_variable(:@pwd) if defined?(@pwd)
+    def reset
+      MEMOIZED_IVARS.each do |ivar|
+        remove_instance_variable(ivar) if instance_variable_get(ivar)
+      end
     end
 
     def resolution_instructions_link
@@ -103,7 +112,7 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
     end
 
     def error(message)
-      warn(message)
+      warn("\e[31m#{message}\e[0m")
       exit 1
     end
 
@@ -137,7 +146,7 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
 
       case value
       when nil then nil
-      when Array then value.each(&block)
+      when Array then value.each { |i| each_or_self(i, &block) }
       else yield(value)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leftovers
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Dana Sherson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2022-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: did_you_mean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: haml
   requirement: !ruby/object:Gem::Requirement
@@ -262,20 +276,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.15.1
-- !ruby/object:Gem::Dependency
-  name: json_schemer
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: parallel
   requirement: !ruby/object:Gem::Requirement
@@ -320,7 +320,6 @@ files:
 - exe/leftovers
 - leftovers.gemspec
 - lib/.DS_Store
-- lib/config/actioncable.yml
 - lib/config/actionmailer.yml
 - lib/config/actionpack.yml
 - lib/config/actionview.yml
@@ -343,6 +342,7 @@ files:
 - lib/config/pry.yml
 - lib/config/rack.yml
 - lib/config/rails.yml
+- lib/config/railties.yml
 - lib/config/rake.yml
 - lib/config/redcarpet.yml
 - lib/config/rollbar.yml
@@ -360,18 +360,48 @@ files:
 - lib/leftovers/cli.rb
 - lib/leftovers/collector.rb
 - lib/leftovers/config.rb
-- lib/leftovers/config_validator.rb
-- lib/leftovers/config_validator/error_processor.rb
-- lib/leftovers/config_validator/schema_hash.rb
+- lib/leftovers/config_loader.rb
+- lib/leftovers/config_loader/argument_position_schema.rb
+- lib/leftovers/config_loader/argumentless_transform_schema.rb
+- lib/leftovers/config_loader/attribute.rb
+- lib/leftovers/config_loader/document_schema.rb
+- lib/leftovers/config_loader/dynamic_schema.rb
+- lib/leftovers/config_loader/has_argument_schema.rb
+- lib/leftovers/config_loader/has_value_schema.rb
+- lib/leftovers/config_loader/keep_test_only_schema.rb
+- lib/leftovers/config_loader/node.rb
+- lib/leftovers/config_loader/object_schema.rb
+- lib/leftovers/config_loader/privacy_processor_schema.rb
+- lib/leftovers/config_loader/privacy_schema.rb
+- lib/leftovers/config_loader/require_schema.rb
+- lib/leftovers/config_loader/rule_pattern_schema.rb
+- lib/leftovers/config_loader/scalar_argument_schema.rb
+- lib/leftovers/config_loader/scalar_value_schema.rb
+- lib/leftovers/config_loader/schema.rb
+- lib/leftovers/config_loader/string_enum_schema.rb
+- lib/leftovers/config_loader/string_pattern_schema.rb
+- lib/leftovers/config_loader/string_schema.rb
+- lib/leftovers/config_loader/string_value_processor_schema.rb
+- lib/leftovers/config_loader/suggester.rb
+- lib/leftovers/config_loader/transform_schema.rb
+- lib/leftovers/config_loader/true_schema.rb
+- lib/leftovers/config_loader/value_matcher_schema.rb
+- lib/leftovers/config_loader/value_or_array_schema.rb
+- lib/leftovers/config_loader/value_processor_schema.rb
+- lib/leftovers/config_loader/value_type_schema.rb
 - lib/leftovers/definition.rb
 - lib/leftovers/definition_node.rb
+- lib/leftovers/definition_node_set.rb
 - lib/leftovers/definition_set.rb
+- lib/leftovers/definition_to_add.rb
 - lib/leftovers/dynamic_processors.rb
 - lib/leftovers/dynamic_processors/call.rb
 - lib/leftovers/dynamic_processors/call_definition.rb
 - lib/leftovers/dynamic_processors/definition.rb
 - lib/leftovers/dynamic_processors/each.rb
 - lib/leftovers/dynamic_processors/null.rb
+- lib/leftovers/dynamic_processors/set_default_privacy.rb
+- lib/leftovers/dynamic_processors/set_privacy.rb
 - lib/leftovers/erb.rb
 - lib/leftovers/file.rb
 - lib/leftovers/file_collector.rb
@@ -392,6 +422,7 @@ files:
 - lib/leftovers/matcher_builders/node_pair_name.rb
 - lib/leftovers/matcher_builders/node_pair_value.rb
 - lib/leftovers/matcher_builders/node_path.rb
+- lib/leftovers/matcher_builders/node_privacy.rb
 - lib/leftovers/matcher_builders/node_type.rb
 - lib/leftovers/matcher_builders/node_value.rb
 - lib/leftovers/matcher_builders/or.rb
@@ -411,6 +442,7 @@ files:
 - lib/leftovers/matchers/node_name.rb
 - lib/leftovers/matchers/node_pair_value.rb
 - lib/leftovers/matchers/node_path.rb
+- lib/leftovers/matchers/node_privacy.rb
 - lib/leftovers/matchers/node_scalar_value.rb
 - lib/leftovers/matchers/node_type.rb
 - lib/leftovers/matchers/not.rb
@@ -466,8 +498,8 @@ files:
 - lib/leftovers/value_processors/pluralize.rb
 - lib/leftovers/value_processors/positional_argument.rb
 - lib/leftovers/value_processors/replace_value.rb
-- lib/leftovers/value_processors/return_definition.rb
-- lib/leftovers/value_processors/return_string.rb
+- lib/leftovers/value_processors/return_definition_node.rb
+- lib/leftovers/value_processors/return_sym.rb
 - lib/leftovers/value_processors/singularize.rb
 - lib/leftovers/value_processors/split.rb
 - lib/leftovers/value_processors/swapcase.rb

data/lib/config/actioncable.yml

@@ -1,4 +0,0 @@
-# THIS IS INCOMPLETE (you can help by expanding it)
-# rails is _really complicated_ and has a lot of magic which calls methods for you.
-# some is currently impossible to handle (with_options).
-# Some is just corners of rails I haven't hit yet.

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