leftovers 0.8.0 → 0.9.0

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

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

data/lib/leftovers/processors.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module Processors
+    autoload(:AddCall, "#{__dir__}/processors/add_call")
+    autoload(:AddDefinitionNode, "#{__dir__}/processors/add_definition_node")
+    autoload(:AddDynamicPrefix, "#{__dir__}/processors/add_dynamic_prefix")
+    autoload(:AddDynamicSuffix, "#{__dir__}/processors/add_dynamic_suffix")
+    autoload(:AddPrefix, "#{__dir__}/processors/add_prefix")
+    autoload(:AddSuffix, "#{__dir__}/processors/add_suffix")
+    autoload(:AppendSym, "#{__dir__}/processors/append_sym")
+    autoload(:Camelize, "#{__dir__}/processors/camelize")
+    autoload(:Capitalize, "#{__dir__}/processors/capitalize")
+    autoload(:Deconstantize, "#{__dir__}/processors/deconstantize")
+    autoload(:DeleteAfter, "#{__dir__}/processors/delete_after")
+    autoload(:DeleteAfterLast, "#{__dir__}/processors/delete_after_last")
+    autoload(:DeleteBefore, "#{__dir__}/processors/delete_before")
+    autoload(:DeleteBeforeLast, "#{__dir__}/processors/delete_before_last")
+    autoload(:DeletePrefix, "#{__dir__}/processors/delete_prefix")
+    autoload(:DeleteSuffix, "#{__dir__}/processors/delete_suffix")
+    autoload(:Demodulize, "#{__dir__}/processors/demodulize")
+    autoload(:Downcase, "#{__dir__}/processors/downcase")
+    autoload(:Each, "#{__dir__}/processors/each")
+    autoload(:EachForDefinitionSet, "#{__dir__}/processors/each_for_definition_set")
+    autoload(:EachKeyword, "#{__dir__}/processors/each_keyword")
+    autoload(:EachKeywordArgument, "#{__dir__}/processors/each_keyword_argument")
+    autoload(:EachPositionalArgument, "#{__dir__}/processors/each_positional_argument")
+    autoload(:EachPositionalArgumentFrom, "#{__dir__}/processors/each_positional_argument_from")
+    autoload(:Eval, "#{__dir__}/processors/eval")
+    autoload(:Itself, "#{__dir__}/processors/itself")
+    autoload(:KeywordArgument, "#{__dir__}/processors/keyword_argument")
+    autoload(:MatchCurrentNode, "#{__dir__}/processors/match_current_node")
+    autoload(:MatchMatchedNode, "#{__dir__}/processors/match_matched_node")
+    autoload(:Parameterize, "#{__dir__}/processors/parameterize")
+    autoload(:Placeholder, "#{__dir__}/processors/placeholder")
+    autoload(:Pluralize, "#{__dir__}/processors/pluralize")
+    autoload(:PositionalArgument, "#{__dir__}/processors/positional_argument")
+    autoload(:Receiver, "#{__dir__}/processors/receiver")
+    autoload(:ReplaceValue, "#{__dir__}/processors/replace_value")
+    autoload(:SetDefaultPrivacy, "#{__dir__}/processors/set_default_privacy")
+    autoload(:SetPrivacy, "#{__dir__}/processors/set_privacy")
+    autoload(:Singularize, "#{__dir__}/processors/singularize")
+    autoload(:Split, "#{__dir__}/processors/split")
+    autoload(:Swapcase, "#{__dir__}/processors/swapcase")
+    autoload(:Titleize, "#{__dir__}/processors/titleize")
+    autoload(:Underscore, "#{__dir__}/processors/underscore")
+    autoload(:Upcase, "#{__dir__}/processors/upcase")
+  end
+end

data/lib/leftovers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leftovers
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end