leftovers 0.6.0 → 0.9.0

data/lib/leftovers/config_validator/schema_hash.rb

@@ -1,551 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module ConfigValidator # rubocop:disable Metrics/ModuleLength
-    SCHEMA_HASH = {
-      '$schema' => 'http://json-schema.org/draft-06/schema#',
-      'type' => 'object',
-      'definitions' => {
-        'true' => { 'enum' => [true, 'true'] },
-        'string' => {
-          'type' => 'string',
-          'minLength' => 1
-        },
-        'stringPattern' => {
-          'type' => 'object',
-          'properties' => {
-            'match' => { '$ref' => '#/definitions/string' },
-            'matches' => { '$ref' => '#/definitions/string' },
-            'has_prefix' => { '$ref' => '#/definitions/string' },
-            'has_suffix' => { '$ref' => '#/definitions/string' }
-          },
-          'minProperties' => 0,
-          'additionalProperties' => true,
-          'allOf' => [
-            # synonyms
-            { 'not' => { 'required' => %w{match matches} } },
-            # incompatible groups
-            { 'not' => { 'required' => %w{match has_prefix} } },
-            { 'not' => { 'required' => %w{match has_suffix} } },
-            { 'not' => { 'required' => %w{matches has_prefix} } },
-            { 'not' => { 'required' => %w{matches has_suffix} } }
-          ]
-        },
-        'stringList' => {
-          'anyOf' => [
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/string' },
-              'minItems' => 1
-            },
-            { '$ref' => '#/definitions/string' }
-          ]
-        },
-        'name' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/string' },
-            {
-              'allOf' => [
-                { '$ref' => '#/definitions/stringPattern' },
-                {
-                  'type' => 'object',
-                  'properties' => {
-                    'match' => true, 'matches' => true,
-                    'has_prefix' => true, 'has_suffix' => true,
-                    'unless' => { '$ref' => '#/definitions/nameList' }
-                  },
-                  'minProperties' => 1,
-                  'additionalProperties' => false
-                }
-              ]
-            }
-          ]
-        },
-        'nameList' => {
-          'anyOf' => [
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/name' },
-              'minItems' => 1
-            },
-            { '$ref' => '#/definitions/name' }
-          ]
-        },
-        'argumentPosition' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/string' },
-            { 'type' => 'integer', 'minimum' => 0 },
-            { '$ref' => '#/definitions/name' }
-          ]
-        },
-        'argumentPositionList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/argumentPosition' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/argumentPosition' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'valueType' => {
-          'type' => 'string',
-          'enum' => %w{String Symbol Integer Float Array Hash Proc}
-        },
-        'valueTypeList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/valueType' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/valueType' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'hasValue' => {
-          'anyOf' => [
-            { 'type' => 'string' },
-            { 'type' => 'integer' },
-            { 'type' => 'number' },
-            { 'type' => 'boolean' },
-            { 'type' => 'null' },
-            {
-              'allOf' => [
-                { '$ref' => '#/definitions/stringPattern' },
-                {
-                  'type' => 'object',
-                  'properties' => {
-                    'match' => true, 'matches' => true,
-                    'has_prefix' => true, 'has_suffix' => true,
-                    'at' => { '$ref' => '#/definitions/argumentPositionList' },
-                    'has_value' => { '$ref' => '#/definitions/hasValueList' },
-                    'has_receiver' => { '$ref' => '#/definitions/hasValueList' },
-                    'type' => { '$ref' => '#/definitions/valueTypeList' },
-                    'unless' => { '$ref' => '#/definitions/hasValueList' }
-                  },
-                  'minProperties' => 1,
-                  'additionalProperties' => false,
-                  'allOf' => [
-                    # incompatible groups
-                    { 'not' => { 'required' => %w{match at} } },
-                    { 'not' => { 'required' => %w{match has_value} } },
-                    { 'not' => { 'required' => %w{match type} } },
-                    { 'not' => { 'required' => %w{matches at} } },
-                    { 'not' => { 'required' => %w{matches has_value} } },
-                    { 'not' => { 'required' => %w{matches type} } },
-                    { 'not' => { 'required' => %w{has_prefix at} } },
-                    { 'not' => { 'required' => %w{has_prefix has_value} } },
-                    { 'not' => { 'required' => %w{has_prefix type} } },
-                    { 'not' => { 'required' => %w{has_suffix at} } },
-                    { 'not' => { 'required' => %w{has_suffix has_value} } },
-                    { 'not' => { 'required' => %w{has_suffix type} } },
-                    { 'not' => { 'required' => %w{at type} } },
-                    { 'not' => { 'required' => %w{has_value type} } }
-                  ]
-                }
-              ]
-            }
-          ]
-        },
-        'hasValueList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/hasValue' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/hasValue' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'hasArgument' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/string' },
-            { 'type' => 'integer', 'minimum' => 0 },
-            {
-              'type' => 'object',
-              'properties' => {
-                'at' => { '$ref' => '#/definitions/argumentPositionList' },
-                'has_value' => { '$ref' => '#/definitions/hasValueList' },
-                'unless' => { '$ref' => '#/definitions/hasArgumentList' }
-              },
-              'minProperties' => 1,
-              'additionalProperties' => false,
-              'allOf' => [
-                # synonyms
-                { 'not' => { 'required' => %w{has_argument has_arguments} } }
-              ]
-            }
-          ]
-        },
-        'hasArgumentList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/hasArgument' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/hasArgument' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'rulePattern' => {
-          'type' => 'object',
-          'properties' => {
-            'name' => { '$ref' => '#/definitions/nameList' },
-            'document' => { '$ref' => '#/definitions/true' },
-            'names' => { '$ref' => '#/definitions/nameList' },
-            'path' => { '$ref' => '#/definitions/stringList' },
-            'paths' => { '$ref' => '#/definitions/stringList' },
-            'has_argument' => { '$ref' => '#/definitions/hasArgumentList' },
-            'has_arguments' => { '$ref' => '#/definitions/hasArgumentList' },
-            'has_receiver' => { '$ref' => '#/definitions/hasValueList' }
-          },
-          'minProperties' => 1,
-          'allOf' => [
-            # synonyms
-            { 'not' => { 'required' => %w{name names} } },
-            { 'not' => { 'required' => %w{path paths} } },
-            { 'not' => { 'required' => %w{has_argument has_arguments} } }
-          ]
-        },
-        'transformProperties' => {
-          'type' => 'object',
-          'properties' => {
-            'original' => { '$ref' => '#/definitions/true' },
-            'pluralize' => { '$ref' => '#/definitions/true' },
-            'singularize' => { '$ref' => '#/definitions/true' },
-            'camelize' => { '$ref' => '#/definitions/true' },
-            'camelcase' => { '$ref' => '#/definitions/true' },
-            'underscore' => { '$ref' => '#/definitions/true' },
-            'titleize' => { '$ref' => '#/definitions/true' },
-            'titlecase' => { '$ref' => '#/definitions/true' },
-            'demodulize' => { '$ref' => '#/definitions/true' },
-            'deconstantize' => { '$ref' => '#/definitions/true' },
-            'parameterize' => { '$ref' => '#/definitions/true' },
-            'downcase' => { '$ref' => '#/definitions/true' },
-            'upcase' => { '$ref' => '#/definitions/true' },
-            'capitalize' => { '$ref' => '#/definitions/true' },
-            'swapcase' => { '$ref' => '#/definitions/true' },
-
-            'add_prefix' => { '$ref' => '#/definitions/actionList' },
-            'add_suffix' => { '$ref' => '#/definitions/actionList' },
-
-            'split' => { '$ref' => '#/definitions/string' },
-            'delete_prefix' => { '$ref' => '#/definitions/string' },
-            'delete_suffix' => { '$ref' => '#/definitions/string' },
-            'delete_before' => { '$ref' => '#/definitions/string' },
-            'delete_after' => { '$ref' => '#/definitions/string' }
-          }
-        },
-        'transform' => {
-          'anyOf' => [
-            {
-              'type' => 'string',
-              'enum' => %w{
-                original
-                pluralize
-                singularize
-                camelize
-                camelcase
-                underscore
-                titleize
-                titlecase
-                demodulize
-                deconstantize
-                parameterize
-                downcase
-                upcase
-                capitalize
-                swapcase
-              }
-            },
-            {
-              'allOf' => [
-                { '$ref' => '#/definitions/transformProperties' },
-                {
-                  'type' => 'object',
-                  'properties' => {
-                    'original' => true,
-                    'pluralize' => true,
-                    'singularize' => true,
-                    'camelize' => true,
-                    'camelcase' => true,
-                    'underscore' => true,
-                    'titleize' => true,
-                    'titlecase' => true,
-                    'demodulize' => true,
-                    'deconstantize' => true,
-                    'parameterize' => true,
-                    'downcase' => true,
-                    'upcase' => true,
-                    'capitalize' => true,
-                    'swapcase' => true,
-                    'add_prefix' => true,
-                    'add_suffix' => true,
-                    'split' => true,
-                    'delete_prefix' => true,
-                    'delete_suffix' => true,
-                    'delete_before' => true,
-                    'delete_after' => true
-                  },
-                  'additionalProperties' => false
-                }
-              ]
-            }
-          ]
-        },
-        'transformList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/transform' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/transform' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'keyword' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/name' }
-          ]
-        },
-        'keywordList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/keyword' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/keyword' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'action' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/string' },
-            { 'type' => 'integer', 'minimum' => 0 },
-            {
-              'allOf' => [
-                { '$ref' => '#/definitions/transformProperties' },
-                {
-                  'type' => 'object',
-                  'properties' => {
-                    'argument' => { '$ref' => '#/definitions/argumentPositionList' },
-                    'arguments' => { '$ref' => '#/definitions/argumentPositionList' },
-                    'keyword' => { '$ref' => '#/definitions/keywordList' },
-                    'keywords' => { '$ref' => '#/definitions/keywordList' },
-                    'itself' => { '$ref' => '#/definitions/true' },
-                    'value' => { '$ref' => '#/definitions/string' },
-                    'nested' => { '$ref' => '#/definitions/actionList' },
-                    'recursive' => { '$ref' => '#/definitions/true' },
-                    'transforms' => { '$ref' => '#/definitions/transformList' },
-                    'pluralize' => true,
-                    'singularize' => true,
-                    'camelize' => true,
-                    'camelcase' => true,
-                    'underscore' => true,
-                    'titleize' => true,
-                    'titlecase' => true,
-                    'demodulize' => true,
-                    'deconstantize' => true,
-                    'parameterize' => true,
-                    'downcase' => true,
-                    'upcase' => true,
-                    'capitalize' => true,
-                    'swapcase' => true,
-                    'add_prefix' => true,
-                    'add_suffix' => true,
-                    'split' => true,
-                    'delete_prefix' => true,
-                    'delete_suffix' => true,
-                    'delete_before' => true,
-                    'delete_after' => true
-                  },
-                  'additionalProperties' => false,
-                  'allOf' => [
-                    # synonyms
-                    { 'not' => { 'required' => %w{keyword keywords} } },
-                    { 'not' => { 'required' => %w{argument arguments} } },
-                    # any of
-                    {
-                      'anyOf' => [
-                        { 'required' => ['argument'] },
-                        { 'required' => ['arguments'] },
-                        { 'required' => ['keyword'] },
-                        { 'required' => ['keywords'] },
-                        { 'required' => ['itself'] },
-                        { 'required' => ['value'] }
-                      ]
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        },
-        'actionList' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/action' },
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/action' },
-              'minItems' => 1
-            }
-          ]
-        },
-        'dynamicAction' => {
-          'type' => 'object',
-          'properties' => {
-            'call' => { '$ref' => '#/definitions/actionList' },
-            'calls' => { '$ref' => '#/definitions/actionList' },
-            'define' => { '$ref' => '#/definitions/actionList' },
-            'defines' => { '$ref' => '#/definitions/actionList' }
-          },
-          'additionalProperties' => true,
-          'minProperties' => 1,
-          'allOf' => [
-            # synonyms
-            { 'not' => { 'required' => %w{call calls} } },
-            { 'not' => { 'required' => %w{define defines} } },
-            # At least one of
-            {
-              'anyOf' => [
-                { 'required' => ['call'] }, { 'required' => ['calls'] },
-                { 'required' => ['define'] }, { 'required' => ['defines'] }
-              ]
-            }
-          ]
-        },
-        'ruleMatcherList' => {
-          'anyOf' => [
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/ruleMatcher' },
-              'minItems' => 1
-            },
-            { '$ref' => '#/definitions/ruleMatcher' }
-          ]
-        },
-        'ruleMatcher' => {
-          'allOf' => [
-            { '$ref' => '#/definitions/rulePattern' },
-            {
-              'anyOf' => [
-                { 'required' => ['name'] }, { 'required' => ['names'] },
-                { 'required' => ['path'] }, { 'required' => ['paths'] },
-                { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
-                { 'required' => ['has_receiver'] },
-                { 'required' => ['unless'] }
-              ]
-            },
-            {
-              'type' => 'object',
-              'properties' => {
-                # unfortunately this repetition is necessary to use additionalProperties: false
-                'name' => true, 'names' => true,
-                'path' => true, 'paths' => true,
-                'has_argument' => true, 'has_arguments' => true,
-                'has_receiver' => true,
-                'unless' => { '$ref' => '#/definitions/ruleMatcherList' }
-
-              },
-              'additionalProperties' => false,
-              'minProperties' => 1
-            }
-          ]
-        },
-        'dynamic' => {
-          'allOf' => [
-            { '$ref' => '#/definitions/rulePattern' },
-            { '$ref' => '#/definitions/dynamicAction' },
-            {
-              'anyOf' => [
-                { 'required' => ['name'] }, { 'required' => ['names'] },
-                { 'required' => ['document'] },
-                { 'required' => ['path'] }, { 'required' => ['paths'] },
-                { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
-                { 'required' => ['has_receiver'] },
-                { 'required' => ['unless'] }
-              ]
-            },
-            {
-              'type' => 'object',
-              'properties' => {
-                # unfortunately this repetition is necessary to use additionalProperties: false
-                'name' => true, 'names' => true,
-                'path' => true, 'paths' => true,
-                'document' => true,
-                'has_argument' => true, 'has_arguments' => true,
-                'has_receiver' => true,
-                'unless' => { '$ref' => '#/definitions/ruleMatcherList' },
-
-                'call' => true, 'calls' => true,
-                'define' => true, 'defines' => true
-              },
-              'additionalProperties' => false,
-              'minProperties' => 1
-            }
-          ]
-        },
-        'dynamicList' => {
-          'anyOf' => [
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/dynamic' },
-              'minItems' => 1
-            },
-            { '$ref' => '#/definitions/dynamic' }
-          ]
-        },
-        'keepTestOnly' => {
-          'anyOf' => [
-            { '$ref' => '#/definitions/string' },
-            {
-              'allOf' => [
-                { '$ref' => '#/definitions/stringPattern' },
-                { '$ref' => '#/definitions/rulePattern' },
-                {
-                  'type' => 'object',
-                  'properties' => {
-                    # unfortunately this repetition is necessary to use additionalProperties: false
-                    'name' => true, 'names' => true,
-                    'has_prefix' => true, 'has_suffix' => true, 'matches' => true,
-                    'path' => true, 'paths' => true,
-                    'has_argument' => true, 'has_arguments' => true,
-                    'has_receiver' => true,
-                    'unless' => { '$ref' => '#/definitions/keepTestOnlyList' }
-                  },
-                  'additionalProperties' => false,
-                  'minProperties' => 1
-                }
-              ]
-            }
-          ]
-        },
-        'keepTestOnlyList' => {
-          'anyOf' => [
-            {
-              'type' => 'array',
-              'items' => { '$ref' => '#/definitions/keepTestOnly' },
-              'minItems' => 1
-            },
-            { '$ref' => '#/definitions/keepTestOnly' }
-          ]
-        }
-      },
-      'properties' => {
-        'include_paths' => { '$ref' => '#/definitions/stringList' },
-        'exclude_paths' => { '$ref' => '#/definitions/stringList' },
-        'test_paths' => { '$ref' => '#/definitions/stringList' },
-        'haml_paths' => { '$ref' => '#/definitions/stringList' },
-        'slim_paths' => { '$ref' => '#/definitions/stringList' },
-        'yaml_paths' => { '$ref' => '#/definitions/stringList' },
-        'json_paths' => { '$ref' => '#/definitions/stringList' },
-        'erb_paths' => { '$ref' => '#/definitions/stringList' },
-        'requires' => { '$ref' => '#/definitions/stringList' },
-        'gems' => { '$ref' => '#/definitions/stringList' },
-        'keep' => { '$ref' => '#/definitions/keepTestOnlyList' },
-        'test_only' => { '$ref' => '#/definitions/keepTestOnlyList' },
-        'dynamic' => { '$ref' => '#/definitions/dynamicList' }
-      }
-    }.freeze
-  end
-end

