leftovers 0.8.0 → 0.9.0

data/lib/leftovers/processor_builders/transform_chain.rb

@@ -7,7 +7,7 @@ module Leftovers
         def build(transforms, next_transform)
           case transforms
           when ::Hash then build_from_hash(transforms, next_transform)
-          when ::String
+          when ::Symbol
             ::Leftovers::ProcessorBuilders::Transform.build(transforms, true, next_transform)
           # :nocov:
           else raise Leftovers::UnexpectedCase, "Unhandled value #{transforms.inspect}"

data/lib/leftovers/processor_builders/transform_set.rb

@@ -4,15 +4,11 @@ module Leftovers
   module ProcessorBuilders
     module TransformSet
       class << self
-        def build(transforms, action)
-          each_builder(action).each_or_self(transforms) do |transform|
+        def build(transforms, final_processor)
+          each_builder(final_processor).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))
+            when ::Hash, ::Symbol
+              ::Leftovers::ProcessorBuilders::TransformChain.build(transform, final_processor)
             # :nocov:
             else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.inspect}"
               # :nocov:
@@ -20,29 +16,13 @@ module Leftovers
           end
         end
 
-        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
-
         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:
+        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

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

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

@@ -1,24 +1,28 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Demodulize
+      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.demodulize, node, method_node)
+        @then_processor.process(str.demodulize, current_node, matched_node, acc)
       rescue NoMethodError
         Leftovers.error <<~MESSAGE
           Tried using the String#demodulize 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}/downcase.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Downcase
+      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.downcase, node, method_node)
+        @then_processor.process(str.downcase, current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/processors/each.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class Each
+      include ComparableInstance
+
+      attr_reader :processors
+
+      def initialize(processors)
+        @processors = processors
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        @processors.each do |processor|
+          processor.process(str, current_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/each_for_definition_set.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    class EachForDefinitionSet
+      include ComparableInstance
+
+      attr_reader :processors
+
+      def initialize(processors)
+        @processors = processors
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        set = ::Leftovers::DefinitionNodeSet.new
+
+        @processors.each do |processor|
+          processor.process(str, current_node, matched_node, set)
+        end
+
+        if set.definitions.length == 1
+          acc.add_definition_node set.definitions.first
+        else
+          acc.add_definition_set set
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/each_keyword.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class EachKeyword
+      include ComparableInstance
+
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, current_node, matched_node, acc)
+        kwargs = current_node.kwargs
+        return unless kwargs
+
+        kwargs.children.each do |pair|
+          next unless pair.type == :pair
+
+          key_node = pair.first
+          @then_processor.process(key_node.to_literal_s, key_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end