leftovers 0.8.0 → 0.9.0

data/lib/leftovers/precompilers.rb

@@ -23,11 +23,11 @@ module Leftovers
 
       def build_precompiler(format)
         case format
-        when 'erb' then ::Leftovers::Precompilers::ERB
-        when 'haml' then ::Leftovers::Precompilers::Haml
-        when 'json' then ::Leftovers::Precompilers::JSON
-        when 'slim' then ::Leftovers::Precompilers::Slim
-        when 'yaml' then ::Leftovers::Precompilers::YAML
+        when :erb then ::Leftovers::Precompilers::ERB
+        when :haml then ::Leftovers::Precompilers::Haml
+        when :json then ::Leftovers::Precompilers::JSON
+        when :slim then ::Leftovers::Precompilers::Slim
+        when :yaml then ::Leftovers::Precompilers::YAML
         when Hash then constantize_precompiler(format[:custom])
           # :nocov:
         else raise Leftovers::UnexpectedCase, "Unhandled value #{format}"

data/lib/leftovers/processor_builders/action.rb

@@ -4,12 +4,12 @@ module Leftovers
   module ProcessorBuilders
     module Action
       class << self
-        def build(patterns, action)
-          ::Leftovers::ProcessorBuilders::EachAction.each_or_self(patterns) do |pattern|
+        def build(patterns, final_processor)
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pattern|
             case pattern
             when ::String, ::Integer
-              ::Leftovers::ProcessorBuilders::Argument.build(pattern, final_transformer(action))
-            when ::Hash then build_from_hash_value(action, **pattern)
+              ::Leftovers::ProcessorBuilders::Argument.build(pattern, final_processor)
+            when ::Hash then build_from_hash_value(**pattern, final_processor: final_processor)
             # :nocov:
             else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
@@ -17,54 +17,72 @@ module Leftovers
           end
         end
 
-        private
+        def build_from_hash_value( # rubocop:disable Metrics/ParameterLists
+          final_processor:,
+          arguments: nil,
+          keywords: nil,
+          itself: nil,
+          receiver: nil,
+          value: nil,
+          nested: nil,
+          recursive: nil,
+
+          has_arguments: nil,
+          has_receiver: nil,
+          unless_arg: nil, all: nil, any: nil,
+          **transform_args
+        )
+          processor = ::Leftovers::ProcessorBuilders::TransformSet.build(
+            transform_args, final_processor
+          )
+          processor = build_nested(nested, processor) if nested
+          recursive_placeholder, processor = build_recursive(processor) if recursive
+          processor = build_sources(arguments, keywords, itself, receiver, value, processor)
+          processor = build_matcher(has_arguments, has_receiver, unless_arg, all, any, processor)
+          return processor unless recursive
 
-        def final_transformer(action)
-          ::Leftovers::ProcessorBuilders::TransformSet.build_final(action)
+          recursive_placeholder.processor = processor
+          recursive_placeholder
         end
 
-        def build_nested(nested, transformer, action)
+        private
+
+        def build_nested(nested, processor)
           ::Leftovers::ProcessorBuilders::Each.build([
-            ::Leftovers::ProcessorBuilders::Action.build(nested, action),
-            transformer
+            ::Leftovers::ProcessorBuilders::Action.build(nested, processor),
+            processor
           ])
         end
 
