leftovers 0.6.0 → 0.9.0

data/lib/leftovers/matcher_builders/node.rb

@@ -3,41 +3,71 @@
 module Leftovers
   module MatcherBuilders
     module Node
-      def self.build(pattern)
-        ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
-          case pat
-          when ::String
-            ::Leftovers::MatcherBuilders::NodeName.build(pat)
-          when ::Hash
-            build_from_hash(**pat)
-            # :nocov:
-          else raise
-            # :nocov:
+      class << self
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
+            case pattern
+            when ::String then ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+            when ::Hash then build_from_hash(**pattern)
+              # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.build_from_hash( # rubocop:disable Metrics/ParameterLists, Metrics/MethodLength
-        names: nil, match: nil, has_prefix: nil, has_suffix: nil,
-        document: false,
-        paths: nil,
-        has_arguments: nil,
-        has_receiver: nil,
-        unless_arg: nil
-      )
-        ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::MatcherBuilders::NodeName.build([
-            names,
-            { match: match, has_prefix: has_prefix, has_suffix: has_suffix }.compact
-          ]),
-          ::Leftovers::MatcherBuilders::Document.build(document),
-          ::Leftovers::MatcherBuilders::NodePath.build(paths),
-          ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
-          ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+        def build_from_hash( # rubocop:disable Metrics/ParameterLists
+          names: nil, match: nil, has_prefix: nil, has_suffix: nil,
+          document: false,
+          paths: nil,
+          has_arguments: nil,
+          has_receiver: nil,
+          type: nil,
+          privacy: nil,
+          unless_arg: nil, all: nil, any: nil
+        )
+          ::Leftovers::MatcherBuilders::And.build([
+            build_node_name_matcher(names, match, has_prefix, has_suffix),
+            ::Leftovers::MatcherBuilders::Document.build(document),
+            ::Leftovers::MatcherBuilders::NodePath.build(paths),
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
+            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+            ::Leftovers::MatcherBuilders::NodePrivacy.build(privacy),
+            ::Leftovers::MatcherBuilders::NodeType.build(type),
+            build_unless_matcher(unless_arg), build_all_matcher(all), build_any_matcher(any)
+          ])
+        end
+
+        private
+
+        def build_node_name_matcher(names, match, has_prefix, has_suffix)
+          ::Leftovers::MatcherBuilders::Or.build([
+            ::Leftovers::MatcherBuilders::NodeName.build(names),
+            ::Leftovers::MatcherBuilders::NodeName.build(
+              match: match, has_prefix: has_prefix, has_suffix: has_suffix
+            )
+          ])
+        end
+
+        def build_unless_matcher(unless_arg)
+          return unless unless_arg
+
           ::Leftovers::MatcherBuilders::Unless.build(
-            (::Leftovers::MatcherBuilders::Node.build(unless_arg) if unless_arg)
+            ::Leftovers::MatcherBuilders::Node.build(unless_arg)
           )
-        ])
+        end
+
+        def build_all_matcher(all)
+          return unless all
+
+          ::Leftovers::MatcherBuilders::And.build(
+            all.map { |pattern| ::Leftovers::MatcherBuilders::Node.build(pattern) }
+          )
+        end
+
+        def build_any_matcher(any)
+          ::Leftovers::MatcherBuilders::Node.build(any)
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -3,71 +3,67 @@
 module Leftovers
   module MatcherBuilders
     module NodeHasArgument
-      def self.build(patterns) # rubocop:disable Metrics/MethodLength
-        ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
-          case pat
-          when ::String
-            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(pat, nil)
-          when ::Integer
-            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(pat, nil)
-          when ::Hash
-            build_from_hash(**pat)
-          # :nocov:
-          else
-            raise
+      class << self
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+            case pat
+            when ::String
+              ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(pat, nil)
+            when ::Integer
+              ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(pat, nil)
+            when ::Hash then build_from_hash(**pat)
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.separate_argument_types(at) # rubocop:disable Metrics/MethodLength
-        keys = []
-        positions = []
+        private
 
