leftovers 0.2.3 → 0.4.3

data/lib/leftovers/value_processors/each_keyword_argument.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class EachKeywordArgument
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        kwargs = node.kwargs
+        return unless kwargs
+
+        kwargs.children.map do |pair|
+          next unless pair.type == :pair
+
+          argument_node = pair.second
+          str = argument_node.to_s if argument_node.string_or_symbol?
+
+          @then_processor.process(str, argument_node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/each_positional_argument.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class EachPositionalArgument
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        positional_arguments = node.positional_arguments
+        return unless positional_arguments
+
+        positional_arguments.map do |argument_node|
+          str = argument_node.to_s if argument_node.string_or_symbol?
+
+          @then_processor.process(str, argument_node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/itself.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Itself
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        @then_processor.process(method_node.to_s, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/keyword.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Keyword
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher, then_processor)
+        @matcher = matcher
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        kwargs = node.kwargs
+        return unless kwargs
+
+        result = []
+
+        kwargs.children.each do |pair|
+          next unless @matcher === pair
+
+          argument_node = pair.first
+          str = argument_node.to_s
+
+          result << @then_processor.process(str, argument_node, method_node)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/keyword_argument.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class KeywordArgument
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher, then_processor)
+        @matcher = matcher
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        kwargs = 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)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/parameterize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Parameterize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.parameterize, node, method_node)
+      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/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/placeholder.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+# TODO: find a way for this to remove itself from the chain
+module Leftovers
+  module ValueProcessors
+    class Placeholder
+      def processor=(value)
+        @processor = value
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        @processor.process(str, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/pluralize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Pluralize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.pluralize, node, method_node)
+      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/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/positional_argument.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class PositionalArgument
+      def initialize(index, then_processor)
+        @index = index
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        positional_arguments = 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)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/replace_value.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class ReplaceValue
+      def initialize(value, then_processor)
+        @value = value
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(_str, node, method_node)
+        @then_processor.process(@value, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/return_definition.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    module ReturnDefinition
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def self.process(str, node, method_node)
+        return unless str
+        return if str.empty?
+
+        str_node = Leftovers::DefinitionNode.new(str.to_sym, method_node.path)
+
+        return :keep if ::Leftovers.config.keep === str_node
+
+        Leftovers::Definition.new(
+          str_node.name,
+          location: node.loc.expression,
+          test: method_node.test_line? || ::Leftovers.config.test_only === str_node
+        )
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/return_string.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    module ReturnString
+      def self.process(str, _node, _method_node)
+        return unless str
+        return if str.empty?
+
+        str.to_sym
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/singularize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Singularize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.singularize, node, method_node)
+      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/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/split.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Split
+      def initialize(split_on, then_processor)
+        @split_on = split_on
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        str.split(@split_on).map do |substring|
+          @then_processor.process(substring, node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/swapcase.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Swapcase
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.swapcase, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/titleize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Titleize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.titleize, node, method_node)
+      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/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/underscore.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Underscore
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.underscore, node, method_node)
+      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/core_ext/string'` to your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/upcase.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Upcase
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.upcase, node, method_node)
+      end
+    end
+  end
+end