leftovers 0.11.1 → 0.11.2

data/lib/leftovers/file_collector/node_processor.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 require 'parser'
 
@@ -90,6 +90,13 @@ module Leftovers
         @collector.collect_commented_dynamic(node)
       end
 
+      # why are block args the parent of send/csend
+      def on_block(node)
+        node.first.parent = node
+
+        super
+      end
+
       # grab e.g. :to_s in each(&:to_s)
       def on_block_pass(node)
         super

data/lib/leftovers/file_collector.rb

@@ -4,17 +4,16 @@ require 'set'
 
 module Leftovers
   class FileCollector
-    autoload(:CommentsProcessor, "#{__dir__}/file_collector/comments_processor.rb")
-    autoload(:NodeProcessor, "#{__dir__}/file_collector/node_processor.rb")
+    include Autoloader
 
     attr_reader :calls, :allow_lines, :test_lines, :dynamic_lines
     attr_accessor :default_method_privacy
 
     def initialize(ruby, file)
       @calls = []
-      @definition_collection = Leftovers::DefinitionCollection.new
-      @allow_lines = Set.new.compare_by_identity
-      @test_lines = Set.new.compare_by_identity
+      @definition_collection = DefinitionCollection.new
+      @allow_lines = ::Set.new.compare_by_identity
+      @test_lines = ::Set.new.compare_by_identity
       @dynamic_lines = {}
       @ruby = ruby
       @file = file
@@ -26,7 +25,7 @@ module Leftovers
     end
 
     def to_h
-      { test?: @file.test?, calls: squash!(calls), definitions: squash!(definitions) }
+      { test: @file.test?, calls: squash!(calls), definitions: squash!(definitions) }
     end
 
     def squash!(list)
@@ -37,11 +36,11 @@ module Leftovers
     end
 
     def collect(ruby = @ruby, line = 1)
-      ast, comments = Leftovers::Parser.parse_with_comments(ruby, @file.relative_path, line)
+      ast, comments = Parser.parse_with_comments(ruby, @file.relative_path, line)
       CommentsProcessor.process(comments, self)
       NodeProcessor.new(self).process(ast)
     rescue ::Parser::SyntaxError => e
