leftovers 0.2.3 → 0.4.3

data/lib/leftovers/processor_builders/each_dynamic.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module EachDynamic
+      def self.each_or_self(value, &block)
+        case value
+        when nil then ::Leftovers::DynamicProcessors::Null
+        when Array then build(value.map(&block))
+        else build([yield(value)])
+        end
+      end
+
+      def self.build(processors)
+        processors = compact(processors)
+
+        case processors.length
+        # :nocov:
+        when 0 then raise
+        # :nocov:
+        when 1 then processors.first
+        else ::Leftovers::DynamicProcessors::Each.new(processors)
+        end
+      end
+
+      def self.flatten(value) # rubocop:disable Metrics/MethodLength
+        case value
+        when ::Leftovers::DynamicProcessors::Each
+          ret = value.processors.map { |v| flatten(v) }
+          ret.flatten!(1)
+          ret
+        when Array
+          ret = value.map { |v| flatten(v) }
+          ret.flatten!(1)
+          ret
+        else
+          value
+        end
+      end
+
+      def self.compact(processors)
+        return processors if processors.length <= 1
+
+        processors = flatten(processors)
+
+        processors.reject! do |p|
+          p == ::Leftovers::DynamicProcessors::Null
+        end
+
+        processors
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/each_for_definition_set.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module EachForDefinitionSet
+      def self.each_or_self(value, &block)
+        case value
+        # :nocov:
+        when nil then raise
+        # :nocov:
+        when Array then build(value.map(&block))
+        else build([yield(value)])
+        end
+      end
+
+      def self.build(processors)
+        processors = compact(processors)
+
+        case processors.length
+        # :nocov:
+        when 0 then raise
+        # :nocov:
+        when 1 then processors.first
+        else ::Leftovers::ValueProcessors::EachForDefinitionSet.new(processors)
+        end
+      end
+
+      def self.compact(processors)
+        processors.flatten!
+        processors.compact!
+
+        processors
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/itself.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Itself
+      def self.build(value, then_processor)
+        return unless value && then_processor
+
+        ::Leftovers::ValueProcessors::Itself.new(then_processor)
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/keyword.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Keyword
+      def self.build(value, then_processor) # rubocop:disable Metrics/MethodLength
+        return unless value && then_processor
+
+        case value
+        when true, '**'
+          ::Leftovers::ValueProcessors::EachKeyword.new(then_processor)
+        when ::String, ::Hash, ::Array
+          ::Leftovers::ValueProcessors::Keyword.new(
+            ::Leftovers::MatcherBuilders::NodePairName.build(value),
+            then_processor
+          )
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/keyword_argument.rb

@@ -0,0 +1,14 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module KeywordArgument
+      def self.build(pattern, then_processor)
+        ::Leftovers::ValueProcessors::KeywordArgument.new(
+          ::Leftovers::MatcherBuilders::NodePairName.build(pattern),
+          then_processor
+        )
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/transform.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Transform
+      def self.build(transform, argument, then_processor) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+        case transform.to_s
+        when 'original', nil
+          then_processor
+        when 'downcase'
+          ::Leftovers::ValueProcessors::Downcase.new(then_processor)
+        when 'upcase'
+          ::Leftovers::ValueProcessors::Upcase.new(then_processor)
+        when 'capitalize'
+          ::Leftovers::ValueProcessors::Capitalize.new(then_processor)
+        when 'swapcase'
+          ::Leftovers::ValueProcessors::Swapcase.new(then_processor)
+        when 'pluralize'
+          ::Leftovers::ValueProcessors::Pluralize.new(then_processor)
+        when 'singularize'
+          ::Leftovers::ValueProcessors::Singularize.new(then_processor)
+        when 'camelize', 'camelcase'
+          ::Leftovers::ValueProcessors::Camelize.new(then_processor)
+        when 'titleize', 'titlecase'
+          ::Leftovers::ValueProcessors::Titleize.new(then_processor)
+        when 'demodulize'
+          ::Leftovers::ValueProcessors::Demodulize.new(then_processor)
+        when 'deconstantize'
+          ::Leftovers::ValueProcessors::Deconstantize.new(then_processor)
+        when 'parameterize'
+          ::Leftovers::ValueProcessors::Parameterize.new(then_processor)
+        when 'underscore'
+          ::Leftovers::ValueProcessors::Underscore.new(then_processor)
+        when 'split'
+          ::Leftovers::ValueProcessors::Split.new(argument, then_processor)
+        when 'delete_before'
+          ::Leftovers::ValueProcessors::DeleteBefore.new(argument, then_processor)
+        when 'delete_after'
+          ::Leftovers::ValueProcessors::DeleteAfter.new(argument, then_processor)
+        when 'add_prefix'
+          ::Leftovers::ProcessorBuilders::AddPrefix.build(argument, then_processor)
+        when 'add_suffix'
+          ::Leftovers::ProcessorBuilders::AddSuffix.build(argument, then_processor)
+        when 'delete_prefix'
+          ::Leftovers::ValueProcessors::DeletePrefix.new(argument, then_processor)
+        when 'delete_suffix'
+          ::Leftovers::ValueProcessors::DeleteSuffix.new(argument, then_processor)
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/transform_chain.rb

