leftovers 0.6.0 → 0.9.0

data/lib/leftovers/processor_builders/transform.rb

@@ -3,51 +3,62 @@
 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
+      def self.build(transform, arguments, then_processor) # rubocop:disable Metrics
+        case transform
+        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:
+        when :downcase
+          ::Leftovers::Processors::Downcase.new(then_processor)
+        when :upcase
+          ::Leftovers::Processors::Upcase.new(then_processor)
+        when :capitalize
+          ::Leftovers::Processors::Capitalize.new(then_processor)
+        when :swapcase
+          ::Leftovers::Processors::Swapcase.new(then_processor)
+        when :pluralize
+          ::Leftovers::Processors::Pluralize.new(then_processor)
+        when :singularize
+          ::Leftovers::Processors::Singularize.new(then_processor)
+        when :camelize
+          ::Leftovers::Processors::Camelize.new(then_processor)
+        when :titleize
+          ::Leftovers::Processors::Titleize.new(then_processor)
+        when :demodulize
+          ::Leftovers::Processors::Demodulize.new(then_processor)
+        when :deconstantize
+          ::Leftovers::Processors::Deconstantize.new(then_processor)
+        when :parameterize
+          ::Leftovers::Processors::Parameterize.new(then_processor)
+        when :underscore
+          ::Leftovers::Processors::Underscore.new(then_processor)
+        when :transforms
+          ::Leftovers::ProcessorBuilders::TransformSet.build(arguments, then_processor)
+        else
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(arguments) do |argument|
+            case transform
+            when :split
+              ::Leftovers::Processors::Split.new(argument, then_processor)
+            when :delete_before
+              ::Leftovers::Processors::DeleteBefore.new(argument, then_processor)
+            when :delete_before_last
+              ::Leftovers::Processors::DeleteBeforeLast.new(argument, then_processor)
+            when :delete_after
+              ::Leftovers::Processors::DeleteAfter.new(argument, then_processor)
+            when :delete_after_last
+              ::Leftovers::Processors::DeleteAfterLast.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::Processors::DeletePrefix.new(argument, then_processor)
+            when :delete_suffix
+              ::Leftovers::Processors::DeleteSuffix.new(argument, then_processor)
+            # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
+              # :nocov:
+            end
+          end
         end
       end
     end

data/lib/leftovers/processor_builders/transform_chain.rb

@@ -3,20 +3,28 @@
 module Leftovers
   module ProcessorBuilders
     module TransformChain
-      def self.build(transforms, next_transform) # rubocop:disable Metrics/MethodLength
-        case transforms
-        when ::Hash
+      class << self
+        def build(transforms, next_transform)
+          case transforms
+          when ::Hash then build_from_hash(transforms, next_transform)
+          when ::Symbol
+            ::Leftovers::ProcessorBuilders::Transform.build(transforms, true, next_transform)
+          # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{transforms.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_from_hash(transforms, next_transform)
           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

data/lib/leftovers/processor_builders/transform_set.rb

@@ -3,43 +3,27 @@
 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
+      class << self
+        def build(transforms, final_processor)
+          each_builder(final_processor).each_or_self(transforms) do |transform|
+            case transform
+            when ::Hash, ::Symbol
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, final_processor)
             # :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
-          # :nocov:
-        end
-      end
+        private
 
-      def self.build_final(action)
-        case action
-        when :call
-          ::Leftovers::ValueProcessors::ReturnString
-        when :define
-          ::Leftovers::ValueProcessors::ReturnDefinition
-        # :nocov:
-        else raise
-          # :nocov:
+        def each_builder(final_processor)
+          if final_processor == ::Leftovers::Processors::AddDefinitionNode
+            ::Leftovers::ProcessorBuilders::Each[:each_for_definition_set]
+          else
+            ::Leftovers::ProcessorBuilders::Each[:each]
+          end
         end
       end
     end

data/lib/leftovers/processor_builders/value.rb

@@ -3,10 +3,10 @@
 module Leftovers
   module ProcessorBuilders
     module Value
-      def self.build(value, then_processor)
-        return unless value && then_processor
-
-        ::Leftovers::ValueProcessors::ReplaceValue.new(value, then_processor)
+      def self.build(values, then_processor)
+        ::Leftovers::ProcessorBuilders::Each.each_or_self(values) do |value|
+          ::Leftovers::Processors::ReplaceValue.new(value, then_processor)
+        end
       end
     end
   end

data/lib/leftovers/processor_builders.rb

@@ -7,13 +7,11 @@ module Leftovers
     autoload(:AddSuffix, "#{__dir__}/processor_builders/add_suffix")
     autoload(:Argument, "#{__dir__}/processor_builders/argument")
     autoload(:Dynamic, "#{__dir__}/processor_builders/dynamic")
-    autoload(:EachAction, "#{__dir__}/processor_builders/each_action")
-    autoload(:EachDynamic, "#{__dir__}/processor_builders/each_dynamic")
-    autoload(:EachForDefinitionSet, "#{__dir__}/processor_builders/each_for_definition_set")
     autoload(:Each, "#{__dir__}/processor_builders/each")
     autoload(:Itself, "#{__dir__}/processor_builders/itself")
     autoload(:Keyword, "#{__dir__}/processor_builders/keyword")
     autoload(:KeywordArgument, "#{__dir__}/processor_builders/keyword_argument")
