leftovers 0.4.2 → 0.5.2

data/lib/leftovers/config_validator/schema_hash.rb

@@ -36,8 +36,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/string' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             },
             { '$ref' => '#/definitions/string' }
           ]
@@ -65,8 +64,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/name' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             },
             { '$ref' => '#/definitions/name' }
           ]
@@ -84,14 +82,13 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/argumentPosition' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
         'valueType' => {
           'type' => 'string',
-          'enum' => %w{String Symbol Integer Float}
+          'enum' => %w{String Symbol Integer Float Array Hash Proc}
         },
         'valueTypeList' => {
           'anyOf' => [
@@ -99,8 +96,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/valueType' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -110,7 +106,41 @@ module Leftovers
             { 'type' => 'integer' },
             { 'type' => 'number' },
             { 'type' => 'boolean' },
-            { 'type' => 'null' }
+            { 'type' => 'null' },
+            { 'allOf' => [
+              { '$ref' => '#/definitions/stringPattern' },
+              {
+                'type' => 'object',
+                'properties' => {
+                  'match' => true, 'matches' => true,
+                  'has_prefix' => true, 'has_suffix' => true,
+                  'at' => { '$ref' => '#/definitions/argumentPositionList' },
+                  'has_value' => { '$ref' => '#/definitions/hasValueList' },
+                  'has_receiver' => { '$ref' => '#/definitions/hasValueList' },
+                  'type' => { '$ref' => '#/definitions/valueTypeList' },
+                  'unless' => { '$ref' => '#/definitions/hasValueList' }
+                },
+                'minProperties' => 1,
+                'additionalProperties' => false,
+                'allOf' => [
+                  # incompatible groups
+                  { 'not' => { 'required' => %w{match at} } },
+                  { 'not' => { 'required' => %w{match has_value} } },
+                  { 'not' => { 'required' => %w{match type} } },
+                  { 'not' => { 'required' => %w{matches at} } },
+                  { 'not' => { 'required' => %w{matches has_value} } },
+                  { 'not' => { 'required' => %w{matches type} } },
+                  { 'not' => { 'required' => %w{has_prefix at} } },
+                  { 'not' => { 'required' => %w{has_prefix has_value} } },
+                  { 'not' => { 'required' => %w{has_prefix type} } },
+                  { 'not' => { 'required' => %w{has_suffix at} } },
+                  { 'not' => { 'required' => %w{has_suffix has_value} } },
+                  { 'not' => { 'required' => %w{has_suffix type} } },
+                  { 'not' => { 'required' => %w{at type} } },
+                  { 'not' => { 'required' => %w{has_value type} } }
+                ]
+              }
+            ] }
           ]
         },
         'hasValueList' => {
@@ -119,8 +149,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/hasValue' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -133,11 +162,14 @@ module Leftovers
               'properties' => {
                 'at' => { '$ref' => '#/definitions/argumentPositionList' },
                 'has_value' => { '$ref' => '#/definitions/hasValueList' },
-                'has_value_type' => { '$ref' => '#/definitions/valueTypeList' },
                 'unless' => { '$ref' => '#/definitions/hasArgumentList' }
               },
               'minProperties' => 1,
-              'additionalProperties' => false
+              'additionalProperties' => false,
+              'allOf' => [
+                # synonyms
+                { 'not' => { 'required' => %w{has_argument has_arguments} } }
+              ]
             }
           ]
         },
@@ -147,8 +179,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/hasArgument' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -160,7 +191,8 @@ module Leftovers
             'path' => { '$ref' => '#/definitions/stringList' },
             'paths' => { '$ref' => '#/definitions/stringList' },
             'has_argument' => { '$ref' => '#/definitions/hasArgumentList' },
-            'has_arguments' => { '$ref' => '#/definitions/hasArgumentList' }
+            'has_arguments' => { '$ref' => '#/definitions/hasArgumentList' },
+            'has_receiver' => { '$ref' => '#/definitions/hasValueList' }
           },
           'minProperties' => 1,
           'allOf' => [
@@ -260,8 +292,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/transform' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -276,8 +307,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/keyword' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -346,8 +376,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/action' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             }
           ]
         },