data/lib/leftovers/config_validator.rb

@@ -1,61 +0,0 @@
-# frozen-string-literal: true
-
-require 'set'
-require 'json_schemer'
-
-module Leftovers
-  module ConfigValidator
-    autoload(:ErrorProcessor, "#{__dir__}/config_validator/error_processor")
-    autoload(:SCHEMA_HASH, "#{__dir__}/config_validator/schema_hash")
-
-    def self.default_schema
-      @default_schema ||= ::JSONSchemer.schema(::Leftovers::ConfigValidator::SCHEMA_HASH)
-    end
-
-    def self.validate(obj, validator = default_schema)
-      validator.validate(obj)
-    end
-
-    def self.validate_and_process!(yaml, path)
-      errors = validate(yaml)
-      print_validation_errors_and_exit(errors, path) unless errors.first.nil?
-      post_process!(yaml)
-    end
-
-    def self.print_validation_errors_and_exit(errors, path)
-      ::Leftovers::ConfigValidator::ErrorProcessor.process(errors).each do |message|
-        warn "\e[31mConfig SchemaError: (#{path}): #{message}\e[0m"
-      end
-
-      ::Leftovers.exit 1
-    end
-
-    def self.post_process!(obj)
-      case obj
-      when Hash
-        obj.keys.each do |key| # rubocop:disable Style/HashEachMethods # each_key never finishes.
-          obj[symbolize_name(key)] = post_process!(obj.delete(key))
-        end
-      when Array
-        obj.map! { |ea| post_process!(ea) }
-      end
-      obj
-    end
-
-    def self.symbolize_name(name) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-      case name
-      when 'matches' then :match
-      when 'defines' then :define
-      when 'calls' then :call
-      when 'name' then :names
-      when 'keyword' then :keywords
-      when 'argument' then :arguments
-      when 'has_argument' then :has_arguments
-      when 'path' then :paths
-      when 'unless' then :unless_arg
-      when 'require' then :requires
-      else name.to_sym
-      end
-    end
-  end
-end

data/lib/leftovers/dynamic_processors/call.rb

@@ -1,21 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    class Call
-      def initialize(matcher, processor)
-        @matcher = matcher
-        @processor = processor
-      end
-
-      def process(node, file)
-        return unless @matcher === node
-
-        call = @processor.process(nil, node, node)
-        return unless call
-
-        file.calls << call
-      end
-    end
-  end
-end

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -1,27 +0,0 @@
-# frozen-string-literal: true
-
-module Leftovers
-  module DynamicProcessors
-    class CallDefinition
-      def initialize(matcher, call_processor, definition_processor)
-        @matcher = matcher
-        @call_processor = call_processor
-        @definition_processor = definition_processor
-      end
-
-      def process(node, file)
-        return unless @matcher === node
-
-        call = @call_processor.process(nil, node, node)
-        (file.calls << call) if call
-
-        return if node.keep_line?
-
-        definition = @definition_processor.process(nil, node, node)
-        return unless definition
-
-        file.definitions << definition
-      end
-    end
-  end
-end