-        def build_processor(arguments, keywords, itself, value, transformer)
-          ::Leftovers::ProcessorBuilders::EachAction.build([
-            ::Leftovers::ProcessorBuilders::Argument.build(arguments, transformer),
-            ::Leftovers::ProcessorBuilders::Keyword.build(keywords, transformer),
-            ::Leftovers::ProcessorBuilders::Itself.build(itself, transformer),
-            ::Leftovers::ProcessorBuilders::Value.build(value, transformer)
+        def build_sources(arguments, keywords, itself, receiver, value, processor) # rubocop:disable Metrics/ParameterLists
+          ::Leftovers::ProcessorBuilders::Each.build([
+            ::Leftovers::ProcessorBuilders::Argument.build(arguments, processor),
+            ::Leftovers::ProcessorBuilders::Keyword.build(keywords, processor),
+            ::Leftovers::ProcessorBuilders::Itself.build(itself, processor),
+            ::Leftovers::ProcessorBuilders::Receiver.build(receiver, processor),
+            ::Leftovers::ProcessorBuilders::Value.build(value, processor)
           ])
         end
 
-        def build_recursive(transformer)
-          placeholder = ::Leftovers::ValueProcessors::Placeholder.new
-          transformer = ::Leftovers::ProcessorBuilders::Each.build([placeholder, transformer])
+        def build_recursive(processor)
+          recursive_placeholder = ::Leftovers::Processors::Placeholder.new
+          processor = ::Leftovers::ProcessorBuilders::Each.build([recursive_placeholder, processor])
 
-          [placeholder, transformer]
+          [recursive_placeholder, processor]
         end
 
-        def build_from_hash_value( # rubocop:disable Metrics/ParameterLists
-          action,
-          arguments: nil,
-          keywords: nil,
-          itself: nil,
-          value: nil,
-          nested: nil,
-          recursive: nil,
-          **transform_args
-        )
-          transformer = ::Leftovers::ProcessorBuilders::TransformSet.build(transform_args, action)
-          transformer = build_nested(nested, transformer, action) if nested
-          placeholder, transformer = build_recursive(transformer) if recursive
-          processor = build_processor(arguments, keywords, itself, value, transformer)
+        def build_matcher(has_arguments, has_receiver, unless_arg, all, any, processor) # rubocop:disable Metrics/ParameterLists
+          matcher = Leftovers::MatcherBuilders::Node.build_from_hash(
+            has_arguments: has_arguments,
+            has_receiver: has_receiver,
+            unless_arg: unless_arg,
+            all: all,
+            any: any
+          )
 
-          return processor unless recursive
+          return processor unless matcher
 
-          placeholder.processor = processor
-          placeholder
+          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
         end
       end
     end

data/lib/leftovers/processor_builders/add_prefix.rb

@@ -3,16 +3,24 @@
 module Leftovers
   module ProcessorBuilders
     module AddPrefix
-      def self.build(argument, then_processor)
-        case argument
-        when ::Hash
-          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
-          ::Leftovers::ValueProcessors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
-        when ::String
-          ::Leftovers::ValueProcessors::AddPrefix.new(argument, then_processor)
-          # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
-          # :nocov:
+      class << self
+        def build(argument, then_processor)
+          case argument
+          when ::Hash then build_hash(argument, then_processor)
+          when ::String then ::Leftovers::Processors::AddPrefix.new(argument, then_processor)
+            # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_hash(argument, then_processor)
+          dynamic_prefix = ::Leftovers::ProcessorBuilders::Action.build(
+            argument, ::Leftovers::Processors::AppendSym
+          )
+          ::Leftovers::Processors::AddDynamicPrefix.new(dynamic_prefix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/add_suffix.rb

@@ -3,16 +3,24 @@
 module Leftovers
   module ProcessorBuilders
     module AddSuffix
-      def self.build(argument, then_processor)
-        case argument
-        when ::Hash
-          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(argument, :sym)
-          ::Leftovers::ValueProcessors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
-        when ::String
-          ::Leftovers::ValueProcessors::AddSuffix.new(argument, then_processor)
-          # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
-          # :nocov:
+      class << self
+        def build(argument, then_processor)
+          case argument
+          when ::Hash then build_hash(argument, then_processor)
+          when ::String then ::Leftovers::Processors::AddSuffix.new(argument, then_processor)
+            # :nocov:
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{argument.inspect}"
+            # :nocov:
+          end
+        end
+
+        private
+
+        def build_hash(argument, then_processor)
+          dynamic_suffix = ::Leftovers::ProcessorBuilders::Action.build(
+            argument, ::Leftovers::Processors::AppendSym
+          )
+          ::Leftovers::Processors::AddDynamicSuffix.new(dynamic_suffix, then_processor)
         end
       end
     end

data/lib/leftovers/processor_builders/argument.rb

@@ -3,19 +3,36 @@
 module Leftovers
   module ProcessorBuilders
     module Argument
-      def self.build(patterns, processor)
-        ::Leftovers::ProcessorBuilders::EachAction.each_or_self(patterns) do |pat|
-          case pat
-          when ::Integer then ::Leftovers::ValueProcessors::PositionalArgument.new(pat, processor)
-          when '*' then ::Leftovers::ValueProcessors::EachPositionalArgument.new(processor)
-          when '**' then ::Leftovers::ValueProcessors::EachKeywordArgument.new(processor)
-          when ::String, ::Hash
-            ::Leftovers::ProcessorBuilders::KeywordArgument.build(pat, processor)
-            # :nocov:
-          else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
-            # :nocov:
+      class << self
+        def build(patterns, processor) # rubocop:disable Metrics/MethodLength
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(patterns) do |pat|
+            case pat
+            when ::Integer then ::Leftovers::Processors::PositionalArgument.new(pat, processor)
+            when '*' then ::Leftovers::Processors::EachPositionalArgument.new(processor)
+            when '**' then ::Leftovers::Processors::EachKeywordArgument.new(processor)
+            when /\A(\d+)\+\z/
+              ::Leftovers::Processors::EachPositionalArgumentFrom.new(pat.to_i, processor)
+            when ::String
+              ::Leftovers::ProcessorBuilders::KeywordArgument.build(pat, processor)
+            when ::Hash
+              build_hash(processor, pat)
+              # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+              # :nocov:
+            end
           end
         end
+
+        private
+
+        def build_hash(then_processor, pat)
+          ::Leftovers::Processors::KeywordArgument.new(
+            ::Leftovers::MatcherBuilders::NodePairKey.build(
+              ::Leftovers::MatcherBuilders::Node.build_from_hash(**pat)
+            ),
+            then_processor
+          )
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/dynamic.rb

@@ -5,57 +5,63 @@ module Leftovers
     module Dynamic
       class << self
         def build(dynamic_rules)
-          ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(dynamic_rules) do |dynamic|
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(dynamic_rules) do |dynamic|
             build_processors(**dynamic)
           end
         end
 
         private
 
-        def build_processors(
-          call: nil, define: nil, set_privacy: nil, set_default_privacy: nil, **matcher_rules
+        def build_processors( # rubocop:disable Metrics/ParameterLists
+          call: nil, define: nil,
+          set_privacy: nil, set_default_privacy: nil,
+          eval: nil, **matcher_rules
         )
           matcher = ::Leftovers::MatcherBuilders::Node.build(**matcher_rules)
 
-          call_action = build_action(call, return_type: :sym)
-          define_action = build_action(define, return_type: :definition_node)
-
-          ::Leftovers::ProcessorBuilders::EachDynamic.build([
-            build_call_define_processor(matcher, call_action, define_action),
-            build_set_privacy_processor(matcher, set_privacy),
-            build_set_default_privacy_processor(matcher, set_default_privacy)
+          processor = ::Leftovers::ProcessorBuilders::Each.build([
+            build_call_action(call),
+            build_define_action(define),
+            build_set_privacy_action(set_privacy),
+            build_set_default_privacy_action(set_default_privacy),
+            build_eval_action(eval)
           ])
-        end
 
-        def build_action(processor_rules, return_type:)
-          ::Leftovers::ProcessorBuilders::Action.build(processor_rules, return_type)
+          ::Leftovers::Processors::MatchMatchedNode.new(matcher, processor)
         end
 
-        def build_set_privacy_processor(matcher, set_privacy)
-          ::Leftovers::ProcessorBuilders::EachDynamic.each_or_self(set_privacy) do |action_values|
-            to = action_values.delete(:to)
-            action = build_action(action_values, return_type: :sym)
+        def build_call_action(call)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            call, ::Leftovers::Processors::AddCall
+          )
+        end
 
-            ::Leftovers::DynamicProcessors::SetPrivacy.new(matcher, action, to)
-          end
+        def build_define_action(define)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            define, ::Leftovers::Processors::AddDefinitionNode
+          )
         end
 
-        def build_set_default_privacy_processor(matcher, set_default_privacy)
-          ::Leftovers::DynamicProcessors::SetDefaultPrivacy.new(matcher, set_default_privacy)
+        def build_eval_action(eval)
+          ::Leftovers::ProcessorBuilders::Action.build(
+            eval, ::Leftovers::Processors::Eval
+          )
         end
 
-        def build_call_define_processor(matcher, call_action, define_action)
-          if call_action && define_action
-            # this nonsense saves a method call and array instantiation per method
-            ::Leftovers::DynamicProcessors::CallDefinition.new(matcher, call_action, define_action)
-          elsif define_action
-            ::Leftovers::DynamicProcessors::Definition.new(matcher, define_action)
-          elsif call_action
-            ::Leftovers::DynamicProcessors::Call.new(matcher, call_action)
-          else
-            ::Leftovers::DynamicProcessors::Null
+        def build_set_privacy_action(set_privacies)
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(set_privacies) do |set_privacy|
+            processor = ::Leftovers::Processors::SetPrivacy.new(set_privacy.delete(:to))
+            ::Leftovers::ProcessorBuilders::Action.build_from_hash_value(
+              **set_privacy, final_processor: processor
+            )
           end
         end
+
+        def build_set_default_privacy_action(set_default_privacy)
+          return unless set_default_privacy
+
+          ::Leftovers::Processors::SetDefaultPrivacy.new(set_default_privacy)
+        end
       end
     end
   end

data/lib/leftovers/processor_builders/each.rb

@@ -2,18 +2,37 @@
 
 module Leftovers
   module ProcessorBuilders
-    module Each
+    class Each
+      def self.build(processors)
+        self[:each].build(processors)
+      end
+
       def self.each_or_self(value, &block)
+        self[:each].each_or_self(value, &block)
+      end
+
+      def self.[](processor_name)
+        @each ||= {
+          each: new(::Leftovers::Processors::Each),
+          each_for_definition_set: new(::Leftovers::Processors::EachForDefinitionSet)
+        }
+
+        @each.fetch(processor_name)
+      end
+
+      def initialize(processor_class = ::Leftovers::Processors::Each)
+        @processor_class = processor_class
+      end
+
+      def each_or_self(value, &block)
         case value
-        # :nocov:
-        when nil then raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
-        # :nocov:
+        when nil then nil
         when Array then build(value.map(&block))
         else build([yield(value)])
         end
       end
 
-      def self.build(processors)
+      def build(processors)
         processors = compact(processors)
 
         case processors.length
@@ -21,15 +40,68 @@ module Leftovers
         when 0 then raise Leftovers::UnexpectedCase, "Unhandled value #{processors.inspect}"
         # :nocov:
         when 1 then processors.first
-        else ::Leftovers::ValueProcessors::Each.new(processors)
+        else @processor_class.new(processors)
         end
       end
 
-      def self.compact(processors)
-        processors.flatten!
-        processors.compact!
+      def flatten(processors)
+        case processors
+        when ::Leftovers::Processors::Each, @processor_class
+          flatten(processors.processors)
+        when Array
+          processors.flat_map { |v| flatten(v) }
+        when ::Leftovers::Processors::MatchCurrentNode, ::Leftovers::Processors::MatchMatchedNode
+          flatten_matchers(processors)
+        else
+          [processors]
+        end
+      end
+
+      def flatten_matchers(processor)
+        then_processors = flatten(processor.then_processor)
+        return [processor] if then_processors.length <= 1
+
+        then_processors.map do |then_processor|
+          processor.class.new(processor.matcher, then_processor)
+        end
+      end
+
+      def compact_matchers_with_same_processor(matchers)
+        matchers.group_by(&:then_processor).map do |then_processor, group|
+          next group.first unless group.length > 1
+
+          group.first.class.new(
+            ::Leftovers::MatcherBuilders::Or.build(group.map(&:matcher)),
+            then_processor
+          )
+        end
+      end
+
+      def compact_matchers_with_same_matcher(matchers)
+        matchers.group_by(&:matcher).map do |matcher, group|
+          next group.first unless group.length > 1
+
+          group.first.class.new(matcher, build(group.map(&:then_processor)))
+        end
+      end
+
+      def compact_matchers(matchers)
+        return [] unless matchers
+
+        matchers = compact_matchers_with_same_processor(matchers)
+        compact_matchers_with_same_matcher(matchers)
+      end
+
+      def compact(processors)
+        processors = flatten(processors).compact
+
+        return processors if processors.length <= 1
+
+        group = processors.group_by(&:class)
 
-        processors
+        compact_matchers(group.delete(::Leftovers::Processors::MatchCurrentNode)) +
+          compact_matchers(group.delete(::Leftovers::Processors::MatchMatchedNode)) +
+          group.values.flatten(1)
       end
     end
   end

data/lib/leftovers/processor_builders/itself.rb

@@ -4,9 +4,9 @@ module Leftovers
   module ProcessorBuilders
     module Itself
       def self.build(value, then_processor)
-        return unless value && then_processor
+        return unless value
 
-        ::Leftovers::ValueProcessors::Itself.new(then_processor)
+        ::Leftovers::Processors::Itself.new(then_processor)
       end
     end
   end

data/lib/leftovers/processor_builders/keyword.rb

@@ -4,19 +4,20 @@ module Leftovers
   module ProcessorBuilders
     module Keyword
       def self.build(value, then_processor)
-        return unless value && then_processor
+        return unless value
 
-        case value
-        when true, '**' then ::Leftovers::ValueProcessors::EachKeyword.new(then_processor)
+        then_processor = case value
+        when true, '**' then then_processor
         when ::String, ::Hash, ::Array
-          ::Leftovers::ValueProcessors::Keyword.new(
-            ::Leftovers::MatcherBuilders::NodePairName.build(value),
-            then_processor
+          ::Leftovers::Processors::MatchCurrentNode.new(
+            ::Leftovers::MatcherBuilders::NodeName.build(value), then_processor
           )
         # :nocov:
         else raise Leftovers::UnexpectedCase, "Unhandled value #{value.inspect}"
           # :nocov:
         end
+
+        ::Leftovers::Processors::EachKeyword.new(then_processor)
       end
     end
   end

data/lib/leftovers/processor_builders/keyword_argument.rb

@@ -4,8 +4,10 @@ module Leftovers
   module ProcessorBuilders
     module KeywordArgument
       def self.build(pattern, then_processor)
-        ::Leftovers::ValueProcessors::KeywordArgument.new(
-          ::Leftovers::MatcherBuilders::NodePairName.build(pattern),
+        ::Leftovers::Processors::KeywordArgument.new(
+          ::Leftovers::MatcherBuilders::NodePairKey.build(
+            ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+          ),
           then_processor
         )
       end

data/lib/leftovers/processor_builders/receiver.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module ProcessorBuilders
+    module Receiver
+      def self.build(value, then_processor)
+        return unless value
+
+        ::Leftovers::Processors::Receiver.new(then_processor)
+      end
+    end
+  end
+end

data/lib/leftovers/processor_builders/transform.rb

@@ -3,51 +3,62 @@
 module Leftovers
   module ProcessorBuilders
     module Transform
-      def self.build(transform, argument, then_processor) # rubocop:disable Metrics
-        case transform.to_s
-        when 'original', nil
+      def self.build(transform, arguments, then_processor) # rubocop:disable Metrics
+        case transform
+        when :original, nil
           then_processor
-        when 'downcase'
-          ::Leftovers::ValueProcessors::Downcase.new(then_processor)
-        when 'upcase'
-          ::Leftovers::ValueProcessors::Upcase.new(then_processor)
-        when 'capitalize'
-          ::Leftovers::ValueProcessors::Capitalize.new(then_processor)
-        when 'swapcase'
-          ::Leftovers::ValueProcessors::Swapcase.new(then_processor)
-        when 'pluralize'
-          ::Leftovers::ValueProcessors::Pluralize.new(then_processor)
-        when 'singularize'
-          ::Leftovers::ValueProcessors::Singularize.new(then_processor)
-        when 'camelize'
-          ::Leftovers::ValueProcessors::Camelize.new(then_processor)
-        when 'titleize'
-          ::Leftovers::ValueProcessors::Titleize.new(then_processor)
-        when 'demodulize'
-          ::Leftovers::ValueProcessors::Demodulize.new(then_processor)
-        when 'deconstantize'
-          ::Leftovers::ValueProcessors::Deconstantize.new(then_processor)
-        when 'parameterize'
-          ::Leftovers::ValueProcessors::Parameterize.new(then_processor)
-        when 'underscore'
-          ::Leftovers::ValueProcessors::Underscore.new(then_processor)
-        when 'split'
-          ::Leftovers::ValueProcessors::Split.new(argument, then_processor)
-        when 'delete_before'
-          ::Leftovers::ValueProcessors::DeleteBefore.new(argument, then_processor)
-        when 'delete_after'
-          ::Leftovers::ValueProcessors::DeleteAfter.new(argument, then_processor)
-        when 'add_prefix'
-          ::Leftovers::ProcessorBuilders::AddPrefix.build(argument, then_processor)
-        when 'add_suffix'
-          ::Leftovers::ProcessorBuilders::AddSuffix.build(argument, then_processor)
-        when 'delete_prefix'
-          ::Leftovers::ValueProcessors::DeletePrefix.new(argument, then_processor)
-        when 'delete_suffix'
-          ::Leftovers::ValueProcessors::DeleteSuffix.new(argument, then_processor)
-        # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
-          # :nocov:
+        when :downcase
+          ::Leftovers::Processors::Downcase.new(then_processor)
+        when :upcase
+          ::Leftovers::Processors::Upcase.new(then_processor)
+        when :capitalize
+          ::Leftovers::Processors::Capitalize.new(then_processor)
+        when :swapcase
+          ::Leftovers::Processors::Swapcase.new(then_processor)
+        when :pluralize
+          ::Leftovers::Processors::Pluralize.new(then_processor)
+        when :singularize
+          ::Leftovers::Processors::Singularize.new(then_processor)
+        when :camelize
+          ::Leftovers::Processors::Camelize.new(then_processor)
+        when :titleize
+          ::Leftovers::Processors::Titleize.new(then_processor)
+        when :demodulize
+          ::Leftovers::Processors::Demodulize.new(then_processor)
+        when :deconstantize
+          ::Leftovers::Processors::Deconstantize.new(then_processor)
+        when :parameterize
+          ::Leftovers::Processors::Parameterize.new(then_processor)
+        when :underscore
+          ::Leftovers::Processors::Underscore.new(then_processor)
+        when :transforms
+          ::Leftovers::ProcessorBuilders::TransformSet.build(arguments, then_processor)
+        else
+          ::Leftovers::ProcessorBuilders::Each.each_or_self(arguments) do |argument|
+            case transform
+            when :split
+              ::Leftovers::Processors::Split.new(argument, then_processor)
+            when :delete_before
+              ::Leftovers::Processors::DeleteBefore.new(argument, then_processor)
+            when :delete_before_last
+              ::Leftovers::Processors::DeleteBeforeLast.new(argument, then_processor)
+            when :delete_after
+              ::Leftovers::Processors::DeleteAfter.new(argument, then_processor)
+            when :delete_after_last
+              ::Leftovers::Processors::DeleteAfterLast.new(argument, then_processor)
+            when :add_prefix
+              ::Leftovers::ProcessorBuilders::AddPrefix.build(argument, then_processor)
+            when :add_suffix
+              ::Leftovers::ProcessorBuilders::AddSuffix.build(argument, then_processor)
+            when :delete_prefix
+              ::Leftovers::Processors::DeletePrefix.new(argument, then_processor)
+            when :delete_suffix
+              ::Leftovers::Processors::DeleteSuffix.new(argument, then_processor)
+            # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{transform.to_s.inspect}"
+              # :nocov:
+            end
+          end
         end
       end
     end