@@ -377,8 +406,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/ruleMatcher' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             },
             { '$ref' => '#/definitions/ruleMatcher' }
           ]
@@ -390,6 +418,7 @@ module Leftovers
               { 'required' => ['name'] }, { 'required' => ['names'] },
               { 'required' => ['path'] }, { 'required' => ['paths'] },
               { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+              { 'required' => ['has_receiver'] },
               { 'required' => ['unless'] }
             ] },
             {
@@ -399,6 +428,7 @@ module Leftovers
                 'name' => true, 'names' => true,
                 'path' => true, 'paths' => true,
                 'has_argument' => true, 'has_arguments' => true,
+                'has_receiver' => true,
                 'unless' => { '$ref' => '#/definitions/ruleMatcherList' }
 
               },
@@ -415,6 +445,7 @@ module Leftovers
               { 'required' => ['name'] }, { 'required' => ['names'] },
               { 'required' => ['path'] }, { 'required' => ['paths'] },
               { 'required' => ['has_argument'] }, { 'required' => ['has_arguments'] },
+              { 'required' => ['has_receiver'] },
               { 'required' => ['unless'] }
             ] },
             {
@@ -424,6 +455,7 @@ module Leftovers
                 'name' => true, 'names' => true,
                 'path' => true, 'paths' => true,
                 'has_argument' => true, 'has_arguments' => true,
+                'has_receiver' => true,
                 'unless' => { '$ref' => '#/definitions/ruleMatcherList' },
 
                 'call' => true, 'calls' => true,
@@ -439,8 +471,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/dynamic' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             },
             { '$ref' => '#/definitions/dynamic' }
           ]
@@ -460,6 +491,7 @@ module Leftovers
                     'has_prefix' => true, 'has_suffix' => true, 'matches' => true,
                     'path' => true, 'paths' => true,
                     'has_argument' => true, 'has_arguments' => true,
+                    'has_receiver' => true,
                     'unless' => { '$ref' => '#/definitions/keepTestOnlyList' }
                   },
                   'additionalProperties' => false,
@@ -474,8 +506,7 @@ module Leftovers
             {
               'type' => 'array',
               'items' => { '$ref' => '#/definitions/keepTestOnly' },
-              'minItems' => 1,
-              'uniqueItems' => true
+              'minItems' => 1
             },
             { '$ref' => '#/definitions/keepTestOnly' }
           ]
@@ -485,6 +516,8 @@ module Leftovers
         'include_paths' => { '$ref' => '#/definitions/stringList' },
         'exclude_paths' => { '$ref' => '#/definitions/stringList' },
         'test_paths' => { '$ref' => '#/definitions/stringList' },
+        'haml_paths' => { '$ref' => '#/definitions/stringList' },
+        'erb_paths' => { '$ref' => '#/definitions/stringList' },
         'requires' => { '$ref' => '#/definitions/stringList' },
         'gems' => { '$ref' => '#/definitions/stringList' },
         'keep' => { '$ref' => '#/definitions/keepTestOnlyList' },

data/lib/leftovers/definition.rb

@@ -2,7 +2,7 @@
 
 module Leftovers
   class Definition
-    attr_reader :name, :test, :location_s
+    attr_reader :name, :test, :location_s, :source_line
     alias_method :names, :name
 
     alias_method :test?, :test
@@ -14,7 +14,7 @@ module Leftovers
     )
       @name = name
       @path = location.source_buffer.name.to_s
-      @location_source_line = location.source_line.to_s
+      @source_line = location.source_line.to_s
       @location_column_range_begin = location.column_range.begin.to_i
       @location_column_range_end = location.column_range.end.to_i
       @location_source = location.source.to_s
@@ -29,9 +29,9 @@ module Leftovers
     end
 
     def highlighted_source(highlight = "\e[31m", normal = "\e[0m")
-      @location_source_line[0...@location_column_range_begin].lstrip +
+      @source_line[0...@location_column_range_begin].lstrip +
         highlight + @location_source + normal +