@@ -0,0 +1,24 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module TransformChain
+      def self.build(transforms, next_transform) # rubocop:disable Metrics/MethodLength
+        case transforms
+        when ::Hash
+          transforms.reverse_each do |(transform, transform_arg)|
+            next_transform = ::Leftovers::ProcessorBuilders::Transform.build(
+              transform, transform_arg, next_transform
+            )
+          end
+          next_transform
+        when ::String
+          ::Leftovers::ProcessorBuilders::Transform.build(transforms, true, next_transform)
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/transform_set.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+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]
+
+            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
+          when ::String
+            ::Leftovers::ProcessorBuilders::TransformChain.build(transform, build_final(action))
+          # :nocov:
+          else raise
+            # :nocov:
+          end
+        end
+      end
+
+      def self.each_builder(action)
+        case action
+        when :call
+          ::Leftovers::ProcessorBuilders::Each
+        when :define
+          ::Leftovers::ProcessorBuilders::EachForDefinitionSet
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+
+      def self.build_final(action)
+        case action
+        when :call
+          ::Leftovers::ValueProcessors::ReturnString
+        when :define
+          ::Leftovers::ValueProcessors::ReturnDefinition
+        # :nocov:
+        else raise
+          # :nocov:
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/value.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Value
+      def self.build(value, then_processor)
+        return unless value && then_processor
+
+        ::Leftovers::ValueProcessors::ReplaceValue.new(value, then_processor)
+      end
+    end
+  end
+end

data/lib/leftovers/rake_task.rb

@@ -2,7 +2,7 @@
 
 require 'rake'
 require 'shellwords'
-require_relative 'cli'
+require_relative '../leftovers'
 
 module Leftovers
   class RakeTask
@@ -49,9 +49,9 @@ module Leftovers
     end
 
     def run(argv)
-      Leftovers::CLI.new(argv: argv)
-    rescue SystemExit => e
-      raise unless e.status == 0
+      exitstatus = Leftovers::CLI.new(argv: argv).run
+
+      exit exitstatus unless exitstatus == 0
     end
 
     def argv_or_default(task_argv)

data/lib/leftovers/reporter.rb

@@ -2,10 +2,62 @@
 
 module Leftovers
   class Reporter
-    def call(definition)
-      Leftovers.puts(
-        "\e[36m#{definition.full_location}\e[0m #{definition.full_name} \e[2m#{definition.highlighted_source("\e[33m", "\e[0;2m")}\e[0m" # rubocop:disable Layout/LineLength
-      )
+    def prepare; end
+
+    def report(only_test:, none:)
+      report_list('Only directly called in tests:', only_test)
+      report_list('Not directly called at all:', none)
+      report_instructions
+
+      1
+    end
+
+    def report_success
+      puts green('Everything is used')
+
+      0
+    end
+
+    private
+
+    def report_instructions
+      puts <<~HELP
+
+        how to resolve: #{green Leftovers.resolution_instructions_link}
+      HELP
+    end
+
+    def report_list(title, list)
+      return if list.empty?
+
+      puts red(title)
+      list.each { |d| print_definition(d) }
+    end
+
+    def print_definition(definition)
+      puts "#{aqua definition.location_s} "\
+        "#{definition} "\
+        "#{grey definition.highlighted_source("\e[33m", "\e[0;2m")}"
+    end
+
+    def puts(string)
+      Leftovers.puts(string)
+    end
+
+    def red(string)
+      "\e[31m#{string}\e[0m"
+    end
+
+    def green(string)
+      "\e[32m#{string}\e[0m"
+    end
+
+    def aqua(string)
+      "\e[36m#{string}\e[0m"
+    end
+
+    def grey(string)
+      "\e[2m#{string}\e[0m"
     end
   end
 end

data/lib/leftovers/todo_reporter.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Leftovers
+  class TodoReporter
+    def prepare
+      return unless path.exist?
+
+      puts "Removing previous #{path.basename} file"
+      puts ''
+      path.delete
+    end
+
+    def report(only_test:, none:)
+      path.write(generate_file_body(only_test, none))
+      report_instructions
+
+      0
+    end
+
+    def report_success
+      puts "No #{path.basename} file generated, everything is used"
+
+      0
+    end
+
+    private
+
+    def report_instructions
+      puts <<~MESSAGE
+        generated #{path.basename}.
+        running leftovers again will read this file and
+        not alert you to any unused items mentioned in it.
+
+        commit this file so you/your team can gradually
+        address these items while still having leftovers
+        alert you to any newly unused items.
+      MESSAGE
+    end
+
+    def path
+      Leftovers.pwd.join('.leftovers_todo.yml')
+    end
+
+    def generate_file_body(only_test, none)
+      <<~YML.chomp
+        #{generation_message.chomp}
+        #
+        #{resolution_instructions}
+        #{todo_data(only_test, none).chomp}
+      YML
+    end
+
+    def generation_message
+      <<~YML
+        # This file was generated by `leftovers --write-todo`
+        # Generated at: #{Time.now.utc.strftime('%F %T')} UTC
+      YML
+    end
+
+    def resolution_instructions
+      <<~YML
+        # for instructions on how to address these
+        # see #{Leftovers.resolution_instructions_link}
+      YML
+    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)
+      ].compact.join
+    end
+
+    def test_only_data(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}
+        #{list.map { |d| print_definition(d) }.join("\n")}
+
+      YML
+    end
+
+    def print_definition(definition)
+      "  - #{definition.to_s.inspect} # #{definition.location_s} #{definition.source_line.strip}"
+    end
+
+    def puts(string)
+      Leftovers.puts(string)
+    end
+  end
+end