+    autoload(:Receiver, "#{__dir__}/processor_builders/receiver")
     autoload(:TransformChain, "#{__dir__}/processor_builders/transform_chain")
     autoload(:TransformSet, "#{__dir__}/processor_builders/transform_set")
     autoload(:Transform, "#{__dir__}/processor_builders/transform")

data/lib/leftovers/processors/add_call.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    module AddCall
+      def self.process(str, _current_node, _matched_node, acc)
+        return unless str
+        return if str.empty?
+
+        acc.calls << str.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/processors/add_definition_node.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    module AddDefinitionNode
+      def self.process(str, current_node, _matched_node, acc)
+        return unless str
+        return if str.empty?
+
+        acc.add_definition_node Leftovers::DefinitionNode.new(current_node, name: str.to_sym)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/add_dynamic_prefix.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class AddDynamicPrefix
+      include ComparableInstance
+
+      def initialize(prefix_processor, then_processor)
+        @prefix_processor = prefix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless str
+
+        prefixes = []
+        @prefix_processor.process(nil, matched_node, matched_node, prefixes)
+
+        prefixes.each do |prefix|
+          @then_processor.process("#{prefix}#{str}", current_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/add_dynamic_suffix.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class AddDynamicSuffix
+      include ComparableInstance
+
+      def initialize(suffix_processor, then_processor)
+        @suffix_processor = suffix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless str
+
+        suffixes = []
+        @suffix_processor.process(nil, matched_node, matched_node, suffixes)
+
+        suffixes.each do |suffix|
+          @then_processor.process("#{str}#{suffix}", current_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/{value_processors → processors}/add_prefix.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class AddPrefix
+      include ComparableInstance
+
       def initialize(prefix, then_processor)
         @prefix = prefix
         @then_processor = then_processor
@@ -10,11 +12,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process("#{@prefix}#{str}", node, method_node)
+        @then_processor.process("#{@prefix}#{str}", current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/{value_processors → processors}/add_suffix.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class AddSuffix
+      include ComparableInstance
+
       def initialize(suffix, then_processor)
         @suffix = suffix
         @then_processor = then_processor
@@ -10,11 +12,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process("#{str}#{@suffix}", node, method_node)
+        @then_processor.process("#{str}#{@suffix}", current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/processors/append_sym.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    module AppendSym
+      def self.process(str, _current_node, _matched_node, acc)
+        return unless str
+
+        acc << str.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/{value_processors → processors}/camelize.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Camelize
+      include ComparableInstance
+
       def initialize(then_processor)
         @then_processor = then_processor
 
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process(str.camelize, node, method_node)
+        @then_processor.process(str.camelize, current_node, matched_node, acc)
       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', 'active_support/core_ext/string']` to your .leftovers.yml
         MESSAGE
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/{value_processors → processors}/capitalize.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Capitalize
+      include ComparableInstance
+
       def initialize(then_processor)
         @then_processor = then_processor
 
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process(str.capitalize, node, method_node)
+        @then_processor.process(str.capitalize, current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/{value_processors → processors}/deconstantize.rb

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Deconstantize
+      include ComparableInstance
+
       def initialize(then_processor)
         @then_processor = then_processor
 
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process(str.deconstantize, node, method_node)
+        @then_processor.process(str.deconstantize, current_node, matched_node, acc)
       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', 'active_support/core_ext/string']` to your .leftovers.yml
         MESSAGE
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/{value_processors → processors}/delete_after.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class DeleteAfter
+      include ComparableInstance
+
       def initialize(delete_after, then_processor)
         @delete_after = delete_after
         @then_processor = then_processor
@@ -10,13 +12,15 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        # TODO: investigate index
-        str = str.split(@delete_after, 2).first || str
-        @then_processor.process(str, node, method_node)
+        index = str.index(@delete_after)
+        str = str[0...index] if index
+        @then_processor.process(str, current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/processors/delete_after_last.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class DeleteAfterLast
+      include ComparableInstance
+
+      def initialize(delete_after, then_processor)
+        @delete_after = delete_after
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless str
+
+        index = str.rindex(@delete_after)
+        str = str[0...index] if index
+        @then_processor.process(str, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/delete_before.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class DeleteBefore
+      include ComparableInstance
+
+      def initialize(delete_before, then_processor)
+        @delete_before = delete_before
+        @delete_before_length = delete_before.length
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless str
+
+        index = str.index(@delete_before)
+        str = str[(index + @delete_before_length)..-1] if index
+        @then_processor.process(str, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/delete_before_last.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class DeleteBeforeLast
+      include ComparableInstance
+
+      def initialize(delete_before, then_processor)
+        @delete_before = delete_before
+        @delete_before_length = delete_before.length
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless str
+
+        index = str.rindex(@delete_before)
+        str = str[(index + @delete_before_length)..-1] if index
+        @then_processor.process(str, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/{value_processors → processors}/delete_prefix.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class DeletePrefix
+      include ComparableInstance
+
       def initialize(prefix, then_processor)
         @prefix = prefix
         @then_processor = then_processor
@@ -10,11 +12,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process(str.delete_prefix(@prefix), node, method_node)
+        @then_processor.process(str.delete_prefix(@prefix), current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/{value_processors → processors}/delete_suffix.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class DeleteSuffix
+      include ComparableInstance
+
       def initialize(suffix, then_processor)
         @suffix = suffix
         @then_processor = then_processor
@@ -10,11 +12,13 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
         return unless str
 
-        @then_processor.process(str.delete_suffix(@suffix), node, method_node)
+        @then_processor.process(str.delete_suffix(@suffix), current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end