-        @location_source_line[@location_column_range_end..-1].rstrip
+        @source_line[@location_column_range_end..-1].rstrip
     end
 
     def in_collection?

data/lib/leftovers/erb.rb

@@ -10,11 +10,11 @@ module Leftovers
     end
 
     def add_insert_cmd(out, content) # leftovers:keep
-      out.push("#{content}\n")
+      out.push("\n#{content}\n")
     end
 
     def add_put_cmd(out, _content) # leftovers:keep
-      out
+      out.push("\n")
     end
   end
 end

data/lib/leftovers/file.rb

@@ -15,10 +15,9 @@ module Leftovers
     end
 
     def ruby
-      case extname
-      when '.haml'
+      if Leftovers.config.haml_paths.allowed?(relative_path)
         ::Leftovers::Haml.precompile(read, self)
-      when '.rhtml', '.rjs', '.erb'
+      elsif Leftovers.config.erb_paths.allowed?(relative_path)
         ::Leftovers::ERB.precompile(read)
       else
         read

data/lib/leftovers/matcher_builders/node.rb

@@ -21,6 +21,7 @@ module Leftovers
         names: nil, match: nil, has_prefix: nil, has_suffix: nil,
         paths: nil,
         has_arguments: nil,
+        has_receiver: nil,
         unless_arg: nil
       )
         ::Leftovers::MatcherBuilders::And.build([
@@ -30,6 +31,7 @@ module Leftovers
           ]),
           ::Leftovers::MatcherBuilders::NodePath.build(paths),
           ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
+          ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
           ::Leftovers::MatcherBuilders::Unless.build(
             (::Leftovers::MatcherBuilders::Node.build(unless_arg) if unless_arg)
           )

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -26,6 +26,8 @@ module Leftovers
 
         ::Leftovers.each_or_self(at) do |k|
           case k
+          when '*'
+            positions << k
           when ::String, ::Hash
             keys << k
           when ::Integer
@@ -35,23 +37,25 @@ module Leftovers
             # :nocov:
           end
         end
+
         keys = nil if keys.empty?
         positions = nil if positions.empty?
 
         [keys, positions]
       end
 
-      def self.build_from_hash(at: nil, has_value: nil, has_value_type: nil, unless_arg: nil) # rubocop:disable Metrics/MethodLength
+      def self.build_from_hash( # rubocop:disable Metrics/MethodLength
+        at: nil,
+        has_value: nil,
+        unless_arg: nil
+      )
         keys, positions = separate_argument_types(at)
 
-        value_matcher = ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::MatcherBuilders::ArgumentNodeValue.build(has_value),
-          ::Leftovers::MatcherBuilders::NodeType.build(has_value_type)
-        ])
+        value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
         matcher = if (keys && positions) || (!keys && !positions)
           ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher),
-            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
+            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher),
+            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
           ])
         elsif keys
           ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -3,19 +3,23 @@
 module Leftovers
   module MatcherBuilders
     module NodeHasKeywordArgument
-      def self.build(keywords, value_matcher)
-        value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
-        keyword_matcher = ::Leftovers::MatcherBuilders::NodePairName.build(keywords)
+      class << self
+        def build(keywords, value_matcher) # rubocop:disable Metrics/MethodLength
+          value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
+          keyword_matcher = if ::Leftovers.each_or_self(keywords).any? { |x| x == '**' }
+            ::Leftovers::Matchers::NodeType.new(:pair)
+          else
+            ::Leftovers::MatcherBuilders::NodePairName.build(keywords)
+          end
 
-        pair_matcher = ::Leftovers::MatcherBuilders::And.build([
-          keyword_matcher, value_matcher
-        ])
-        # :nocov:
-        raise unless pair_matcher
+          pair_matcher = ::Leftovers::MatcherBuilders::And.build([
+            keyword_matcher, value_matcher
+          ])
 
-        # :nocov:
+          return nil unless pair_matcher
 
