leftovers 0.3.0 → 0.4.0

data/lib/leftovers/value_processors/delete_before.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class DeleteBefore
+      def initialize(delete_before, then_processor)
+        @delete_before = delete_before
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        # TODO: investigate index
+        str = str.split(@delete_before, 2)[1] || str
+        @then_processor.process(str, node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/delete_prefix.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class DeletePrefix
+      # :nocov:
+      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
+        using ::Leftovers::Backports::StringDeletePrefixSuffix
+      end
+      # :nocov:
+
+      def initialize(prefix, then_processor)
+        @prefix = prefix
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.delete_prefix(@prefix), node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/delete_suffix.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class DeleteSuffix
+      # :nocov:
+      if defined?(::Leftovers::Backports::StringDeletePrefixSuffix)
+        using ::Leftovers::Backports::StringDeletePrefixSuffix
+      end
+      # :nocov:
+
+      def initialize(suffix, then_processor)
+        @suffix = suffix
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.delete_suffix(@suffix), node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/demodulize.rb

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

data/lib/leftovers/value_processors/downcase.rb

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

data/lib/leftovers/value_processors/each.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Each
+      attr_reader :processors
+
+      def initialize(processors)
+        @processors = processors
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        @processors.flat_map do |processor|
+          processor.process(str, node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/each_for_definition_set.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    class EachForDefinitionSet
+      def initialize(then_processors)
+        @then_processors = then_processors
+
+        freeze
+      end
+
+      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+        definitions = @then_processors.map do |then_processor|
+          processed = then_processor.process(str, node, method_node)
+          return if processed == :keep # rubocop:disable Lint/NonLocalExitFromIterator
+
+          processed
+        end
+
+        definitions.flatten!
+        definitions.compact!
+
+        return definitions.first if definitions.length <= 1
+
+        ::Leftovers::DefinitionSet.new(
+          definitions,
+          location: node.loc.expression,
+          method_node: method_node
+        )
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/each_keyword.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class EachKeyword
+      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.first
+          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_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