leftovers 0.2.1 → 0.4.1

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, stdout: $stdout, stderr: $stderr)
-    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

@@ -4,7 +4,7 @@ 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
+        "\e[36m#{definition.location_s}\e[0m #{definition} \e[2m#{definition.highlighted_source("\e[33m", "\e[0;2m")}\e[0m" # rubocop:disable Layout/LineLength
       )
     end
   end

data/lib/leftovers/value_processors.rb

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    autoload(:AddDynamicPrefix, "#{__dir__}/value_processors/add_dynamic_prefix")
+    autoload(:AddDynamicSuffix, "#{__dir__}/value_processors/add_dynamic_suffix")
+    autoload(:AddPrefix, "#{__dir__}/value_processors/add_prefix")
+    autoload(:AddSuffix, "#{__dir__}/value_processors/add_suffix")
+    autoload(:Camelize, "#{__dir__}/value_processors/camelize")
+    autoload(:Capitalize, "#{__dir__}/value_processors/capitalize")
+    autoload(:Deconstantize, "#{__dir__}/value_processors/deconstantize")
+    autoload(:DeleteAfter, "#{__dir__}/value_processors/delete_after")
+    autoload(:DeleteBefore, "#{__dir__}/value_processors/delete_before")
+    autoload(:DeletePrefix, "#{__dir__}/value_processors/delete_prefix")
+    autoload(:DeleteSuffix, "#{__dir__}/value_processors/delete_suffix")
+    autoload(:Demodulize, "#{__dir__}/value_processors/demodulize")
+    autoload(:Downcase, "#{__dir__}/value_processors/downcase")
+    autoload(:EachForDefinitionSet, "#{__dir__}/value_processors/each_for_definition_set")
+    autoload(:EachKeyword, "#{__dir__}/value_processors/each_keyword")
+    autoload(:EachKeywordArgument, "#{__dir__}/value_processors/each_keyword_argument")
+    autoload(:EachPositionalArgument, "#{__dir__}/value_processors/each_positional_argument")
+    autoload(:Each, "#{__dir__}/value_processors/each")
+    autoload(:Itself, "#{__dir__}/value_processors/itself")
+    autoload(:Keyword, "#{__dir__}/value_processors/keyword")
+    autoload(:KeywordArgument, "#{__dir__}/value_processors/keyword_argument")
+    autoload(:Parameterize, "#{__dir__}/value_processors/parameterize")
+    autoload(:Placeholder, "#{__dir__}/value_processors/placeholder")
+    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(:Singularize, "#{__dir__}/value_processors/singularize")
+    autoload(:Split, "#{__dir__}/value_processors/split")
+    autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")
+    autoload(:Titleize, "#{__dir__}/value_processors/titleize")
+    autoload(:Underscore, "#{__dir__}/value_processors/underscore")
+    autoload(:Upcase, "#{__dir__}/value_processors/upcase")
+  end
+end

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddDynamicPrefix
+      def initialize(prefix_processor, then_processor)
+        @prefix_processor = prefix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+        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)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddDynamicSuffix
+      def initialize(suffix_processor, then_processor)
+        @suffix_processor = suffix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+        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)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_prefix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddPrefix
+      def initialize(prefix, then_processor)
+        @prefix = prefix
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process("#{@prefix}#{str}", node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_suffix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddSuffix
+      def initialize(suffix, then_processor)
+        @suffix = suffix
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process("#{str}#{@suffix}", node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/camelize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Camelize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.camelize, node, method_node)
+      rescue NoMethodError
+        Leftovers.error <<~MESSAGE
+          Tried using the String#camelize method, but the activesupport gem was not available and/or not required
+          `gem install activesupport`, and/or add `requires: 'active_support/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/capitalize.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Capitalize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.capitalize, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/deconstantize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Deconstantize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.deconstantize, node, method_node)
+      rescue NoMethodError
+        Leftovers.error <<~MESSAGE
+          Tried using the String#deconstantize method, but the activesupport gem was not available and/or not required
+          `gem install activesupport`, and/or add `requires: 'active_support/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end