leftovers 0.5.4 → 0.7.0

data/lib/leftovers/ast/node.rb

@@ -25,14 +25,6 @@ module Leftovers
         @memo[:path] ||= loc.expression.source_buffer.name.to_s
       end
 
-      def test_line?
-        @memo[:test_line]
-      end
-
-      def test_line=(value)
-        @memo[:test_line] = value
-      end
-
       def keep_line=(value)
         @memo[:keep_line] = value
       end
@@ -41,6 +33,14 @@ module Leftovers
         @memo[:keep_line]
       end
 
+      def privacy=(value)
+        @memo[:privacy] = value
+      end
+
+      def privacy
+        @memo[:privacy] || :public
+      end
+
       def to_scalar_value
         case type
         when :sym, :int, :float, :str
@@ -58,7 +58,8 @@ module Leftovers
         case type
         when :sym, :int, :float, :str, :true, :false, :nil
           true
-        else false
+        else
+          false
         end
       end
 
@@ -78,6 +79,10 @@ module Leftovers
         type == :str || type == :sym
       end
 
+      def string_or_symbol_or_def?
+        type == :str || type == :sym || type == :def || type == :defs
+      end
+
       def proc?
         return unless type == :block
 
@@ -140,9 +145,9 @@ module Leftovers
 
       def name
         @memo[:name] ||= case type
-        when :send, :csend, :casgn, :const
+        when :send, :csend, :casgn, :const, :defs
           second
-        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym
+        when :def, :ivasgn, :ivar, :gvar, :cvar, :gvasgn, :cvasgn, :sym, :lvar
           first
         when :str
           first.to_sym

data/lib/leftovers/collector.rb

@@ -28,7 +28,9 @@ module Leftovers
 
     def collect_file_list(list)
       if Leftovers.parallel?
-        Parallel.each(list, finish: method(:finish_file), &method(:collect_file))
+        Parallel.each(list, finish: method(:finish_file)) do |file|
+          collect_file(file)
+        end
       else
         list.each { |file| finish_file(nil, nil, collect_file(file)) }
       end

data/lib/leftovers/config.rb

@@ -1,13 +1,7 @@
 # frozen_string_literal: true
 
-require 'yaml'
-
 module Leftovers
   class Config
-    # :nocov:
-    using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-    # :nocov:
-
     attr_reader :name
 
     def initialize(name, path: nil, content: nil)
@@ -40,6 +34,14 @@ module Leftovers
       @slim_paths ||= Array(yaml[:slim_paths])
     end
 
+    def yaml_paths
+      @yaml_paths ||= Array(yaml[:yaml_paths])
+    end
+
+    def json_paths
+      @json_paths ||= Array(yaml[:json_paths])
+    end
+
     def erb_paths
       @erb_paths ||= Array(yaml[:erb_paths])
     end
@@ -62,29 +64,8 @@ module Leftovers
 
     private
 
-    def content
-      @content ||= ::File.exist?(path) ? ::File.read(path) : ''
-    end
-
-    def path
-      @path ||= ::File.expand_path("../config/#{name}.yml", __dir__)
-    end
-
     def yaml
-      @yaml ||= ::Leftovers::ConfigValidator.validate_and_process!(parse_yaml, path)
-    end
-
-    def parse_yaml
-      # :nocov:
-      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.6')
-        Psych.safe_load(content, filename: path) || {}
-      else
-        Psych.safe_load(content, [], [], false, path) || {}
-      end
-      # :nocov:
-    rescue ::Psych::SyntaxError => e
-      warn "\e[31mConfig SyntaxError: #{e.message}\e[0m"
-      Leftovers.exit 1
+      @yaml ||= ::Leftovers::ConfigLoader.load(name, path: @path, content: @content)
     end
   end
 end

data/lib/leftovers/config_loader/argument_position_schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArgumentPositionSchema < ObjectSchema
+      inherit_attributes_from StringPatternSchema
+
+      self.or_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/argumentless_transform_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ArgumentlessTransformSchema < StringEnumSchema
+      value :original
+      value :pluralize
+      value :singularize
+      value :camelize, aliases: :camelcase
+      value :underscore
+      value :titleize, aliases: :titlecase
+      value :demodulize
+      value :deconstantize
+      value :parameterize
+      value :downcase
+      value :upcase
+      value :capitalize
+      value :swapcase
+    end
+  end
+end

