leftovers 0.7.0 → 0.10.0

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/{value_processors → processors}/keyword_argument.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 module Leftovers
-  module ValueProcessors
+  module Processors
     class KeywordArgument
+      include ComparableInstance
+
       def initialize(matcher, then_processor)
         @matcher = matcher
         @then_processor = then_processor
@@ -10,23 +12,19 @@ module Leftovers
         freeze
       end
 
-      def process(_str, node, method_node)
-        kwargs = node.kwargs
+      def process(_str, current_node, matched_node, acc)
+        kwargs = current_node.kwargs
         return unless kwargs
 
-        result = []
-
         kwargs.children.each do |pair|
           next unless @matcher === pair
 
-          argument_node = pair.second
-          str = argument_node.to_s if argument_node.string_or_symbol?
-
-          result << @then_processor.process(str, argument_node, method_node)
+          value_node = pair.second
+          @then_processor.process(value_node.to_literal_s, value_node, matched_node, acc)
         end
-
-        result
       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
 
-        str.split(@split_on).map do |substring|
-          @then_processor.process(substring, 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

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

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

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

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