leftovers 0.8.0 → 0.11.0

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

data/lib/leftovers/processors/each_keyword_argument.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class EachKeywordArgument
+      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
+
+          value_node = pair.second
+          @then_processor.process(value_node.to_literal_s, value_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/each_positional_argument.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class EachPositionalArgument
+      include ComparableInstance
+
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, current_node, matched_node, acc)
+        positional_arguments = current_node.positional_arguments
+
+        return unless positional_arguments
+
+        positional_arguments.each do |argument_node|
+          @then_processor.process(argument_node.to_literal_s, argument_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/each_positional_argument_from.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class EachPositionalArgumentFrom
+      include ComparableInstance
+
+      def initialize(position, then_processor)
+        @position = position
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, current_node, matched_node, acc)
+        positional_arguments = current_node.positional_arguments
+
+        return unless positional_arguments
+
+        positional_arguments.each_with_index do |argument_node, index|
+          next if index < @position
+
+          @then_processor.process(argument_node.to_literal_s, argument_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/eval.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    module Eval
+      def self.process(str, current_node, _matched_node, acc)
+        return unless str
+        return if str.empty?
+
+        acc.collect_subfile(str, current_node.loc.expression)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/itself.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class Itself
+      include ComparableInstance
+
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, current_node, matched_node, acc)
+        @then_processor.process(current_node.to_s, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/keyword_argument.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class KeywordArgument
+      include ComparableInstance
+
+      def initialize(matcher, then_processor)
+        @matcher = matcher
+        @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 @matcher === pair
+
+          value_node = pair.second
+          @then_processor.process(value_node.to_literal_s, value_node, matched_node, acc)
+        end
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/match_current_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class MatchCurrentNode
+      include ComparableInstance
+
+      attr_reader :matcher, :then_processor
+
+      def initialize(matcher, then_processor)
+        @matcher = matcher
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless @matcher === current_node
+
+        @then_processor.process(str, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/match_matched_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class MatchMatchedNode
+      include ComparableInstance
+
+      attr_reader :matcher, :then_processor
+
+      def initialize(matcher, then_processor)
+        @matcher = matcher
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, current_node, matched_node, acc)
+        return unless @matcher === matched_node
+
+        @then_processor.process(str, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

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

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

@@ -1,8 +1,7 @@
 # frozen-string-literal: true
 
-# TODO: find a way for this to remove itself from the chain
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Placeholder
       def processor=(value)
         @processor = value
@@ -10,9 +9,11 @@ module Leftovers
         freeze
       end
 
-      def process(str, node, method_node)
-        @processor.process(str, node, method_node)
+      def process(str, current_node, matched_node, acc)
+        @processor.process(str, current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

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

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

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class PositionalArgument
+      include ComparableInstance
+
       def initialize(index, then_processor)
         @index = index
         @then_processor = then_processor
@@ -10,17 +12,17 @@ module Leftovers
         freeze
       end
 
-      def process(_str, node, method_node)
-        positional_arguments = node.positional_arguments
+      def process(_str, current_node, matched_node, acc)
+        positional_arguments = current_node.positional_arguments
         return unless positional_arguments
 
         argument_node = positional_arguments[@index]
         return unless argument_node
 
-        str = argument_node.to_s if argument_node.string_or_symbol?
-
-        @then_processor.process(str, argument_node, method_node)
+        @then_processor.process(argument_node.to_literal_s, argument_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/processors/receiver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Processors
+    class Receiver
+      include ComparableInstance
+
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, current_node, matched_node, acc)
+        receiver = matched_node.receiver
+        return unless receiver
+
+        @then_processor.process(receiver.to_s, current_node, matched_node, acc)
+      end
+
+      freeze
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class ReplaceValue
+      include ComparableInstance
+
       def initialize(value, then_processor)
         @value = value
         @then_processor = then_processor
@@ -10,9 +12,11 @@ module Leftovers
         freeze
       end
 
-      def process(_str, node, method_node)
-        @then_processor.process(@value, node, method_node)
+      def process(_str, current_node, matched_node, acc)
+        @then_processor.process(@value, current_node, matched_node, acc)
       end
+
+      freeze
     end
   end
 end

data/lib/leftovers/processors/set_default_privacy.rb

@@ -0,0 +1,21 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    class SetDefaultPrivacy
+      include ComparableInstance
+
+      def initialize(to)
+        @to = to
+
+        freeze
+      end
+
+      def process(_str, _current_node, _matched_node, acc)
+        acc.default_method_privacy = @to
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/processors/set_privacy.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    class SetPrivacy
+      include ComparableInstance
+
+      def initialize(to)
+        @to = to
+
+        freeze
+      end
+
+      def process(str, _current_node, _matched_node, acc)
+        return unless str
+
+        acc.set_privacy(str.to_sym, @to)
+      end
+
+      freeze
+    end
+  end
+end

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

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

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class Split
+      include ComparableInstance
+
       def initialize(split_on, then_processor)
         @split_on = split_on
         @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
 
-        Leftovers.map_or_self(str.split(@split_on)) do |sub_str|
-          @then_processor.process(sub_str, node, method_node)
+        str.split(@split_on).each do |sub_str|
+          @then_processor.process(sub_str, current_node, matched_node, acc)
         end
       end
+
+      freeze
     end
   end
 end

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

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