-        ::Leftovers.each_or_self(at) do |k|
-          case k
-          when '*', ::Integer
-            positions << k
-          when ::String, ::Hash
-            keys << k
-          # :nocov:
-          else raise
-            # :nocov:
-          end
-        end
+        def build_from_hash(at: nil, has_value: nil, unless_arg: nil)
+          value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
 
-        keys = nil if keys.empty?
-        positions = nil if positions.empty?
+          ::Leftovers::MatcherBuilders::AndNot.build(
+            build_argument_matcher(value_matcher, **separate_argument_types(at)),
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
+          )
+        end
 
-        [keys, positions]
-      end
+        def separate_argument_types(at)
+          groups = ::Leftovers.each_or_self(at).group_by do |index|
+            case index
+            when '*', ::Integer then :positions
+            when ::String, ::Hash then :keys
+            # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{index.inspect}"
+              # :nocov:
+            end
+          end
 
-      def self.build_from_hash( # rubocop:disable Metrics/MethodLength
-        at: nil,
-        has_value: nil,
-        unless_arg: nil
-      )
-        keys, positions = separate_argument_types(at)
+          groups.transform_values { |v| Leftovers.unwrap_array(v) }
+        end
 
-        value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
-        matcher = if (keys && positions) || (!keys && !positions)
-          ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher),
-            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
-          ])
-        elsif keys
+        def build_has_keyword_argument(keys, value_matcher)
           ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
-        elsif positions
+        end
+
+        def build_has_positional_argument(positions, value_matcher)
           ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
-          # :nocov:
-        else
-          raise
-          # :nocov:
         end
 
-        ::Leftovers::MatcherBuilders::AndNot.build(
-          matcher, ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
-        )
+        def build_argument_matcher(value_matcher, keys: nil, positions: nil)
+          if keys && !positions
+            build_has_keyword_argument(keys, value_matcher)
+          elsif positions && !keys
+            build_has_positional_argument(positions, value_matcher)
+          else
+            ::Leftovers::MatcherBuilders::Or.build([
+              build_has_positional_argument(positions, value_matcher),
+              build_has_keyword_argument(keys, value_matcher)
+            ])
+          end
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -4,22 +4,27 @@ module Leftovers
   module MatcherBuilders
     module NodeHasKeywordArgument
       class << self
-        def build(keywords, value_matcher) # rubocop:disable Metrics/MethodLength
+        def build(keywords, value_matcher)
           value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
-          keyword_matcher = if ::Leftovers.each_or_self(keywords).include?('**')
-            ::Leftovers::Matchers::NodeType.new(:pair)
-          else
-            ::Leftovers::MatcherBuilders::NodePairName.build(keywords)
-          end
+          keyword_matcher = build_keyword_matcher(keywords)
+          pair_matcher = ::Leftovers::MatcherBuilders::And.build([keyword_matcher, value_matcher])
 
-          pair_matcher = ::Leftovers::MatcherBuilders::And.build([
-            keyword_matcher, value_matcher
-          ])
-
-          return nil unless pair_matcher
+          return unless pair_matcher
 
           ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
         end
+
+        private
+
+        def build_keyword_matcher(keywords)
+          if ::Leftovers.each_or_self(keywords).include?('**')
+            ::Leftovers::Matchers::NodeType.new(:pair)
+          else
+            ::Leftovers::MatcherBuilders::NodePairKey.build(
+              ::Leftovers::MatcherBuilders::Node.build(keywords)
+            )
+          end
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -4,22 +4,36 @@ module Leftovers
   module MatcherBuilders
     module NodeHasPositionalArgument
       class << self
-        def build(positions, value_matcher) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
-          if positions && value_matcher
-            ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |pos|
-              if pos == '*'
-                ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
-              else
-                ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(pos, value_matcher)
-              end
-            end
-          elsif positions
-            pos = 0 if ::Leftovers.each_or_self(positions).include?('*')
-            pos ||= ::Leftovers.each_or_self(positions).min
-
-            ::Leftovers::Matchers::NodeHasPositionalArgument.new(pos)
+        def build(positions, value_matcher)
+          if positions && !all_positions?(positions) && value_matcher
+            build_has_positional_value_matcher(positions, value_matcher)
+          elsif positions && !value_matcher
+            build_has_position_matcher(positions)
           elsif value_matcher