-        ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
+          ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -3,20 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module NodeHasPositionalArgument
-      def self.build(positions, value_matcher) # rubocop:disable Metrics/MethodLength
-        if positions && value_matcher
-          ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |position|
-            ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(position, value_matcher)
-          end
-        elsif positions
-          position = positions.is_a?(Array) ? positions.min : positions
+      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).any? { |x| x == '*' }
+            pos ||= ::Leftovers.each_or_self(positions).min
 
-          ::Leftovers::Matchers::NodeHasPositionalArgument.new(position)
-        elsif value_matcher
-          ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
-        # :nocov:
-        else raise
-          # :nocov:
+            ::Leftovers::Matchers::NodeHasPositionalArgument.new(pos)
+          elsif value_matcher
+            ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+          end
         end
       end
     end

data/lib/leftovers/matcher_builders/node_has_receiver.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasReceiver
+      class << self
+        def build(pattern)
+          matcher = ::Leftovers::MatcherBuilders::NodeValue.build(pattern)
+
+          ::Leftovers::Matchers::NodeHasReceiver.new(matcher) if matcher
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -5,18 +5,19 @@ require 'set'
 module Leftovers
   module MatcherBuilders
     module NodeType
-      def self.build(types_pattern)
+      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)
-          # these would be neat but i can't think of a use-case
-          # when 'Array' then :array
-          # when 'Hash' then :hash
-          # when 'Method' then Set[:send, :csend, :def]
-          # when 'Constant' then Set[:const, :class, :module]
+          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])
           # :nocov:
           else raise
             # :nocov:

data/lib/leftovers/matcher_builders/node_value.rb

@@ -0,0 +1,50 @@
+# frozen-string-literal: true
+
+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)
+            # :nocov:
+            else raise
+              # :nocov:
+            end
+          end
+        end
+
+        private
+
+        def build_from_hash( # rubocop:disable Metrics/MethodLength, Metrics/ParameterLists
+          at: nil, has_value: 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::NodeType.build(type),
+            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver)
+          ])
+
+          ::Leftovers::MatcherBuilders::AndNot.build(
+            matcher, ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders.rb

@@ -4,17 +4,18 @@ module Leftovers
   module MatcherBuilders
     autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
     autoload(:And, "#{__dir__}/matcher_builders/and")
-    autoload(:ArgumentNodeValue, "#{__dir__}/matcher_builders/argument_node_value")
     autoload(:Name, "#{__dir__}/matcher_builders/name")
+    autoload(:Node, "#{__dir__}/matcher_builders/node")
     autoload(:NodeHasArgument, "#{__dir__}/matcher_builders/node_has_argument")
     autoload(:NodeHasKeywordArgument, "#{__dir__}/matcher_builders/node_has_keyword_argument")
     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(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
-    autoload(:Node, "#{__dir__}/matcher_builders/node")
+    autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")
     autoload(:Path, "#{__dir__}/matcher_builders/path")
     autoload(:StringPattern, "#{__dir__}/matcher_builders/string_pattern")

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -14,7 +14,10 @@ module Leftovers
       end
 
       def ===(node)
-        node.positional_arguments.any? do |value|
+        args = node.positional_arguments
+        return false unless args
+
+        args.any? do |value|
           @matcher === value
         end
       end

data/lib/leftovers/matchers/node_has_positional_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(position)
         @position = position
 

data/lib/leftovers/matchers/node_has_receiver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasReceiver
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        receiver = node.receiver
+        @matcher === receiver if receiver
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/predicate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Predicate
+      def initialize(predicate)
+        @predicate = predicate
+
+        freeze
+      end
+
+      def ===(node)
+        node.send(@predicate)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -15,6 +15,7 @@ module Leftovers
       "#{__dir__}/matchers/node_has_positional_argument_with_value"
     )
     autoload(:NodeHasPositionalArgument, "#{__dir__}/matchers/node_has_positional_argument")
+    autoload(:NodeHasReceiver, "#{__dir__}/matchers/node_has_receiver")
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
@@ -22,5 +23,6 @@ module Leftovers
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")
     autoload(:Or, "#{__dir__}/matchers/or")
+    autoload(:Predicate, "#{__dir__}/matchers/predicate")
   end
 end