leftovers 0.11.1 → 0.12.0

data/lib/leftovers/collection.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Leftovers
+  class Collection
+    attr_reader :calls, :test_calls, :definitions
+
+    def initialize
+      @calls = []
+      @test_calls = []
+      @definitions = []
+    end
+
+    def leftovers
+      @leftovers ||= begin
+        freeze_calls
+
+        @definitions
+          .reject { |definition| definition.in_collection?(self) }
+          .sort_by(&:location_s).freeze
+      end
+    end
+
+    def with_tests
+      split_leftovers.first
+    end
+
+    def without_tests
+      split_leftovers[1]
+    end
+
+    def empty?
+      leftovers.empty?
+    end
+
+    def concat(calls:, definitions:, test:)
+      if test
+        @test_calls.concat(calls)
+      else
+        @calls.concat(calls)
+      end
+
+      @definitions.concat(definitions)
+    end
+
+    private
+
+    def split_leftovers
+      return @split_leftovers if defined?(@split_leftovers)
+
+      @split_leftovers = leftovers.partition do |definition|
+        !definition.test? && definition.in_test_collection?(self)
+      end.each(&:freeze).freeze
+
+      freeze
+
+      @split_leftovers
+    end
+
+    def freeze_calls
+      @calls = @calls.to_set.compare_by_identity.freeze
+      @test_calls = @test_calls.to_set.compare_by_identity.freeze
+    end
+  end
+end

data/lib/leftovers/collector.rb

@@ -1,34 +1,32 @@
 # frozen_string_literal: true
 
-require 'fast_ignore'
-require 'set'
 require 'parallel'
 
+require 'parser'
+require 'parser/current' # to get the error message early and once before we parallel things
+
 module Leftovers
   class Collector
-    attr_reader :calls, :test_calls, :definitions
+    attr_writer :progress, :parallel
+    attr_reader :collection
 
     def initialize
-      @calls = []
-      @test_calls = []
-      @definitions = []
       @count = 0
       @count_calls = 0
       @count_definitions = 0
+      @progress = true
+      @parallel = true
+      @collection ||= Collection.new
     end
 
     def collect
-      Leftovers.reporter.prepare
-      collect_file_list(Leftovers::FileList.new)
-      print_progress
-      Leftovers.newline
-      @calls = @calls.to_set.freeze
-      @test_calls = @test_calls.to_set.freeze
+      collect_file_list(FileList.new)
+      ::Leftovers.puts progress_message
     end
 
     def collect_file_list(list)
-      if Leftovers.parallel?
-        Parallel.each(list, finish: method(:finish_file)) do |file|
+      if @parallel
+        ::Parallel.each(list, finish: method(:finish_file)) do |file|
           collect_file(file)
         end
       else
@@ -37,31 +35,23 @@ module Leftovers
     end
 
     def collect_file(file)
-      file_collector = ::Leftovers::FileCollector.new(file.ruby, file)
+      file_collector = FileCollector.new(file.ruby, file)
       file_collector.collect
 
       file_collector.to_h
     end
 
-    def print_progress
-      Leftovers.print(
-        "\e[2Kchecked #{@count} files, " \
-          "collected #{@count_calls} calls, #{@count_definitions} definitions\r"
-      )
+    def progress_message
+      "checked #{@count} files, collected #{@count_calls} calls, #{@count_definitions} definitions"
     end
 
     def finish_file(_item, _index, result)
       @count += 1
       @count_calls += result[:calls].length
       @count_definitions += result[:definitions].length
-      print_progress if Leftovers.progress?
-      if result[:test?]
-        @test_calls.concat(result[:calls])
-      else
-        @calls.concat(result[:calls])
-      end
+      ::Leftovers.print(progress_message) if @progress
 
-      @definitions.concat(result[:definitions])
+      @collection.concat(**result)
     end
   end
 end

data/lib/leftovers/config.rb

@@ -3,6 +3,18 @@
 module Leftovers
   class Config
     attr_reader :name