data/lib/leftovers/config_loader/attribute.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Attribute
+      def initialize(name, value_schema, aliases: nil, require_group: nil)
+        @name = name
+        @value_schema = value_schema
+        @aliases = aliases
+        @require_group = require_group
+      end
+
+      def attributes
+        { @name => @value_schema }
+      end
+
+      def aliases
+        ::Leftovers.each_or_self(@aliases).map do |aka|
+          [aka, @name]
+        end.to_h
+      end
+
+      def require_groups
+        return {} unless @require_group
+
+        { @require_group => [@name, *::Leftovers.each_or_self(@aliases)] }
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/document_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DocumentSchema < ObjectSchema
+      attribute :include_paths, ValueOrArraySchema[StringSchema], aliases: :include_path
+      attribute :exclude_paths, ValueOrArraySchema[StringSchema], aliases: :exclude_path
+      attribute :test_paths, ValueOrArraySchema[StringSchema], aliases: :test_path
+      attribute :haml_paths, ValueOrArraySchema[StringSchema], aliases: :haml_path
+      attribute :slim_paths, ValueOrArraySchema[StringSchema], aliases: :slim_path
+      attribute :yaml_paths, ValueOrArraySchema[StringSchema], aliases: :yaml_path
+      attribute :json_paths, ValueOrArraySchema[StringSchema], aliases: :json_path
+      attribute :erb_paths, ValueOrArraySchema[StringSchema], aliases: :erb_path
+      attribute :requires, ValueOrArraySchema[RequireSchema], aliases: :require
+      attribute :gems, ValueOrArraySchema[StringSchema], aliases: :gem
+      attribute :keep, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :test_only, ValueOrArraySchema[KeepTestOnlySchema]
+      attribute :dynamic, ValueOrArraySchema[DynamicSchema]
+    end
+  end
+end

data/lib/leftovers/config_loader/dynamic_schema.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class DynamicSchema < ObjectSchema
+      inherit_attributes_from RulePatternSchema
+
+      attribute :call, ValueOrArraySchema[ValueProcessorSchema], aliases: :calls,
+        require_group: :processor
+      attribute :define, ValueOrArraySchema[ValueProcessorSchema], aliases: :defines,
+        require_group: :processor
+      attribute :set_privacy, ValueOrArraySchema[PrivacyProcessorSchema],
+                require_group: :processor
+      attribute :set_default_privacy, PrivacySchema, require_group: :processor
+    end
+  end
+end

