leftovers 0.8.0 → 0.9.0

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_type.rb

@@ -8,15 +8,15 @@ 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, :defs])
-          when 'Constant'
+          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 Leftovers::UnexpectedCase, "Unhandled value #{type.inspect}"

data/lib/leftovers/matcher_builders/node_value.rb

@@ -7,8 +7,10 @@ module Leftovers
         def build(patterns)
           ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
             case pattern
-            when ::Integer, ::Float, true, false, nil
+            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:
@@ -20,10 +22,22 @@ module Leftovers
 
         private
 
-        def build_node_name(match, has_prefix, has_suffix)
-          ::Leftovers::MatcherBuilders::NodeName.build(
-            match: match, has_prefix: has_prefix, has_suffix: has_suffix
-          )
+        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)
@@ -35,15 +49,15 @@ module Leftovers
         end
 
         def build_from_hash( # rubocop:disable Metrics/ParameterLists
-          at: nil, has_value: nil,
-          match: nil, has_prefix: nil, has_suffix: nil,
+          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
         )
           ::Leftovers::MatcherBuilders::And.build([
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(at: at, has_value: has_value),
-            build_node_name(match, has_prefix, has_suffix),
+            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),
             build_unless(unless_arg)

data/lib/leftovers/matcher_builders/or.rb

@@ -34,30 +34,45 @@ module Leftovers
             [*flatten(value.lhs), *flatten(value.rhs)]
           when ::Leftovers::Matchers::Any
             flatten(value.matchers)
-          when Array
+          when Array, Set
             value.flat_map { |v| flatten(v) }
           else
-            value
+            [value]
           end
         end
 
         def group_by_compactable(matchers)
           groups = matchers.group_by do |matcher|
             case matcher
-            when ::Integer, ::Symbol then :set
+            when ::Integer, ::Symbol, true, false then :set
             when ::Regexp then :regexp
-            else :uncompactable
+            when nil then :nil
+            else matcher.class.to_s.to_sym
             end
           end
 
           groups.transform_values { |v| Leftovers.unwrap_array(v) }
         end
 
-        def build_grouped(set: nil, regexp: nil, uncompactable: nil)
-          set = set.to_set if set.is_a?(Array)
+        def mergeable?(matcher)
+          matcher.respond_to?(: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
+
+        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].concat(Array(uncompactable)).compact
+          [set, regexp].compact.concat(matcher_classes).uniq
         end
 
         def compact(matchers)

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.rb

@@ -12,7 +12,7 @@ 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")

data/lib/leftovers/matchers/all.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class All
+      include ComparableInstance
+
+      attr_reader :matchers
+
       def initialize(matchers)
         @matchers = matchers
 

data/lib/leftovers/matchers/and.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class And
+      include ComparableInstance
+
+      attr_reader :lhs, :rhs
+
       def initialize(lhs, rhs)
         @lhs = lhs
         @rhs = rhs

data/lib/leftovers/matchers/any.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class Any
+      include ComparableInstance
+
       attr_reader :matchers
 
       def initialize(matchers)

data/lib/leftovers/matchers/node_has_any_keyword_argument.rb

@@ -3,17 +3,20 @@
 module Leftovers
   module Matchers
     class NodeHasAnyKeywordArgument
-      def initialize(pair_matcher)
-        @pair_matcher = pair_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
         kwargs = node.kwargs
-        return false unless kwargs
 
-        kwargs.children.any?(@pair_matcher)
+        kwargs.children.any?(@matcher) if kwargs # rubocop:disable Style/SafeNavigation because there are multiple steps and this should be a configuration option
       end
 
       freeze

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class NodeHasAnyPositionalArgumentWithValue
+      include ComparableInstance
+
+      attr_reader :matcher
+
       def initialize(matcher)
         @matcher = matcher
 
@@ -10,10 +14,7 @@ module Leftovers
       end
 
       def ===(node)
-        args = node.positional_arguments
-        return false unless args
-
-        args.any?(@matcher)
+        node.positional_arguments&.any?(@matcher)
       end
 
       freeze

data/lib/leftovers/matchers/node_has_positional_argument.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgument
+      include ComparableInstance
+
       def initialize(position)
         @position = position
 
@@ -10,7 +12,9 @@ module Leftovers
       end
 
       def ===(node)
-        node.positional_arguments[@position]
+        args = node.positional_arguments
+
+        args.length > @position if args
       end
 
       freeze

data/lib/leftovers/matchers/node_has_positional_argument_with_value.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgumentWithValue
+      include ComparableInstance
+
       def initialize(position, matcher)
         @position = position
         @matcher = matcher
@@ -11,7 +13,10 @@ module Leftovers
       end
 
       def ===(node)
-        value_node = node.positional_arguments[@position]
+        args = node.positional_arguments
+        return unless args
+
+        value_node = args[@position]
         @matcher === value_node if value_node
       end
 

data/lib/leftovers/matchers/node_has_receiver.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class NodeHasReceiver
+      include ComparableInstance
+
+      attr_reader :matcher
+
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/node_is_proc.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    module NodeIsProc
+      def self.===(node)
+        node.proc?
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_name.rb

@@ -3,14 +3,20 @@
 module Leftovers
   module Matchers
     class NodeName
-      def initialize(name_matcher)
-        @name_matcher = name_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @name_matcher === node.name
+        name = node.name
+
+        @matcher === name if name
       end
 
       freeze

data/lib/leftovers/matchers/node_pair_key.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePairKey
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @matcher === node.first
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_pair_value.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePairValue
-      def initialize(value_matcher)
-        @value_matcher = value_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @value_matcher === node.second
+        @matcher === node.second
       end
 
       freeze

data/lib/leftovers/matchers/node_path.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePath
-      def initialize(path_matcher)
-        @path_matcher = path_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @path_matcher === node.path
+        @matcher === node.path
       end
 
       freeze

data/lib/leftovers/matchers/node_privacy.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePrivacy
-      def initialize(privacy_matcher)
-        @privacy_matcher = privacy_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @privacy_matcher === node.privacy
+        @matcher === node.privacy
       end
 
       freeze

data/lib/leftovers/matchers/node_scalar_value.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class NodeScalarValue
+      include ComparableInstance
+
+      attr_reader :matcher
+
       def initialize(matcher)
         @matcher = matcher
 
@@ -10,7 +14,8 @@ module Leftovers
       end
 
       def ===(node)
-        return false unless node.scalar?
+        # can't just check to_scalar_value, it might be false/nil on purpose.
+        return unless node.scalar?
 
         @matcher === node.to_scalar_value
       end

data/lib/leftovers/matchers/node_type.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodeType
-      def initialize(type_matcher)
-        @type_matcher = type_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @type_matcher === node.type
+        @matcher === node.type
       end
 
       freeze

data/lib/leftovers/matchers/not.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class Not
+      include ComparableInstance
+
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/or.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class Or
+      include ComparableInstance
+
       attr_reader :lhs, :rhs
 
       def initialize(lhs, rhs)

data/lib/leftovers/matchers/path.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Path
+      include ComparableInstance
+
+      def initialize(fast_ignore)
+        @fast_ignore = fast_ignore
+
+        freeze
+      end
+
+      def ===(path)
+        @fast_ignore.allowed?(path, exists: true, directory: false)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -16,7 +16,9 @@ module Leftovers
     )
     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 +26,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