leftovers 0.2.3 → 0.4.3

data/lib/leftovers/value_processors.rb

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module ValueProcessors
+    autoload(:AddDynamicPrefix, "#{__dir__}/value_processors/add_dynamic_prefix")
+    autoload(:AddDynamicSuffix, "#{__dir__}/value_processors/add_dynamic_suffix")
+    autoload(:AddPrefix, "#{__dir__}/value_processors/add_prefix")
+    autoload(:AddSuffix, "#{__dir__}/value_processors/add_suffix")
+    autoload(:Camelize, "#{__dir__}/value_processors/camelize")
+    autoload(:Capitalize, "#{__dir__}/value_processors/capitalize")
+    autoload(:Deconstantize, "#{__dir__}/value_processors/deconstantize")
+    autoload(:DeleteAfter, "#{__dir__}/value_processors/delete_after")
+    autoload(:DeleteBefore, "#{__dir__}/value_processors/delete_before")
+    autoload(:DeletePrefix, "#{__dir__}/value_processors/delete_prefix")
+    autoload(:DeleteSuffix, "#{__dir__}/value_processors/delete_suffix")
+    autoload(:Demodulize, "#{__dir__}/value_processors/demodulize")
+    autoload(:Downcase, "#{__dir__}/value_processors/downcase")
+    autoload(:EachForDefinitionSet, "#{__dir__}/value_processors/each_for_definition_set")
+    autoload(:EachKeyword, "#{__dir__}/value_processors/each_keyword")
+    autoload(:EachKeywordArgument, "#{__dir__}/value_processors/each_keyword_argument")
+    autoload(:EachPositionalArgument, "#{__dir__}/value_processors/each_positional_argument")
+    autoload(:Each, "#{__dir__}/value_processors/each")
+    autoload(:Itself, "#{__dir__}/value_processors/itself")
+    autoload(:Keyword, "#{__dir__}/value_processors/keyword")
+    autoload(:KeywordArgument, "#{__dir__}/value_processors/keyword_argument")
+    autoload(:Parameterize, "#{__dir__}/value_processors/parameterize")
+    autoload(:Placeholder, "#{__dir__}/value_processors/placeholder")
+    autoload(:Pluralize, "#{__dir__}/value_processors/pluralize")
+    autoload(:PositionalArgument, "#{__dir__}/value_processors/positional_argument")
+    autoload(:ReplaceValue, "#{__dir__}/value_processors/replace_value")
+    autoload(:ReturnDefinition, "#{__dir__}/value_processors/return_definition")
+    autoload(:ReturnString, "#{__dir__}/value_processors/return_string")
+    autoload(:Singularize, "#{__dir__}/value_processors/singularize")
+    autoload(:Split, "#{__dir__}/value_processors/split")
+    autoload(:Swapcase, "#{__dir__}/value_processors/swapcase")
+    autoload(:Titleize, "#{__dir__}/value_processors/titleize")
+    autoload(:Underscore, "#{__dir__}/value_processors/underscore")
+    autoload(:Upcase, "#{__dir__}/value_processors/upcase")
+  end
+end

data/lib/leftovers/value_processors/add_dynamic_prefix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddDynamicPrefix
+      def initialize(prefix_processor, then_processor)
+        @prefix_processor = prefix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+        return unless str
+
+        prefixes = @prefix_processor.process(nil, method_node, method_node)
+        if prefixes.is_a?(Array)
+          prefixes.flatten!
+          prefixes.compact!
+          prefixes.uniq!
+
+          prefixes.map do |prefix|
+            @then_processor.process("#{prefix}#{str}", node, method_node)
+          end
+        else
+          @then_processor.process("#{prefixes}#{str}", node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_dynamic_suffix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddDynamicSuffix
+      def initialize(suffix_processor, then_processor)
+        @suffix_processor = suffix_processor
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node) # rubocop:disable Metrics/MethodLength
+        return unless str
+
+        suffixes = @suffix_processor.process(nil, method_node, method_node)
+        if suffixes.is_a?(Array)
+          suffixes.flatten!
+          suffixes.compact!
+          suffixes.uniq!
+
+          suffixes.map do |suffix|
+            @then_processor.process("#{str}#{suffix}", node, method_node)
+          end
+        else
+          @then_processor.process("#{str}#{suffixes}", node, method_node)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_prefix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddPrefix
+      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("#{@prefix}#{str}", node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/add_suffix.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class AddSuffix
+      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}#{@suffix}", node, method_node)
+      end
+    end
+  end
+end

data/lib/leftovers/value_processors/camelize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Camelize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.camelize, node, method_node)
+      rescue NoMethodError
+        Leftovers.error <<~MESSAGE
+          Tried using the String#camelize 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/capitalize.rb

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

data/lib/leftovers/value_processors/deconstantize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ValueProcessors
+    class Deconstantize
+      def initialize(then_processor)
+        @then_processor = then_processor
+
+        freeze
+      end
+
+      def process(str, node, method_node)
+        return unless str
+
+        @then_processor.process(str.deconstantize, node, method_node)
+      rescue NoMethodError
+        Leftovers.error <<~MESSAGE
+          Tried using the String#deconstantize 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/delete_after.rb

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

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,29 @@
+# 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)
+        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)
+      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