data/lib/leftovers/config_loader/has_argument_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasArgumentSchema < ObjectSchema
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasArgumentSchema], require_group: :matcher
+
+      self.or_schema = ScalarArgumentSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/has_value_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class HasValueSchema < ObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+
+      attribute :at, ValueOrArraySchema[ArgumentPositionSchema], require_group: :matcher
+      attribute :has_value, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+
+      self.or_schema = ScalarValueSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/keep_test_only_schema.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class KeepTestOnlySchema < ObjectSchema
+      inherit_attributes_from StringPatternSchema, except: :unless
+      inherit_attributes_from RulePatternSchema, except: :unless
+      attribute :unless, ValueOrArraySchema[KeepTestOnlySchema], require_group: :matcher
+
+      self.or_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/node.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class Node
+      class_loader = Psych::ClassLoader::Restricted.new([], [])
+      ToRuby = Psych::Visitors::ToRuby.new(
+        Psych::ScalarScanner.new(class_loader),
+        class_loader
+      )
+
+      attr_reader :node, :file, :name
+      attr_accessor :error
+
+      def initialize(node, file, name = nil)
+        @node = node
+        @file = file
+        @name = name
+      end
+
+      def name_
+        "#{name} " if name
+      end
+
+      def valid?
+        !error
+      end
+
+      def error_message
+        "Config SchemaError: #{location} #{@error}" if @error
+      end
+
+      def all_errors
+        Array(error_message) + children.flat_map(&:all_errors)
+      end
+
+      def to_s
+        to_ruby.to_s
+      end
+
+      def hash?
+        node.is_a?(Psych::Nodes::Mapping)
+      end
+
+      def location
+        "#{file.relative_path}:#{node.start_line + 1}:#{node.start_column}"
+      end
+
+      def children
+        @children ||= if hash?
+          prepare_hash_children
+        elsif array?
+          node.children.map { |value| self.class.new(value, file, "#{name} value") }
+        else
+          []
+        end
+      end
+
+      def keys
+        @keys ||= pairs.map(&:first)
+      end
+
+      def pairs
+        @pairs ||= children.each_slice(2).to_a
+      end
+
+      def each_key(&block)
+        keys.each(&block)
+      end
+
+      def to_ruby
+        @to_ruby ||= ToRuby.accept(node)
+      end
+
+      def to_sym
+        to_ruby.to_sym if string?
+      end
+
+      def string?
+        to_ruby.is_a?(String)
+      end
+
+      def scalar?
+        !array? and !hash?
+      end
+
+      def array?
+        node.is_a?(Psych::Nodes::Sequence)
+      end
+
+      def integer?
+        to_ruby.is_a?(Integer)
+      end
+
+      private
+
+      def prepare_hash_children
+        node.children.each_slice(2).flat_map do |key, value|
+          key = self.class.new(key, file, name)
+          value = self.class.new(value, file, key.to_ruby)
+          [key, value]
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/object_schema.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ObjectSchema < Schema # rubocop:disable Metrics/ClassLength
+      class << self
+        def inherit_attributes_from(schema, require_group: true, except: nil)
+          attributes_and_schemas_to_inherit_from << schema
+
+          inherit_except[schema] = Leftovers.each_or_self(except)
+
+          return if require_group
+
+          skip_require_group << schema
+        end
+
+        def attributes
+          nonexcluded_attributes = attributes_and_schemas_to_inherit_from.map do |attr_or_schema|
+            attr_or_schema.attributes.dup.tap do |attributes_copy|
+              inherit_except[attr_or_schema]&.each { |e| attributes_copy.delete(e) }
+            end
+          end
+
+          nonexcluded_attributes.reduce { |a, e| a.merge(e) { raise 'Duplicate attributes' } }
+        end
+
+        def aliases
+          attributes_and_schemas_to_inherit_from.map(&:aliases)
+            .reduce { |a, e| a.merge(e) { raise 'Duplicate aliases' } }
+        end
+
+        def require_groups
+          (attributes_and_schemas_to_inherit_from - skip_require_group)
+            .map(&:require_groups).each_with_object({}) do |require_groups, hash|
+              require_groups.each do |group, keys|
+                hash[group] ||= []
+                hash[group] += keys
+              end
+            end
+        end
+
+        attr_accessor :or_schema
+
+        def attribute(name, value_schema, aliases: nil, require_group: nil)
+          attributes_and_schemas_to_inherit_from << Attribute.new(
+            name,
+            value_schema,
+            aliases: aliases,
+            require_group: require_group
+          )
+        end
+
+        def validate(node)
+          if node.hash?
+            validate_attributes(node)
+          elsif or_schema
+            validate_or_schema(node)
+          else
+            validate_is_hash(node)
+          end
+        end
+
+        def to_ruby(node)
+          if node.hash?
+            node.pairs.map { |(key, value)| pair_to_ruby(key, value) }.to_h
+          else
+            or_schema.to_ruby(node)
+          end
+        end
+
+        private
+
+        def inherit_except
+          @inherit_except ||= {}
+        end
+
+        def skip_require_group
+          @skip_require_group ||= []
+        end
+
+        def attributes_and_schemas_to_inherit_from
+          @attributes_and_schemas_to_inherit_from ||= []
+        end
+
+        def pair_to_ruby(key, value)
+          key_sym = key.to_sym
+          key_sym = aliases[key_sym] || key_sym
+          key_sym = :unless_arg if key_sym == :unless
+          [key_sym, schema_for_attribute(key).to_ruby(value)]
+        end
+
+        def validate_attributes(node)
+          validate_attribute_keys(node) && validate_required_keys(node)
+          validate_alias_uniqueness_of_keys(node)
+          validate_valid_attribute_values(node)
+
+          node.children.all?(&:valid?)
+        end
+
+        def validate_or_schema(node)
+          or_schema.validate(node)
+          return true if node.valid?
+
+          if node.string? && valid_keys.include?(node.to_sym)
+            node.error = "#{node.name_}#{node.to_sym} must be a hash key"
+          else
+            node.error += " or a hash with any of #{attributes.keys.join(', ')}"
+          end
+        end
+
+        def validate_is_hash(node)
+          error(node, 'be a hash')
+          node.valid?
+        end
+
+        def validate_attribute_keys(node)
+          node.each_key { |key| validate_recognized_key(key, node) }
+          node.keys.all?(&:valid?)
+        end
+
+        def valid_keys
+          attributes.keys + aliases.keys
+        end
+
+        def validate_alias_uniqueness_of_keys(node)
+          node.keys.select(&:valid?)
+            .group_by { |key| aliases[key.to_sym] || key.to_sym }
+            .each_value do |keys|
+              next unless keys.length > 1
+
+              error_message_for_non_unique_keys(node, keys)
+            end
+        end
+
+        def error_message_for_non_unique_keys(node, keys)
+          keys.each do |key|
+            key.error = "#{node.name_}must only use one of #{keys.uniq.join(' or ')}"
+          end
+        end
+
+        def validate_recognized_key(key, node)
+          return true if valid_keys.include?(key.to_sym)
+
+          suggestions = suggestions_for_unrecognized_key(key, node)
+          did_you_mean = "\nDid you mean: #{suggestions.join(', ')}" unless suggestions.empty?
+          for_name = " for #{node.name}" if node.name
+
+          key.error = "unrecognized key #{key}#{for_name}#{did_you_mean}"
+
+          false
+        end
+
+        def suggester
+          @suggester ||= Suggester.new(attributes.keys)
+        end
+
+        def suggestions_for_unrecognized_key(key, node)
+          existing_keys = node.keys.flat_map { |k| [k.to_sym, aliases[k.to_sym]] }.compact
+          suggester.suggest(key.to_ruby) - existing_keys
+        end
+
+        def validate_required_keys(node)
+          missing_groups = require_groups.map do |_name, group|
+            next if node.keys.any? { |key| group.include?(key.to_sym) }
+
+            "include at least one of #{(attributes.keys & group).join(', ')}"
+          end.compact
+
+          error(node, missing_groups.join(' and ')) unless missing_groups.empty?
+
+          node.valid?
+        end
+
+        def schema_for_attribute(key)
+          key_sym = key.to_sym
+          attributes[key_sym] || attributes.fetch(aliases[key_sym])
+        end
+
+        def validate_valid_attribute_values(node)
+          node.pairs.each do |(key, value)|
+            next unless key.valid?
+
+            schema_for_attribute(key).validate(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/privacy_processor_schema.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrivacyProcessorSchema < ObjectSchema
+      inherit_attributes_from ValueProcessorSchema
+      attribute :to, PrivacySchema, require_group: :privacy_setting
+
+      self.or_schema = nil
+    end
+  end
+end

data/lib/leftovers/config_loader/privacy_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class PrivacySchema < StringEnumSchema
+      value :public
+      value :protected
+      value :private
+
+      def self.to_ruby(node)
+        super.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/require_schema.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RequireSchema < ObjectSchema
+      attribute :quiet, StringSchema, aliases: :name, require_group: :quiet
+
+      self.or_schema = StringSchema
+    end
+  end
+end

data/lib/leftovers/config_loader/rule_pattern_schema.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class RulePatternSchema < ObjectSchema
+      attribute :names, ValueOrArraySchema[StringPatternSchema], aliases: :name,
+        require_group: :matcher
+      attribute :paths, ValueOrArraySchema[StringSchema], aliases: :path, require_group: :matcher
+      attribute :document, TrueSchema, require_group: :matcher
+      attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
+        require_group: :matcher
+      attribute :has_receiver, ValueOrArraySchema[HasValueSchema], require_group: :matcher
+      attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
+      attribute :privacy, ValueOrArraySchema[PrivacySchema], require_group: :matcher
+      attribute :unless, ValueOrArraySchema[RulePatternSchema], require_group: :matcher
+    end
+  end
+end

data/lib/leftovers/config_loader/scalar_argument_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ScalarArgumentSchema < Schema
+      class << self
+        def validate(node)
+          error(node, 'be a string or an integer') unless node.string? || node.integer?
+          super
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/scalar_value_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class ScalarValueSchema < Schema
+      class << self
+        def validate(node)
+          error(node, 'be any scalar value') unless node.scalar?
+          super
+        end
+      end
+    end
+  end
+end