-      Leftovers.warn(
+      ::Leftovers.warn(
         "\e[31m#{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column} " \
           "SyntaxError: #{e.message}\e[0m"
       )
@@ -100,7 +99,7 @@ module Leftovers
       when :lvasgn then nil # we don't check local variable use, rubocop already covers this
 
       # :nocov:
-      else raise Leftovers::UnexpectedCase, "Unhandled value #{node.type.inspect}"
+      else raise UnexpectedCase, "Unhandled value #{node.type.inspect}"
         # :nocov:
       end
     end
@@ -112,18 +111,16 @@ module Leftovers
     end
 
     def collect_dynamic(node)
-      Leftovers.config.dynamic.process(nil, node, node, self)
-    rescue StandardError => e
-      raise ::Leftovers::Error, "#{e.class}: #{e.message}\n" \
+      ::Leftovers.config.dynamic.process(nil, node, node, self)
+    rescue ::StandardError => e
+      raise Error, "#{e.class}: #{e.message}\n" \
         "when processing #{node} at #{filename}:#{node.loc.line}:#{node.loc.column}", e.backtrace
     end
 
     private
 
     def build_send_wrapper_for(node, name)
-      ::Leftovers::AST::SendNode.new(
-        :send, [nil, name.to_sym, *node.arguments], location: node.location
-      )
+      AST::SendNode.new(:send, [nil, name.to_sym, *node.arguments], location: node.location)
     end
   end
 end

data/lib/leftovers/file_list.rb

@@ -6,17 +6,15 @@ module Leftovers
   class FileList < ::FastIgnore
     def initialize(**arguments)
       super(
-        ignore_rules: Leftovers.config.exclude_paths,
-        include_rules: Leftovers.config.include_paths,
-        root: Leftovers.pwd,
+        ignore_rules: ::Leftovers.config.exclude_paths,
+        include_rules: ::Leftovers.config.include_paths,
+        root: ::Leftovers.pwd,
         **arguments
       )
     end
 
     def each
-      super do |file|
-        yield(Leftovers::File.new(file))
-      end
+      super { |file| yield(File.new(file)) }
     end
   end
 end

data/lib/leftovers/matcher_builders/and.rb

@@ -9,8 +9,8 @@ module Leftovers
           case matchers.length
           when 0 then nil
           when 1 then matchers.first
-          when 2 then ::Leftovers::Matchers::And.new(matchers.first, matchers[1])
-          else ::Leftovers::Matchers::All.new(matchers.dup)
+          when 2 then Matchers::And.new(matchers.first, matchers[1])
+          else Matchers::All.new(matchers.dup)
           end
         end
 
@@ -18,13 +18,13 @@ module Leftovers
 
         def flatten(value)
           case value
-          when ::Leftovers::Matchers::And
+          when Matchers::And
             [*flatten(value.lhs), *flatten(value.rhs)]
           # :nocov: # not sure how to make this happen
-          when ::Leftovers::Matchers::All
+          when Matchers::All
             flatten(value.matchers)
           # :nocov:
-          when Array
+          when ::Array
             value.flat_map { |v| flatten(v) }
           else
             [value]

data/lib/leftovers/matcher_builders/document.rb

@@ -4,9 +4,7 @@ module Leftovers
   module MatcherBuilders
     module Document
       def self.build(true_arg)
-        return unless true_arg
-
-        ::Leftovers::Matchers::NodeName.new(:__leftovers_document)
+        Matchers::NodeName.new(:__leftovers_document) if true_arg
       end
     end
   end

data/lib/leftovers/matcher_builders/name.rb

@@ -5,12 +5,12 @@ module Leftovers
     module Name
       class << self
         def build(patterns)
-          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+          Or.each_or_self(patterns) do |pat|
             case pat
-            when ::String then ::Leftovers::MatcherBuilders::String.build(pat)
+            when ::String then String.build(pat)
             when ::Hash then build_from_hash(**pat)
             # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pat.inspect}"
               # :nocov:
             end
           end
@@ -19,10 +19,7 @@ module Leftovers
         private
 
         def build_from_hash(unless_arg: nil, **pattern)
-          ::Leftovers::MatcherBuilders::AndNot.build(
-            ::Leftovers::MatcherBuilders::StringPattern.build(**pattern),
-            ::Leftovers::MatcherBuilders::Name.build(unless_arg)
-          )
+          And.build([StringPattern.build(**pattern), Unless.build(build(unless_arg))])
         end
       end
     end

data/lib/leftovers/matcher_builders/node.rb

@@ -1,72 +1,58 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module Node
       class << self
         def build(patterns)
-          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
+          Or.each_or_self(patterns) do |pattern|
             case pattern
-            when ::String then ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+            when ::String then NodeName.build(pattern)
             when ::Hash then build_from_hash(**pattern)
               # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
             end
           end
         end
 
-        def build_from_hash( # rubocop:disable Metrics/ParameterLists
+        def 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,
+          has_block: nil,
           type: nil,
           privacy: nil,
           unless_arg: nil, all: nil, any: nil
         )
-          ::Leftovers::MatcherBuilders::And.build([
+          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)
+            Document.build(document),
+            NodePath.build(paths),
+            NodeHasArgument.build(has_arguments),
+            NodeHasBlock.build(has_block),
+            NodeHasReceiver.build(has_receiver),
+            NodePrivacy.build(privacy),
+            NodeType.build(type),
+            Unless.build(build(unless_arg)),
+            build_all_matcher(all),
+            build(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
-            )
+          Or.build([
+            NodeName.build(names),
+            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)
-          )
-        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)
+          And.build(all.map { |pattern| build(pattern) }) if all
         end
       end
     end

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -1,19 +1,17 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeHasArgument
       class << self
         def build(patterns)
-          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+          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 ::String then NodeHasKeywordArgument.build(pat, nil)
+            when ::Integer then NodeHasPositionalArgument.build(pat, nil)
             when ::Hash then build_from_hash(**pat)
             # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pat.inspect}"
               # :nocov:
             end
           end
@@ -22,45 +20,35 @@ module Leftovers
         private
 
         def build_from_hash(at: nil, has_value: nil, unless_arg: nil)
-          value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
-
-          ::Leftovers::MatcherBuilders::AndNot.build(
-            build_argument_matcher(value_matcher, **separate_argument_types(at)),
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
-          )
+          And.build([
+            build_argument_matcher(NodeValue.build(has_value), **separate_argument_types(at)),
+            Unless.build(build(unless_arg))
+          ])
         end
 
         def separate_argument_types(at)
-          groups = ::Leftovers.each_or_self(at).group_by do |index|
+          groups = ::Leftovers.wrap_array(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}"
+            else raise UnexpectedCase, "Unhandled value #{index.inspect}"
               # :nocov:
             end
           end
 
-          groups.transform_values { |v| Leftovers.unwrap_array(v) }
-        end
-
-        def build_has_keyword_argument(keys, value_matcher)
-          ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
-        end
-
-        def build_has_positional_argument(positions, value_matcher)
-          ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
+          groups.transform_values { |v| ::Leftovers.unwrap_array(v) }
         end
 
         def build_argument_matcher(value_matcher, keys: nil, positions: nil)
           if keys && !positions
-            build_has_keyword_argument(keys, value_matcher)
+            NodeHasKeywordArgument.build(keys, value_matcher)
           elsif positions && !keys
-            build_has_positional_argument(positions, value_matcher)
+            NodeHasPositionalArgument.build(positions, value_matcher)
           else
-            ::Leftovers::MatcherBuilders::Or.build([
-              build_has_positional_argument(positions, value_matcher),
-              build_has_keyword_argument(keys, value_matcher)
+            Or.build([
+              NodeHasPositionalArgument.build(positions, value_matcher),
+              NodeHasKeywordArgument.build(keys, value_matcher)
             ])
           end
         end

data/lib/leftovers/matcher_builders/node_has_block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasBlock
+      class << self
+        def build(has_block)
+          if has_block
+            Matchers::NodeHasBlock
+          elsif has_block == false
+            Matchers::Not.new(Matchers::NodeHasBlock)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -1,28 +1,26 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeHasKeywordArgument
       class << self
         def build(keywords, value_matcher)
-          value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
+          value_matcher = NodePairValue.build(value_matcher)
           keyword_matcher = build_keyword_matcher(keywords)
-          pair_matcher = ::Leftovers::MatcherBuilders::And.build([keyword_matcher, value_matcher])
+          pair_matcher = And.build([keyword_matcher, value_matcher])
 
           return unless pair_matcher
 
-          ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
+          Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
         end
 
         private
 
         def build_keyword_matcher(keywords)
-          if ::Leftovers.each_or_self(keywords).include?('**')
-            ::Leftovers::Matchers::NodeType.new(:pair)
+          if ::Leftovers.wrap_array(keywords).include?('**')
+            Matchers::NodeType.new(:pair)
           else
-            ::Leftovers::MatcherBuilders::NodePairKey.build(
-              ::Leftovers::MatcherBuilders::Node.build(keywords)
-            )
+            NodePairKey.build(Node.build(keywords))
           end
         end
       end

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -1,13 +1,14 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeHasPositionalArgument
       class << self
         def build(positions, value_matcher)
-          if positions && !all_positions?(positions) && value_matcher
+          positions = ::Leftovers.wrap_array(positions)
+          if !positions.empty? && !all_positions?(positions) && value_matcher
             build_has_positional_value_matcher(positions, value_matcher)
-          elsif positions && !value_matcher
+          elsif !positions.empty? && !value_matcher
             build_has_position_matcher(positions)
           elsif value_matcher
             build_has_any_positional_value_matcher(value_matcher)
@@ -17,23 +18,22 @@ module Leftovers
         private
 
         def all_positions?(positions)
-          ::Leftovers.each_or_self(positions).include?('*')
+          positions.include?('*')
         end
 
         def build_has_position_matcher(positions)
-          position = 0 if all_positions?(positions)
-          position ||= ::Leftovers.each_or_self(positions).min
+          last_position = all_positions?(positions) ? 0 : positions.min
 
-          ::Leftovers::Matchers::NodeHasPositionalArgument.new(position)
+          Matchers::NodeHasPositionalArgument.new(last_position)
         end
 
         def build_has_any_positional_value_matcher(value_matcher)
-          ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+          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)
+          Or.each_or_self(positions) do |position|
+            Matchers::NodeHasPositionalArgumentWithValue.new(position, value_matcher)
           end
         end
       end

data/lib/leftovers/matcher_builders/node_has_receiver.rb

@@ -1,21 +1,19 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeHasReceiver
       class << self
-        def build(pattern) # rubocop:disable Metrics/MethodLength
+        def build(pattern)
           case pattern
           when true
-            ::Leftovers::Matchers::NodeHasAnyReceiver
+            Matchers::NodeHasAnyReceiver
           when false, :_leftovers_nil_value
-            ::Leftovers::Matchers::Not.new(
-              ::Leftovers::Matchers::NodeHasAnyReceiver
-            )
+            Matchers::Not.new(Matchers::NodeHasAnyReceiver)
           else
-            matcher = ::Leftovers::MatcherBuilders::NodeValue.build(pattern)
+            matcher = NodeValue.build(pattern)
 
-            ::Leftovers::Matchers::NodeHasReceiver.new(matcher) if matcher
+            Matchers::NodeHasReceiver.new(matcher) if matcher
           end
         end
       end

data/lib/leftovers/matcher_builders/node_name.rb

@@ -1,14 +1,12 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeName
       def self.build(name_pattern)
-        matcher = ::Leftovers::MatcherBuilders::Name.build(name_pattern)
+        matcher = Name.build(name_pattern)
 
-        return unless matcher
-
-        ::Leftovers::Matchers::NodeName.new(matcher)
+        Matchers::NodeName.new(matcher) if matcher
       end
     end
   end

data/lib/leftovers/matcher_builders/node_pair_key.rb

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

data/lib/leftovers/matcher_builders/node_pair_value.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
@@ -6,9 +6,9 @@ module Leftovers
       def self.build(value_matcher)
         return unless value_matcher
 
-        ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::Matchers::NodeType.new(:pair),
-          ::Leftovers::Matchers::NodePairValue.new(value_matcher)
+        And.build([
+          Matchers::NodeType.new(:pair),
+          Matchers::NodePairValue.new(value_matcher)
         ])
       end
     end

data/lib/leftovers/matcher_builders/node_path.rb

@@ -1,13 +1,12 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodePath
       def self.build(path_pattern)
-        matcher = ::Leftovers::MatcherBuilders::Path.build(path_pattern)
-        return unless matcher
+        matcher = Path.build(path_pattern)
 
-        ::Leftovers::Matchers::NodePath.new(matcher)
+        Matchers::NodePath.new(matcher) if matcher
       end
     end
   end

data/lib/leftovers/matcher_builders/node_privacy.rb

@@ -1,11 +1,11 @@
-# frozen-string-literal: true
+# 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)
+        Or.each_or_self(privacy_settings) do |privacy|
+          Matchers::NodePrivacy.new(privacy)
         end
       end
     end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -1,25 +1,24 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 require 'set'
 
 module Leftovers
   module MatcherBuilders
     module NodeType
-      def self.build(types_pattern) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-        ::Leftovers::MatcherBuilders::Or.each_or_self(types_pattern) do |type|
+      def self.build(types_pattern) # rubocop:disable Metrics
+        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::NodeIsProc
-          when :Method then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def, :defs])
-          when :Constant
-            ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module, :casgn])
+          when :Symbol then Matchers::NodeType.new(:sym)
+          when :String then Matchers::NodeType.new(:str)
+          when :Integer then Matchers::NodeType.new(:int)
+          when :Float then Matchers::NodeType.new(:float)
+          when :Array then Matchers::NodeType.new(:array)
+          when :Hash then Matchers::NodeType.new(:hash)
+          when :Proc then Matchers::NodeIsProc
+          when :Method then Matchers::NodeType.new(::Set[:send, :csend, :def, :defs])
+          when :Constant then Matchers::NodeType.new(::Set[:const, :class, :module, :casgn])
           # :nocov:
-          else raise Leftovers::UnexpectedCase, "Unhandled value #{type.inspect}"
+          else raise UnexpectedCase, "Unhandled value #{type.inspect}"
             # :nocov:
           end
         end