+    alias_method :to_sym, :name
+
+    def self.[](name_or_config)
+      return name_or_config if name_or_config.is_a?(self)
+
+      @loaded_configs ||= {}
+      @loaded_configs[name_or_config] ||= new(name_or_config)
+    end
+
+    def self.reset
+      @loaded_configs = {}
+    end
 
     def initialize(name, path: nil, content: nil)
       @name = name.to_sym
@@ -27,19 +39,19 @@ module Leftovers
     end
 
     def precompile
-      @precompile ||= Leftovers.each_or_self(yaml[:precompile]).to_a
+      @precompile ||= ::Leftovers.wrap_array(yaml[:precompile])
     end
 
     def dynamic
-      @dynamic ||= ::Leftovers::ProcessorBuilders::Dynamic.build(yaml[:dynamic])
+      @dynamic ||= ProcessorBuilders::Dynamic.build(yaml[:dynamic])
     end
 
     def keep
-      @keep ||= ::Leftovers::MatcherBuilders::Node.build(yaml[:keep])
+      @keep ||= MatcherBuilders::Node.build(yaml[:keep])
     end
 
     def test_only
-      @test_only ||= ::Leftovers::MatcherBuilders::Node.build(yaml[:test_only])
+      @test_only ||= MatcherBuilders::Node.build(yaml[:test_only])
     end
 
     def requires
@@ -49,7 +61,7 @@ module Leftovers
     private
 
     def yaml
-      @yaml ||= ::Leftovers::ConfigLoader.load(name, path: @path, content: @content)
+      @yaml ||= ConfigLoader.load(name, path: @path, content: @content)
     end
   end
 end

data/lib/leftovers/config_loader/attribute.rb

@@ -13,7 +13,7 @@ module Leftovers
       def initialize(name, schema, aliases: nil, require_group: nil, suggest: true)
         @name = name
         @schema = schema
-        @aliases = aliases
+        @aliases = Array(aliases)
         @require_group = require_group
         @suggest = suggest
       end
@@ -35,7 +35,7 @@ module Leftovers
       def name?(name)
         name = name.to_sym
 
-        @name == name || Leftovers.each_or_self(@aliases).include?(name)
+        @name == name || @aliases.include?(name)
       end
 
       def to_ruby(value)

data/lib/leftovers/config_loader/bool_schema.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class ConfigLoader
+    class BoolSchema < Schema
+      class << self
+        def validate(node)
+          error(node, 'be true or false') if to_ruby(node).nil?
+          super
+        end
+
+        def to_ruby(node)
+          case node.to_ruby
+          when true, 'true' then true
+          when false, 'false' then false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/config_loader/document_schema.rb

@@ -31,13 +31,13 @@ module Leftovers
           yaml = { 'precompile' => [value.transform_keys(&:to_s).transform_values(&:to_s)] }
             .to_yaml.delete_prefix("---\n")
 
