leftovers 0.5.5 → 0.8.0

data/lib/leftovers/processor_builders/transform_set.rb

@@ -3,43 +3,47 @@
 module Leftovers
   module ProcessorBuilders
     module TransformSet
-      def self.build(transforms, action)
-        each_builder(action).each_or_self(transforms) do |transform|
-          case transform
-          when ::Hash
-            next build(transform[:transforms], action) if transform[:transforms]
+      class << self
+        def build(transforms, action)
+          each_builder(action).each_or_self(transforms) do |transform|
+            case transform
+            when ::Hash
+              next build(transform[:transforms], action) if transform[:transforms]
 
-            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
-          when ::String
-            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
-          # :nocov:
-          else raise
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
+            when ::String
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.each_builder(action)
-        case action
-        when :call
-          ::Leftovers::ProcessorBuilders::Each
-        when :define
-          ::Leftovers::ProcessorBuilders::EachForDefinitionSet
-        # :nocov:
-        else raise
+        def build_final(action)
+          case action
+          when :sym
+            ::Leftovers::ValueProcessors::ReturnSym
+          when :definition_node
+            ::Leftovers::ValueProcessors::ReturnDefinitionNode
           # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{action.inspect}"
+            # :nocov:
+          end
         end
-      end
 
-      def self.build_final(action)
-        case action
-        when :call
-          ::Leftovers::ValueProcessors::ReturnString
-        when :define
-          ::Leftovers::ValueProcessors::ReturnDefinition
-        # :nocov:
-        else raise
+        private
+
+        def each_builder(action)
+          case action
+          when :sym
+            ::Leftovers::ProcessorBuilders::Each
+          when :definition_node
+            ::Leftovers::ProcessorBuilders::EachForDefinitionSet
           # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{action.inspect}"
+            # :nocov:
+          end
         end
       end
     end

data/lib/leftovers/rake_task.rb

@@ -8,7 +8,7 @@ module Leftovers
   class RakeTask
     include ::Rake::DSL
 
-    def self.generate_task(name = :leftovers, *default_argv) # rubocop:disable
+    def self.generate_task(name = :leftovers, *default_argv)
       new(name, default_argv)
 
       name

data/lib/leftovers/todo_reporter.rb

@@ -64,54 +64,29 @@ module Leftovers
     end
 
     def todo_data(only_test, none)
-      none_test = none.select(&:test?)
-      none_non_test = none.reject(&:test?)
       [
-        test_only_data(none_test),
-        keep_data(only_test, none_non_test)
+        list_data(
+          :test_only, 'Only directly called in tests', only_test
+        ),
+        list_data(
+          :keep, 'Not directly called at all', none
+        )
       ].compact.join
     end
 
-    def test_only_data(list)
+    def list_data(key, title, list)
       return if list.empty?
 
       <<~YML
-        test_only:
-        #{generate_list('Defined in tests:', list).chomp}
-      YML
-    end
-
-    def keep_data(only_test, none_non_test)
-      return if only_test.empty? && none_non_test.empty?
-
-      <<~YML.chomp
-        keep:
-        #{keep_test_called_data(only_test)}#{keep_never_called_data(none_non_test)}
-      YML
-    end
-
-    def keep_test_called_data(list)
-      return if list.empty?
-
-      generate_list('Only directly called in tests:', list)
-    end
-
-    def keep_never_called_data(list)
-      return if list.empty?
-
-      generate_list('Not directly called at all:', list)
-    end
-
-    def generate_list(title, list)
-      <<~YML
-          # #{title}
+        #{key}:
+          # #{title}:
         #{print_definition_list(list)}
 
       YML
     end
 
     def print_definition_list(definition_list)
-      definition_list.map { |definition| print_definition(definition) }.join("\n")
+      definition_list.map { |definition| print_definition(definition) }.sort.join("\n")
     end
 
     def print_definition(definition)

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -10,20 +10,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+      def process(str, node, method_node)
         return unless str
 
         prefixes = @prefix_processor.process(nil, method_node, method_node)
-        if prefixes.is_a?(Array)
-          prefixes.flatten!
-          prefixes.compact!
-          prefixes.uniq!
 
-          prefixes.map do |prefix|
-            @then_processor.process("#{prefix}#{str}", node, method_node)
-          end
-        else
-          @then_processor.process("#{prefixes}#{str}", node, method_node)
+        Leftovers.map_or_self(prefixes) do |prefix|
+          @then_processor.process("#{prefix}#{str}", node, method_node)
         end
       end
     end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -10,20 +10,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+      def process(str, node, method_node)
         return unless str
 
         suffixes = @suffix_processor.process(nil, method_node, method_node)
-        if suffixes.is_a?(Array)
-          suffixes.flatten!
-          suffixes.compact!
-          suffixes.uniq!
 
-          suffixes.map do |suffix|
-            @then_processor.process("#{str}#{suffix}", node, method_node)
-          end
-        else
-          @then_processor.process("#{str}#{suffixes}", node, method_node)
+        Leftovers.map_or_self(suffixes) do |suffix|
+          @then_processor.process("#{str}#{suffix}", node, method_node)
         end
       end
     end

data/lib/leftovers/value_processors/delete_prefix.rb

@@ -3,12 +3,6 @@
 module Leftovers
   module ValueProcessors
     class DeletePrefix
-      # :nocov:
-      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
-        using ::Leftovers::Backports::StringDeletePrefixSuffix
-      end
-      # :nocov:
-
       def initialize(prefix, then_processor)
         @prefix = prefix
         @then_processor = then_processor

data/lib/leftovers/value_processors/delete_suffix.rb

@@ -3,12 +3,6 @@
 module Leftovers
   module ValueProcessors
     class DeleteSuffix
