leftovers 0.8.0 → 0.11.0

data/lib/leftovers/matchers.rb

@@ -10,13 +10,16 @@ module Leftovers
       :NodeHasAnyPositionalArgumentWithValue,
       "#{__dir__}/matchers/node_has_any_positional_argument_with_value"
     )
+    autoload(:NodeHasAnyReceiver, "#{__dir__}/matchers/node_has_any_receiver")
     autoload(
       :NodeHasPositionalArgumentWithValue,
       "#{__dir__}/matchers/node_has_positional_argument_with_value"
     )
     autoload(:NodeHasPositionalArgument, "#{__dir__}/matchers/node_has_positional_argument")
     autoload(:NodeHasReceiver, "#{__dir__}/matchers/node_has_receiver")
+    autoload(:NodeIsProc, "#{__dir__}/matchers/node_is_proc")
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
+    autoload(:NodePairKey, "#{__dir__}/matchers/node_pair_key")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
     autoload(:NodePrivacy, "#{__dir__}/matchers/node_privacy")
@@ -24,6 +27,6 @@ module Leftovers
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")
     autoload(:Or, "#{__dir__}/matchers/or")
-    autoload(:Predicate, "#{__dir__}/matchers/predicate")
+    autoload(:Path, "#{__dir__}/matchers/path")
   end
 end

data/lib/leftovers/merged_config.rb

@@ -5,12 +5,23 @@ require 'fast_ignore'
 
 module Leftovers
   class MergedConfig
+    MEMOIZED_IVARS = %i{
+      @exclude_paths
+      @include_paths
+      @test_paths
+      @precompilers
+      @dynamic
+      @keep
+      @test_only
+    }.freeze
+
     def initialize(load_defaults: false)
       @configs = []
       @loaded_configs = Set.new
       return unless load_defaults
 
       self << :ruby
+      self << :leftovers
       self << project_config
       self << project_todo
       load_bundled_gem_config
@@ -27,30 +38,6 @@ module Leftovers
       require_requires(config)
     end
 
-    def project_config
-      Leftovers::Config.new(:'.leftovers.yml', path: Leftovers.pwd + '.leftovers.yml')
-    end
-
-    def project_todo
-      Leftovers::Config.new(:'.leftovers_todo.yml', path: Leftovers.pwd + '.leftovers_todo.yml')
-    end
-
-    MEMOIZED_IVARS = %i{
-      @exclude_paths
-      @include_paths
-      @test_paths
-      @precompilers
-      @dynamic
-      @keep
-      @test_only
-    }.freeze
-
-    def unmemoize
-      MEMOIZED_IVARS.each do |ivar|
-        remove_instance_variable(ivar) if instance_variable_get(ivar)
-      end
-    end
-
     def exclude_paths
       @exclude_paths ||= @configs.flat_map(&:exclude_paths)
     end
@@ -68,7 +55,7 @@ module Leftovers
     end
 
     def dynamic
-      @dynamic ||= ::Leftovers::ProcessorBuilders::EachDynamic.build(@configs.map(&:dynamic))
+      @dynamic ||= ::Leftovers::ProcessorBuilders::Each.build(@configs.map(&:dynamic))
     end
 
     def keep
@@ -81,6 +68,20 @@ module Leftovers
 
     private
 
+    def project_config
+      Leftovers::Config.new(:'.leftovers.yml', path: Leftovers.pwd + '.leftovers.yml')
+    end
+
+    def project_todo
+      Leftovers::Config.new(:'.leftovers_todo.yml', path: Leftovers.pwd + '.leftovers_todo.yml')
+    end
+
+    def unmemoize
+      MEMOIZED_IVARS.each do |ivar|
+        remove_instance_variable(ivar) if instance_variable_get(ivar)
+      end
+    end
+
     def require_requires(config)
       config.requires.each do |req|
         if req.is_a?(Hash) && req[:quiet]

data/lib/leftovers/parser.rb

@@ -10,14 +10,17 @@ module Leftovers
       # but with our parser
       def parse_with_comments(string, file = '(string)', line = 1)
         PARSER.reset
-        source_buffer = ::Parser::CurrentRuby.send(
-          :setup_source_buffer, file, line, string, PARSER.default_encoding
-        )
-        PARSER.parse_with_comments(source_buffer)
+        PARSER.parse_with_comments(new_source_buffer(string, file, line))
       end
 
       private
 
+      def new_source_buffer(string, file, line)
+        ::Parser::CurrentRuby.send(
+          :setup_source_buffer, file, line, string, PARSER.default_encoding
+        )
+      end
+
       # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
       # but with our builder
       def parser

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