-          Leftovers.warn(<<~MESSAGE)
+          ::Leftovers.warn(<<~MESSAGE)
             \e[33m`#{key}:` is deprecated\e[0m
             Replace with:
             \e[32m#{yaml}\e[0m
           MESSAGE
 
-          write_hash[:precompile] = Leftovers.each_or_self(write_hash[:precompile]).to_a
+          write_hash[:precompile] = ::Leftovers.wrap_array(write_hash[:precompile])
           write_hash[:precompile] << value
           write_hash.delete(key)
         end

data/lib/leftovers/config_loader/inherit_schema_attributes.rb

@@ -6,7 +6,7 @@ module Leftovers
       def initialize(schema, require_group: true, except: nil)
         @schema = schema
         @use_require_groups = require_group
-        @except = Leftovers.each_or_self(except)
+        @except = Array(except)
       end
 
       def attributes

data/lib/leftovers/config_loader/node.rb

@@ -3,9 +3,9 @@
 module Leftovers
   class ConfigLoader
     class Node
-      class_loader = Psych::ClassLoader::Restricted.new([], [])
-      ToRuby = Psych::Visitors::ToRuby.new(
-        Psych::ScalarScanner.new(class_loader),
+      class_loader = ::Psych::ClassLoader::Restricted.new([], [])
+      TO_RUBY_INSTANCE = ::Psych::Visitors::ToRuby.new(
+        ::Psych::ScalarScanner.new(class_loader),
         class_loader
       )
 
@@ -39,7 +39,7 @@ module Leftovers
       end
 
       def hash?
-        node.is_a?(Psych::Nodes::Mapping)
+        node.is_a?(::Psych::Nodes::Mapping)
       end
 
       def location
@@ -69,7 +69,7 @@ module Leftovers
       end
 
       def to_ruby
-        @to_ruby ||= ToRuby.accept(node)
+        @to_ruby ||= TO_RUBY_INSTANCE.accept(node)
       end
 
       def to_sym
@@ -77,7 +77,7 @@ module Leftovers
       end
 
       def string?
-        to_ruby.is_a?(String)
+        to_ruby.is_a?(::String)
       end
 
       def scalar?
@@ -85,11 +85,11 @@ module Leftovers
       end
 
       def array?
-        node.is_a?(Psych::Nodes::Sequence)
+        node.is_a?(::Psych::Nodes::Sequence)
       end
 
       def integer?
-        to_ruby.is_a?(Integer)
+        to_ruby.is_a?(::Integer)
       end
 
       private

data/lib/leftovers/config_loader/regexp_schema.rb

@@ -16,7 +16,7 @@ module Leftovers
 
         def validate_regexp(node)
           /#{node.to_ruby}/
-        rescue RegexpError, ArgumentError => e
+        rescue ::RegexpError, ::ArgumentError => e
           error(node, "be a string with a valid ruby regexp (#{e.message})")
         else
           true

data/lib/leftovers/config_loader/rule_pattern_schema.rb

@@ -10,6 +10,7 @@ module Leftovers
       attribute :has_arguments, ValueOrArraySchema[HasArgumentSchema], aliases: :has_argument,
         require_group: :matcher
       attribute :has_receiver, ValueOrArraySchema[HasReceiverSchema], require_group: :matcher
+      attribute :has_block, BoolSchema, require_group: :matcher
       attribute :type, ValueOrArraySchema[ValueTypeSchema], require_group: :matcher
       attribute :privacy, ValueOrArraySchema[PrivacySchema], require_group: :matcher
       attribute :unless, ValueOrArraySchema[RulePatternSchema], require_group: :matcher

data/lib/leftovers/config_loader/schema.rb

@@ -20,7 +20,7 @@ module Leftovers
 
         def ===(other) # leftovers:test_only
           # :nocov:
-          if other.is_a?(Module)
+          if other.is_a?(::Module)
             self >= other
           else
             other.is_a?(self)

data/lib/leftovers/config_loader/string_enum_schema.rb

@@ -6,7 +6,7 @@ module Leftovers
       class << self
         def value(value, aliases: nil)
           values << value
-          Leftovers.each_or_self(aliases) do |alias_name|
+          Array(aliases).each do |alias_name|
             self.aliases[alias_name] = value
           end
         end

data/lib/leftovers/config_loader/value_or_array_schema.rb

@@ -13,7 +13,7 @@ module Leftovers
 
       def to_ruby(node)
         if node.array?
-          Leftovers.unwrap_array(super)
+          ::Leftovers.unwrap_array(super)
         else
           value_schema.to_ruby(node)
         end

data/lib/leftovers/config_loader.rb

@@ -1,50 +1,10 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 require 'yaml'
 
 module Leftovers
   class ConfigLoader
-    autoload(:ArgumentlessTransformSchema, "#{__dir__}/config_loader/argumentless_transform_schema")
-    autoload(:ArgumentPositionSchema, "#{__dir__}/config_loader/argument_position_schema")
-    autoload(:ArraySchema, "#{__dir__}/config_loader/array_schema")
-    autoload(:Attribute, "#{__dir__}/config_loader/attribute")
-    autoload(:BuiltInPrecompilerSchema, "#{__dir__}/config_loader/built_in_precompiler_schema")
-    autoload(:DocumentSchema, "#{__dir__}/config_loader/document_schema")
-    autoload(:DynamicSchema, "#{__dir__}/config_loader/dynamic_schema")
-    autoload(:HasArgumentSchema, "#{__dir__}/config_loader/has_argument_schema")
-    autoload(:HasValueSchema, "#{__dir__}/config_loader/has_value_schema")
-    autoload(:HasReceiverSchema, "#{__dir__}/config_loader/has_receiver_schema")
-    autoload(:InheritSchemaAttributes, "#{__dir__}/config_loader/inherit_schema_attributes")
-    autoload(:KeepTestOnlySchema, "#{__dir__}/config_loader/keep_test_only_schema")
-    autoload(:KeywordArgumentSchema, "#{__dir__}/config_loader/keyword_argument_schema")
-    autoload(:Node, "#{__dir__}/config_loader/node")
-    autoload(:ObjectSchema, "#{__dir__}/config_loader/object_schema")
-    autoload(:PrecompilerSchema, "#{__dir__}/config_loader/precompiler_schema")
-    autoload(:PrecompileSchema, "#{__dir__}/config_loader/precompile_schema")
-    autoload(:PrivacyProcessorSchema, "#{__dir__}/config_loader/privacy_processor_schema")
-    autoload(:PrivacySchema, "#{__dir__}/config_loader/privacy_schema")
-    autoload(:RegexpSchema, "#{__dir__}/config_loader/regexp_schema")
-    autoload(:RequireSchema, "#{__dir__}/config_loader/require_schema")
-    autoload(:RulePatternSchema, "#{__dir__}/config_loader/rule_pattern_schema")
-    autoload(:ScalarArgumentSchema, "#{__dir__}/config_loader/scalar_argument_schema")
-    autoload(:ScalarValueSchema, "#{__dir__}/config_loader/scalar_value_schema")
-    autoload(:Schema, "#{__dir__}/config_loader/schema")
-    autoload(:StringEnumSchema, "#{__dir__}/config_loader/string_enum_schema")
-    autoload(:StringPatternSchema, "#{__dir__}/config_loader/string_pattern_schema")
-    autoload(:StringSchema, "#{__dir__}/config_loader/string_schema")
-    autoload(:StringValueProcessorSchema, "#{__dir__}/config_loader/string_value_processor_schema")
-    autoload(:Suggester, "#{__dir__}/config_loader/suggester")
-    autoload(:TransformSchema, "#{__dir__}/config_loader/transform_schema")
-    autoload(:TrueSchema, "#{__dir__}/config_loader/true_schema")
-    autoload(
-      :ValueMatcherConditionSchema,
-      "#{__dir__}/config_loader/value_matcher_condition_schema"
-    )
-    autoload(:ValueMatcherSchema, "#{__dir__}/config_loader/value_matcher_schema")
-    autoload(:ValueOrArraySchema, "#{__dir__}/config_loader/value_or_array_schema")
-    autoload(:ValueOrObjectSchema, "#{__dir__}/config_loader/value_or_object_schema")
-    autoload(:ValueProcessorSchema, "#{__dir__}/config_loader/value_processor_schema")
-    autoload(:ValueTypeSchema, "#{__dir__}/config_loader/value_type_schema")
+    include Autoloader
 
     def self.load(name, path: nil, content: nil)
       new(name, path: path, content: content).load
@@ -59,13 +19,13 @@ module Leftovers
     end
 
     def load
-      document = ::Leftovers::ConfigLoader::Node.new(parse, file)
+      document = Node.new(parse, file)
       DocumentSchema.validate(document)
 
       all_errors = document.all_errors
       return DocumentSchema.to_ruby(document) if all_errors.empty?
 
-      Leftovers.error(all_errors.join("\n"))
+      ::Leftovers.error(all_errors.join("\n"))
     end
 
     private
@@ -75,7 +35,7 @@ module Leftovers
     end
 
     def file
-      @file ||= ::Leftovers::File.new(path)
+      @file ||= File.new(path)
     end
 
     def content
@@ -83,12 +43,12 @@ module Leftovers
     end
 
     def parse
-      parsed = Psych.parse(content)
-      parsed ||= Psych.parse('{}')
+      parsed = ::Psych.parse(content)
+      parsed ||= ::Psych.parse('{}')
       parsed.children.first
     rescue ::Psych::SyntaxError => e
       message = [e.problem, e.context].compact.join(' ')
-      Leftovers.error "Config SyntaxError: #{file.relative_path}:#{e.line}:#{e.column} #{message}"
+      ::Leftovers.error "Config SyntaxError: #{file.relative_path}:#{e.line}:#{e.column} #{message}"
     end
   end
 end

data/lib/leftovers/definition.rb

@@ -34,12 +34,12 @@ module Leftovers
         @source_line[@location_column_range_end..-1].rstrip
     end
 
-    def in_collection?
-      Leftovers.collector.calls.include?(@name) || (@test && in_test_collection?)
+    def in_collection?(collection)
+      collection.calls.include?(@name) || (@test && in_test_collection?(collection))
     end
 
-    def in_test_collection?
-      Leftovers.collector.test_calls.include?(@name)
+    def in_test_collection?(collection)
+      collection.test_calls.include?(@name)
     end
   end
 end

data/lib/leftovers/definition_collection.rb

@@ -12,12 +12,12 @@ module Leftovers
     end
 
     def add(node, name: node.name, loc: node.loc.name)
-      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+      @definitions_to_add[name] = DefinitionToAdd.new(node, name: name, location: loc)
     end
 
     def add_definition_set(definition_node_set)
       @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
-        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
+        DefinitionToAdd.new(definition_node, location: definition_node.loc)
       end
     end
 
@@ -30,7 +30,7 @@ module Leftovers
         @definition_sets_to_add.map do |definition_set|
           next if definition_set.any? { |d| d.keep?(file_collector) }
 
-          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(file_collector) })
+          DefinitionSet.new(definition_set.map { |d| d.to_definition(file_collector) })
         end
     end
   end

data/lib/leftovers/definition_node.rb

@@ -1,7 +1,7 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
-  class DefinitionNode < ::Leftovers::AST::Node
+  class DefinitionNode < AST::Node
     attr_reader :name, :path
     alias_method :to_sym, :name
 

data/lib/leftovers/definition_node_set.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   class DefinitionNodeSet

data/lib/leftovers/definition_set.rb

@@ -26,16 +26,16 @@ module Leftovers
       @definitions.first.highlighted_source(*args)
     end
 
-    def in_collection?
-      @definitions.any?(&:in_collection?)
+    def in_collection?(collection)
+      @definitions.any? { |d| d.in_collection?(collection) }
     end
 
     def test?
       @definitions.any?(&:test?)
     end
 
-    def in_test_collection?
-      @definitions.any?(&:in_test_collection?)
+    def in_test_collection?(collection)
+      @definitions.any? { |d| d.in_test_collection?(collection) }
     end
   end
 end

data/lib/leftovers/definition_to_add.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   class DefinitionToAdd
@@ -25,7 +25,7 @@ module Leftovers
     def to_definition(file_collector)
       return if keep?(file_collector)
 
-      Leftovers::Definition.new(name, location: location, test: test?(file_collector))
+      Definition.new(name, location: location, test: test?(file_collector))
     end
   end
 end

data/lib/leftovers/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class Error < ::StandardError
+  end
+end

data/lib/leftovers/file.rb

@@ -3,11 +3,11 @@
 require 'pathname'
 
 module Leftovers
-  class File < Pathname
+  class File < ::Pathname
     def relative_path
       @relative_path ||= begin
-        relative_path_from(Leftovers.pwd)
-      rescue ArgumentError
+        relative_path_from(::Leftovers.pwd)
+      rescue ::ArgumentError
         self
       end
     end
@@ -15,7 +15,7 @@ module Leftovers
     def test?
       return @test if defined?(@test)
 
-      @test = Leftovers.config.test_paths === relative_path
+      @test = ::Leftovers.config.test_paths === relative_path
     end
 
     def ruby

data/lib/leftovers/file_collector/comments_processor.rb

@@ -1,21 +1,8 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   class FileCollector
     module CommentsProcessor
-      METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
-      NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
-        []= [] ** ~ +@ -@ * / % + - >> << &
-        ^ | <=> <= >= < > === == != =~ !~ !
-      }.map { |op| /#{Regexp.escape(op)}/ })
-      CONSTANT_NAME_RE = /[[:upper:]][[:alnum:]_]*\b/.freeze
-      NAME_RE = Regexp.union(METHOD_NAME_RE, NON_ALNUM_METHOD_NAME_RE, CONSTANT_NAME_RE)
-      NAME_LIST_RE = /#{NAME_RE}(?:[, :]+#{NAME_RE})*/.freeze
-      LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|e(?:d|rs?))? (#{NAME_LIST_RE})/.freeze
-      LEFTOVERS_ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
-      LEFTOVERS_TEST_RE = /\bleftovers:(?:for_tests?|tests?|testing|test_only)\b/.freeze
-      LEFTOVERS_DYNAMIC_RE = /\bleftovers:dynamic[: ](#{NAME_LIST_RE})/.freeze
-
       class << self
         def process(comments, collector)
           comments.each do |comment|
@@ -26,27 +13,45 @@ module Leftovers
           end
         end
 
+        private
+
+        method_name_re = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
+        non_alnum_method_name_re = ::Regexp.union(%w{
+          []= [] ** ~ +@ -@ * / % + - >> << &
+          ^ | <=> <= >= < > === == != =~ !~ !
+        }.map { |op| /#{::Regexp.escape(op)}/ })
+        constant_name_re = /[[:upper:]][[:alnum:]_]*\b/.freeze
+        NAME_RE = ::Regexp.union(method_name_re, non_alnum_method_name_re, constant_name_re)
+        name_list_re = /#{NAME_RE}(?:[, :]+#{NAME_RE})*/o.freeze
+
+        CALL_RE = /\bleftovers:call(?:s|e(?:d|rs?))? (#{name_list_re})/.freeze
+        ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
+        TEST_ONLY_RE = /\bleftovers:(?:for_tests?|tests?|testing|test_only)\b/.freeze
+        DYNAMIC_RE = /\bleftovers:dynamic[: ](#{name_list_re})/.freeze
+
+        private_constant :NAME_RE, :CALL_RE, :ALLOW_RE, :TEST_ONLY_RE, :DYNAMIC_RE
+
         def process_leftovers_keep_comment(comment, collector)
-          return unless comment.text.match?(LEFTOVERS_ALLOW_RE)
+          return unless comment.text.match?(ALLOW_RE)
 
           collector.allow_lines << comment.loc.line
         end
 
         def process_leftovers_test_comment(comment, collector)
-          return unless comment.text.match?(LEFTOVERS_TEST_RE)
+          return unless comment.text.match?(TEST_ONLY_RE)
 
           collector.test_lines << comment.loc.line
         end
 
         def process_leftovers_dynamic_comment(comment, collector)
-          match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
+          match = comment.text.match(DYNAMIC_RE)
           return unless match
 
           collector.dynamic_lines[comment.loc.line] = match[1].scan(NAME_RE)
         end
 
         def process_leftovers_call_comment(comment, collector)
-          match = comment.text.match(LEFTOVERS_CALL_RE)
+          match = comment.text.match(CALL_RE)
           return unless match
 
           match[1].scan(NAME_RE).each { |s| collector.calls << s.to_sym }