-            ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+            build_has_any_positional_value_matcher(value_matcher)
+          end
+        end
+
+        private
+
+        def all_positions?(positions)
+          ::Leftovers.each_or_self(positions).include?('*')
+        end
+
+        def build_has_position_matcher(positions)
+          position = 0 if all_positions?(positions)
+          position ||= ::Leftovers.each_or_self(positions).min
+
+          ::Leftovers::Matchers::NodeHasPositionalArgument.new(position)
+        end
+
+        def build_has_any_positional_value_matcher(value_matcher)
+          ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+        end
+
+        def build_has_positional_value_matcher(positions, value_matcher)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |position|
+            ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(position, value_matcher)
           end
         end
       end

data/lib/leftovers/matcher_builders/node_pair_key.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePairKey
+      def self.build(key_matcher)
+        return unless key_matcher
+
+        ::Leftovers::MatcherBuilders::And.build([
+          ::Leftovers::Matchers::NodeType.new(:pair),
+          ::Leftovers::Matchers::NodePairKey.new(key_matcher)
+        ])
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_privacy.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodePrivacy
+      def self.build(privacy_settings)
+        ::Leftovers::MatcherBuilders::Or.each_or_self(privacy_settings) do |privacy|
+          ::Leftovers::Matchers::NodePrivacy.new(privacy)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -8,18 +8,18 @@ module Leftovers
       def self.build(types_pattern) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         ::Leftovers::MatcherBuilders::Or.each_or_self(types_pattern) do |type|
           case type
-          when 'Symbol' then ::Leftovers::Matchers::NodeType.new(:sym)
-          when 'String' then ::Leftovers::Matchers::NodeType.new(:str)
-          when 'Integer' then ::Leftovers::Matchers::NodeType.new(:int)
-          when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
-          when 'Array' then ::Leftovers::Matchers::NodeType.new(:array)
-          when 'Hash' then ::Leftovers::Matchers::NodeType.new(:hash)
-
-          when 'Proc' then ::Leftovers::Matchers::Predicate.new(:proc?)
-          # when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def])
-          # when 'Constant' then ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module])
+          when :Symbol then ::Leftovers::Matchers::NodeType.new(:sym)
+          when :String then ::Leftovers::Matchers::NodeType.new(:str)
+          when :Integer then ::Leftovers::Matchers::NodeType.new(:int)
+          when :Float then ::Leftovers::Matchers::NodeType.new(:float)
+          when :Array then ::Leftovers::Matchers::NodeType.new(:array)
+          when :Hash then ::Leftovers::Matchers::NodeType.new(:hash)
+          when :Proc then ::Leftovers::Matchers::NodeIsProc
+          when :Method then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def, :defs])
+          when :Constant
+            ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module, :casgn])
           # :nocov:
-          else raise
+          else raise Leftovers::UnexpectedCase, "Unhandled value #{type.inspect}"
             # :nocov:
           end
         end

data/lib/leftovers/matcher_builders/node_value.rb

@@ -4,17 +4,17 @@ module Leftovers
   module MatcherBuilders
     module NodeValue
       class << self
-        def build(pattern) # rubocop:disable Metrics/MethodLength
-          ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
-            case pat
-            when ::Integer, true, false, nil
-              ::Leftovers::Matchers::NodeScalarValue.new(pat)
-            when ::String
-              ::Leftovers::MatcherBuilders::NodeName.build(pat)
-            when ::Hash
-              build_from_hash(**pat)
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
+            case pattern
+            when ::Integer, ::Float, true, false
+              # matching scalar on nil will fall afoul of compact and each_or_self etc.
+              ::Leftovers::Matchers::NodeScalarValue.new(pattern)
+            when :_leftovers_nil_value then ::Leftovers::Matchers::NodeType.new(:nil)
+            when ::String then ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+            when ::Hash then build_from_hash(**pattern)
             # :nocov:
-            else raise
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
             end
           end
@@ -22,27 +22,46 @@ module Leftovers
 
         private
 