-      # :nocov:
-      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
-        using ::Leftovers::Backports::StringDeletePrefixSuffix
-      end
-      # :nocov:
-
       def initialize(suffix, then_processor)
         @suffix = suffix
         @then_processor = then_processor

data/lib/leftovers/value_processors/each.rb

@@ -12,7 +12,7 @@ module Leftovers
       end
 
       def process(str, node, method_node)
-        @processors.flat_map do |processor|
+        Leftovers.map_or_self(@processors) do |processor|
           processor.process(str, node, method_node)
         end
       end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -10,19 +10,13 @@ module Leftovers
       end
 
       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
+        definitions = Leftovers.map_or_self(@then_processors) do |then_processor|
+          then_processor.process(str, node, method_node)
         end
 
-        definitions.flatten!
-        definitions.compact!
-
-        return definitions.first if definitions.length <= 1
+        return definitions unless definitions.is_a?(Array)
 
-        ::Leftovers::DefinitionSet.new(definitions)
+        ::Leftovers::DefinitionNodeSet.new(definitions)
       end
     end
   end

data/lib/leftovers/value_processors/each_keyword.rb

@@ -13,7 +13,7 @@ module Leftovers
         kwargs = node.kwargs
         return unless kwargs
 
-        kwargs.children.map do |pair|
+        Leftovers.map_or_self(kwargs.children) do |pair|
           next unless pair.type == :pair
 
           argument_node = pair.first

data/lib/leftovers/value_processors/each_keyword_argument.rb

@@ -13,7 +13,7 @@ module Leftovers
         kwargs = node.kwargs
         return unless kwargs
 
-        kwargs.children.map do |pair|
+        Leftovers.map_or_self(kwargs.children) do |pair|
           next unless pair.type == :pair
 
           argument_node = pair.second

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -11,10 +11,11 @@ module Leftovers
 
       def process(_str, node, method_node)
         positional_arguments = node.positional_arguments
+
         return unless positional_arguments
 
-        positional_arguments.map do |argument_node|
-          str = argument_node.to_s if argument_node.string_or_symbol?
+        Leftovers.map_or_self(positional_arguments) do |argument_node|
+          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/keyword.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module ValueProcessors
     class Keyword
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, then_processor)
         @matcher = matcher
         @then_processor = then_processor
@@ -18,18 +14,14 @@ module Leftovers
         kwargs = node.kwargs
         return unless kwargs
 
-        result = []
-
-        kwargs.children.each do |pair|
+        Leftovers.map_or_self(kwargs.children) do |pair|
           next unless @matcher === pair
 
           argument_node = pair.first
-          str = argument_node.to_s
+          str = argument_node.to_s if argument_node.string_or_symbol?
 
-          result << @then_processor.process(str, argument_node, method_node)
+          @then_processor.process(str, argument_node, method_node)
         end
-
-        result
       end
     end
   end

data/lib/leftovers/value_processors/keyword_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module ValueProcessors
     class KeywordArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(matcher, then_processor)
         @matcher = matcher
         @then_processor = then_processor
@@ -18,18 +14,14 @@ module Leftovers
         kwargs = node.kwargs
         return unless kwargs
 
-        result = []
-
-        kwargs.children.each do |pair|
+        Leftovers.map_or_self(kwargs.children) do |pair|
           next unless @matcher === pair
 
           argument_node = pair.second
           str = argument_node.to_s if argument_node.string_or_symbol?
 
-          result << @then_processor.process(str, argument_node, method_node)
+          @then_processor.process(str, argument_node, method_node)
         end
-
-        result
       end
     end
   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/split.rb

@@ -13,8 +13,8 @@ module Leftovers
       def process(str, node, method_node)
         return unless str
 
-        str.split(@split_on).map do |substring|
-          @then_processor.process(substring, node, method_node)
+        Leftovers.map_or_self(str.split(@split_on)) do |sub_str|
+          @then_processor.process(sub_str, node, method_node)
         end
       end
     end

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.5.5'
+  VERSION = '0.8.0'
 end

data/lib/leftovers.rb

@@ -1,35 +1,68 @@
 # frozen_string_literal: true
 
+require 'parser'
+require 'parser/current' # to get the error message early and once.
+
 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(:Backports, "#{__dir__}/leftovers/backports")
   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(:ERB, "#{__dir__}/leftovers/erb")
+  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(:Haml, "#{__dir__}/leftovers/haml")
   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(:Slim, "#{__dir__}/leftovers/slim")
   autoload(:TodoReporter, "#{__dir__}/leftovers/todo_reporter")
   autoload(:DynamicProcessors, "#{__dir__}/leftovers/dynamic_processors")
   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
@@ -81,16 +114,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
@@ -102,7 +129,7 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
     end
 
     def error(message)
-      warn(message)
+      warn("\e[31m#{message}\e[0m")
       exit 1
     end
 
@@ -141,18 +168,34 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
       end
     end
 
+    def map_or_self(value, &block)
+      # return enum_for(__method__, value) unless block
+
+      case value
+      when nil then nil
+      when Array then unwrap_array(value.flat_map(&block).compact)
+      else yield(value)
+      end
+    end
+
+    def unwrap_array(array)
+      if array.length <= 1
+        array.first
+      else
+        array
+      end
+    end
+
     private
 
     def try_require_cache(requirable)
       @try_require_cache ||= {}
 
       @try_require_cache.fetch(requirable) do
-        begin
-          require requirable
-          @try_require_cache[requirable] = true
-        rescue LoadError
-          @try_require_cache[requirable] = false
-        end
+        require requirable
+        @try_require_cache[requirable] = true
+      rescue LoadError
+        @try_require_cache[requirable] = false
       end
     end
   end