lib/leftovers.rb in leftovers-0.11.1 vs lib/leftovers.rb in leftovers-0.11.2

@@ -1,155 +1,64 @@
 # frozen_string_literal: true
 
-require 'parser'
-require 'parser/current' # to get the error message early and once.
+module Leftovers
+  require_relative 'leftovers/autoloader'
+  include Autoloader
 
-module Leftovers # rubocop:disable Metrics/ModuleLength
-  class Error < ::StandardError; end
-  class UnexpectedCase < Error; end
-
-  class PrecompileError < Error
-    attr_reader :line, :column
-
-    def initialize(message, line: nil, column: nil)
-      @line = line
-      @column = column
-      super(message)
-    end
-
-    def warn(path:)
-      line_column = ":#{line}#{":#{column}" if column}" if line
-      klass = cause ? cause.class : self.class
-
-      Leftovers.warn "#{klass}: #{path}#{line_column} #{message}"
-    end
-  end
-
-  autoload(:AST, "#{__dir__}/leftovers/ast")
-  autoload(:CLI, "#{__dir__}/leftovers/cli")
-  autoload(:Collector, "#{__dir__}/leftovers/collector")
-  autoload(:ComparableInstance, "#{__dir__}/leftovers/comparable_instance")
-  autoload(:ConfigLoader, "#{__dir__}/leftovers/config_loader")
-  autoload(:Config, "#{__dir__}/leftovers/config")
-  autoload(:Definition, "#{__dir__}/leftovers/definition")
-  autoload(:DefinitionCollection, "#{__dir__}/leftovers/definition_collection")
-  autoload(:DefinitionNode, "#{__dir__}/leftovers/definition_node")
-  autoload(:DefinitionNodeSet, "#{__dir__}/leftovers/definition_node_set")
-  autoload(:DefinitionSet, "#{__dir__}/leftovers/definition_set")
-  autoload(:DefinitionToAdd, "#{__dir__}/leftovers/definition_to_add")
-  autoload(:FileCollector, "#{__dir__}/leftovers/file_collector")
-  autoload(:FileList, "#{__dir__}/leftovers/file_list")
-  autoload(:File, "#{__dir__}/leftovers/file")
-  autoload(:MatcherBuilders, "#{__dir__}/leftovers/matcher_builders")
-  autoload(:Matchers, "#{__dir__}/leftovers/matchers")
-  autoload(:MergedConfig, "#{__dir__}/leftovers/merged_config")
-  autoload(:Parser, "#{__dir__}/leftovers/parser")
-  autoload(:Precompilers, "#{__dir__}/leftovers/precompilers")
-  autoload(:ProcessorBuilders, "#{__dir__}/leftovers/processor_builders")
-  autoload(:RakeTask, "#{__dir__}/leftovers/rake_task")
-  autoload(:Reporter, "#{__dir__}/leftovers/reporter")
-  autoload(:TodoReporter, "#{__dir__}/leftovers/todo_reporter")
-  autoload(:Processors, "#{__dir__}/leftovers/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
-    alias_method :parallel?, :parallel
-    alias_method :progress?, :progress
+    attr_writer :stdout, :stderr
 
     def stdout
-      @stdout ||= $stdout
+      @stdout ||= ::StringIO.new
     end
 
     def stderr
-      @stderr ||= $stderr
+      @stderr ||= ::StringIO.new
     end
 
     def config
-      @config ||= Leftovers::MergedConfig.new(load_defaults: true)
+      @config ||= MergedConfig.new(load_defaults: true)
     end
 
-    def collector
-      @collector ||= Leftovers::Collector.new
-    end
-
-    def reporter
-      @reporter ||= Leftovers::Reporter.new
-    end
-
-    def leftovers
-      @leftovers ||= begin
-        collector.collect
-        collector.definitions.reject(&:in_collection?)
-      end
-    end
-
-    def run(stdout: StringIO.new, stderr: StringIO.new) # rubocop:disable Metrics/MethodLength
-      @stdout = stdout
-      @stderr = stderr
-      return reporter.report_success if leftovers.empty?
-
-      only_test = []
-      none = []
-      leftovers.sort_by(&:location_s).each do |definition|
-        if !definition.test? && definition.in_test_collection?
-          only_test << definition
-        else
-          none << definition
-        end
-      end
-
-      reporter.report(only_test: only_test, none: none)
-    end
-
     def reset
       MEMOIZED_IVARS.each do |ivar|
         remove_instance_variable(ivar) if instance_variable_get(ivar)
       end
     end
 
     def resolution_instructions_link
-      "https://github.com/robotdana/leftovers/tree/v#{Leftovers::VERSION}/README.md#how-to-resolve"
+      "https://github.com/robotdana/leftovers/tree/v#{VERSION}/README.md#how-to-resolve"
     end
 
     def warn(message)
       stderr.puts("\e[2K#{message}")
     end
 
-    def error(message)
+    def error(message, did_you_mean = nil)
       warn("\e[31m#{message}\e[0m")
+      warn("\n#{did_you_mean}") if did_you_mean
       exit 1
     end
 
     def puts(message)
       stdout.puts("\e[2K#{message}")
     end
 
     def print(message)
-      stdout.print(message)
+      stdout.print("\e[2K#{message}\r")
     end
 
-    def newline
-      stdout.puts('')
-    end
-
     def pwd
-      @pwd ||= Pathname.new(Dir.pwd + '/')
+      @pwd ||= ::Pathname.new(::Dir.pwd + '/')
     end
 
     def exit(status = 0)
       throw :leftovers_exit, status
     end
@@ -157,17 +66,15 @@
     def try_require(requirable, message: nil)
       warn message if !try_require_cache(requirable) && message
       try_require_cache(requirable)
     end
 
-    def each_or_self(value, &block)
-      return enum_for(__method__, value) unless block
-
+    def wrap_array(value)
       case value
-      when nil then nil
-      when Array then value.each(&block)
-      else yield(value)
+      when nil then []
+      when ::Array then value
+      else [value]
       end
     end
 
     def unwrap_array(array)
       if array.length <= 1
@@ -183,10 +90,10 @@
       @try_require_cache ||= {}
 
       @try_require_cache.fetch(requirable) do
         require requirable
         @try_require_cache[requirable] = true
-      rescue LoadError
+      rescue ::LoadError
         @try_require_cache[requirable] = false
       end
     end
   end
 end