-        def build_from_hash( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
-          at: nil, has_value: nil,
-          match: nil, has_prefix: nil, has_suffix: nil,
+        def build_node_name_matcher(names, match, has_prefix, has_suffix)
+          ::Leftovers::MatcherBuilders::Or.build([
+            ::Leftovers::MatcherBuilders::NodeName.build(names),
+            ::Leftovers::MatcherBuilders::NodeName.build(
+              match: match, has_prefix: has_prefix, has_suffix: has_suffix
+            )
+          ])
+        end
+
+        def build_node_has_argument_matcher(has_arguments, at, has_value)
+          ::Leftovers::MatcherBuilders::Or.build([
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(
+              at: at, has_value: has_value
+            )
+          ])
+        end
+
+        def build_unless(unless_arg)
+          return unless unless_arg
+
+          ::Leftovers::MatcherBuilders::Unless.build(
+            ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
+          )
+        end
+
+        def build_from_hash( # rubocop:disable Metrics/ParameterLists
+          has_arguments: nil, at: nil, has_value: nil,
+          names: nil, match: nil, has_prefix: nil, has_suffix: nil,
           type: nil,
           has_receiver: nil,
           unless_arg: nil
         )
-          matcher = ::Leftovers::MatcherBuilders::And.build([
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(
-              at: at, has_value: has_value
-            ),
-            ::Leftovers::MatcherBuilders::NodeName.build(
-              match: match, has_prefix: has_prefix, has_suffix: has_suffix
-            ),
+          ::Leftovers::MatcherBuilders::And.build([
+            build_node_has_argument_matcher(has_arguments, at, has_value),
+            build_node_name_matcher(names, match, has_prefix, has_suffix),
             ::Leftovers::MatcherBuilders::NodeType.build(type),
-            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver)
+            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+            build_unless(unless_arg)
           ])
-
-          ::Leftovers::MatcherBuilders::AndNot.build(
-            matcher, ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
-          )
         end
       end
     end

data/lib/leftovers/matcher_builders/or.rb

@@ -5,68 +5,83 @@ require 'set'
 module Leftovers
   module MatcherBuilders
     module Or
-      def self.each_or_self(value, &block)
-        case value
-        when nil then nil
-        when Array then build(value.map(&block))
-        else build([yield(value)])
+      class << self
+        def each_or_self(value, &block)
+          case value
+          when nil then nil
+          when Array then build(value.map(&block))
+          else build([yield(value)])
+          end
         end
-      end
 
-      def self.build(matchers)
-        matchers = compact(matchers)
-        case matchers.length
-          # :nocov:
-        when 0 then nil
-          # :nocov:
-        when 1 then matchers.first
-        when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
-        else ::Leftovers::Matchers::Any.new(matchers.dup)
+        def build(matchers)
+          matchers = compact(matchers)
+          case matchers.length
+            # :nocov:
+          when 0 then nil
+            # :nocov:
+          when 1 then matchers.first
+          when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
+          else ::Leftovers::Matchers::Any.new(matchers.dup)
+          end
         end
-      end
 
-      def self.flatten(value) # rubocop:disable Metrics/MethodLength
-        case value
-        when ::Leftovers::Matchers::Or
-          [*flatten(value.lhs), *flatten(value.rhs)]
-        when ::Leftovers::Matchers::Any
-          flatten(value.matchers)
-        when Array
-          ret = value.map { |v| flatten(v) }
-          ret.flatten!(1)
-          ret
-        else
-          value
+        private
+
+        def flatten(value)
+          case value
+          when ::Leftovers::Matchers::Or
+            [*flatten(value.lhs), *flatten(value.rhs)]
+          when ::Leftovers::Matchers::Any
+            flatten(value.matchers)
+          when Array, Set
+            value.flat_map { |v| flatten(v) }
+          else
+            [value]
+          end
         end
-      end
 
-      def self.compact(matchers) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize,
-        return matchers if matchers.length <= 1
+        def group_by_compactable(matchers)
+          groups = matchers.group_by do |matcher|
+            case matcher
+            when ::Integer, ::Symbol, true, false then :set
+            when ::Regexp then :regexp
+            when nil then :nil
+            else matcher.class.to_s.to_sym
+            end
+          end
 
-        set = Set.new
-        regexps = []
-        uncompactable = []
+          groups.transform_values { |v| Leftovers.unwrap_array(v) }
+        end
 
-        matchers = flatten(matchers)
+        def mergeable?(matcher)
+          matcher.respond_to?(:matcher)
+        end
 
-        matchers.each do |matcher|
-          case matcher
-          when nil then nil
-          when ::Integer, ::Symbol then set << matcher
-          # when ::Set then set.merge(matcher) # may not be necessary
-          when ::Regexp then regexps << matcher
-          else uncompactable << matcher
-          end
+        def build_grouped_for_matcher(matchers)
+          return matchers unless matchers.is_a?(Array)
+          return matchers unless mergeable?(matchers.first)
+
+          matchers.first.class.new(build(matchers.map(&:matcher)))
         end
 
-        set = set.first if set.length <= 1
-        regexps = if regexps.length <= 1
-          regexps.first
-        else
-          Regexp.union(regexps)
+        def build_grouped(set: nil, regexp: nil, nil: nil, **matcher_classes) # rubocop:disable Lint/UnusedMethodArgument i want to throw away nils
+          set = set.to_set.compare_by_identity if set.is_a?(Array)
+          regexp = Regexp.union(regexp) if regexp.is_a?(Array)
+          matcher_classes = matcher_classes.each_value.flat_map do |matchers|
+            build_grouped_for_matcher(matchers)
+          end
+
+          [set, regexp].compact.concat(matcher_classes).uniq
         end
 
-        [set, regexps].compact.concat(uncompactable)
+        def compact(matchers)
+          matchers = flatten(matchers)
+
+          return matchers if matchers.length <= 1
+
+          build_grouped(**group_by_compactable(matchers))
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/path.rb

@@ -8,7 +8,9 @@ module Leftovers
       def self.build(path_pattern)
         return if path_pattern.nil? || path_pattern.empty?
 
-        ::FastIgnore.new(include_rules: path_pattern, gitignore: false, root: Leftovers.pwd)
+        ::Leftovers::Matchers::Path.new(
+          ::FastIgnore.new(include_rules: path_pattern, gitignore: false, root: Leftovers.pwd)
+        )
       end
     end
   end

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -3,15 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module StringPattern
-      def self.build(match: nil, has_prefix: nil, has_suffix: nil)
-        if match
+      def self.build(match: nil, has_prefix: nil, has_suffix: nil) # rubocop:disable Metrics
+        has_prefix = ::Regexp.escape(has_prefix) if has_prefix
+        has_suffix = ::Regexp.escape(has_suffix) if has_suffix
+
+        if match && has_prefix && has_suffix
+          /\A(?=#{match}\z)(?=#{has_prefix}).*#{has_suffix}\z/
+        elsif match && has_prefix
+          /\A(?=#{match}\z)#{has_prefix}/
+        elsif match && has_suffix
+          /\A(?=#{match}\z).*#{has_suffix}\z/
+        elsif match
           /\A#{match}\z/
         elsif has_prefix && has_suffix
-          /\A#{::Regexp.escape(has_prefix)}.*#{::Regexp.escape(has_suffix)}\z/
+          /\A(?=#{has_prefix}).*#{has_suffix}\z/
         elsif has_prefix
-          /\A#{::Regexp.escape(has_prefix)}/
+          /\A#{has_prefix}/
         elsif has_suffix
-          /#{::Regexp.escape(has_suffix)}\z/
+          /#{has_suffix}\z/
         end
       end
     end

data/lib/leftovers/matcher_builders.rb

@@ -12,9 +12,10 @@ module Leftovers
     autoload(:NodeHasPositionalArgument, "#{__dir__}/matcher_builders/node_has_positional_argument")
     autoload(:NodeHasReceiver, "#{__dir__}/matcher_builders/node_has_receiver")
     autoload(:NodeName, "#{__dir__}/matcher_builders/node_name")
-    autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
+    autoload(:NodePairKey, "#{__dir__}/matcher_builders/node_pair_key")
     autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
+    autoload(:NodePrivacy, "#{__dir__}/matcher_builders/node_privacy")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
     autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")