leftovers 0.7.0 → 0.8.0

data/lib/leftovers/file_collector/node_processor.rb

@@ -0,0 +1,131 @@
+# frozen-string-literal: true
+
+require 'parser'
+
+module Leftovers
+  class FileCollector
+    class NodeProcessor < ::Parser::AST::Processor
+      def initialize(collector) # rubocop:disable Lint/MissingSuper # there isn't one to call
+        @collector = collector
+      end
+
+      def on_def(node)
+        node.privacy = @collector.default_method_privacy
+        @collector.add_definition(node)
+        super
+      end
+
+      def on_defs(node)
+        @collector.add_definition(node)
+        super
+      end
+
+      def on_ivasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_gvasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_cvasgn(node)
+        @collector.collect_variable_assign(node)
+        super
+      end
+
+      def on_ivar(node)
+        @collector.add_call(node.name)
+        super
+      end
+
+      def on_gvar(node)
+        @collector.add_call(node.name)
+        super
+      end
+
+      def on_cvar(node)
+        @collector.add_call(node.name)
+        super
+      end
+
+      def on_op_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_and_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_or_asgn(node)
+        @collector.collect_op_asgn(node)
+        super
+      end
+
+      def on_send(node)
+        super
+        @collector.collect_send(node)
+      end
+
+      def on_csend(node)
+        super
+        @collector.collect_send(node)
+      end
+
+      def on_const(node)
+        super
+        @collector.add_call(node.name)
+      end
+
+      def on_array(node)
+        super
+        @collector.collect_commented_dynamic(node)
+      end
+
+      def on_hash(node)
+        super
+        @collector.collect_commented_dynamic(node)
+      end
+
+      # grab e.g. :to_s in each(&:to_s)
+      def on_block_pass(node)
+        super
+        return unless node.first.string_or_symbol?
+
+        @collector.add_call(node.first.to_sym)
+      end
+
+      # grab class Constant or module Constant
+      def on_class(node)
+        # don't call super so we don't interpret the class name as being called by its definition
+        process_all(node.children.drop(1))
+
+        node = node.children.first
+
+        @collector.add_definition(node)
+      end
+      alias_method :on_module, :on_class
+
+      # grab Constant = Class.new or CONSTANT = 'string'.freeze
+      def on_casgn(node)
+        super
+
+        @collector.add_definition(node)
+        @collector.collect_dynamic(node)
+      end
+
+      # grab calls to `alias new_method original_method`
+      def on_alias(node)
+        super
+        new_method, original_method = node.children
+        @collector.add_definition(
+          new_method, name: new_method.children.first, loc: new_method.loc.expression
+        )
+        @collector.add_call(original_method.children.first)
+      end
+    end
+  end
+end

data/lib/leftovers/file_collector.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 require 'set'
-require 'parser'
 
 module Leftovers
-  class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls
+  class FileCollector
+    autoload(:CommentsProcessor, "#{__dir__}/file_collector/comments_processor.rb")
+    autoload(:NodeProcessor, "#{__dir__}/file_collector/node_processor.rb")
+
+    attr_reader :calls, :allow_lines, :test_lines, :dynamic_lines
     attr_accessor :default_method_privacy
 
-    def initialize(ruby, file) # rubocop:disable Lint/MissingSuper
+    def initialize(ruby, file)
       @calls = []
       @definitions_to_add = {}
       @allow_lines = Set.new.compare_by_identity
@@ -25,176 +27,30 @@ module Leftovers
     end
 
     def to_h
-      squash!
-
-      {
-        test?: @file.test?,
-        calls: calls,
-        definitions: definitions
-      }
+      { test?: @file.test?, calls: squash!(calls), definitions: squash!(definitions) }
     end
 
-    def squash!
-      calls.flatten!
-      calls.compact!
-      calls.uniq!
-      definitions.flatten!
-      definitions.compact!
-      definitions.uniq!
+    def squash!(list)
+      list.flatten!
+      list.compact!
+      list.uniq!
+      list
     end
 
     def collect
       ast, comments = Leftovers::Parser.parse_with_comments(@ruby, @file.relative_path)
-      process_comments(comments)
-      process(ast)
+      CommentsProcessor.process(comments, self)
+      NodeProcessor.new(self).process(ast)
     rescue ::Parser::SyntaxError => e
-      Leftovers.warn "\e[31m#{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column} SyntaxError: #{e.message}\e[0m" # rubocop:disable Layout/LineLength
-    end
-
-    METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
-    NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
-      []= [] ** ~ +@ -@ * / % + - >> << &
-      ^ | <=> <= >= < > === == != =~ !~ !
-    }.map { |op| /#{Regexp.escape(op)}/ })
-    CONSTANT_NAME_RE = /[[:upper:]][[:alnum:]_]*\b/.freeze
-    NAME_RE = Regexp.union(METHOD_NAME_RE, NON_ALNUM_METHOD_NAME_RE, CONSTANT_NAME_RE)
-    LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|ed|er|ers|) (#{NAME_RE}(?:[, :]+#{NAME_RE})*)/.freeze
-    LEFTOVERS_ALLOW_RE = /\bleftovers:(?:keeps?|skip(?:s|ped|)|allow(?:s|ed|))\b/.freeze
-    LEFTOVERS_TEST_RE = /\bleftovers:(?:for_tests?|tests?|testing|test_only)\b/.freeze
-    LEFTOVERS_DYNAMIC_RE = /\bleftovers:dynamic:(#{NAME_RE})\b/.freeze
-
-    def process_comments(comments) # rubocop:disable Metrics/AbcSize
-      comments.each do |comment|
-        @allow_lines << comment.loc.line if comment.text.match?(LEFTOVERS_ALLOW_RE)
-        @test_lines << comment.loc.line if comment.text.match?(LEFTOVERS_TEST_RE)
-        dynamic_match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
-        @dynamic_lines[comment.loc.line] = dynamic_match[1] if dynamic_match
-
-        next unless (call_match = comment.text.match(LEFTOVERS_CALL_RE))
-
-        call_match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
-      end
+      Leftovers.warn(
+        "\e[31m#{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column} " \
+          "SyntaxError: #{e.message}\e[0m"
+      )
     end
 
     # grab method definitions
-    def on_def(node)
-      node.privacy = default_method_privacy
-      add_definition(node)
-      super
-    end
-
-    def on_defs(node)
-      add_definition(node)
-      super
-    end
-
-    def on_ivasgn(node)
-      collect_variable_assign(node)
-      super
-    end
-
-    def on_gvasgn(node)
-      collect_variable_assign(node)
-      super
-    end
-
-    def on_cvasgn(node)
-      collect_variable_assign(node)
-      super
-    end
-
-    def on_ivar(node)
-      add_call(node.name)
-      super
-    end
-
-    def on_gvar(node)
-      add_call(node.name)
-      super
-    end
-
-    def on_cvar(node)
-      add_call(node.name)
-      super
-    end
-
-    def on_op_asgn(node)
-      collect_op_asgn(node)
-      super
-    end
-
-    def on_and_asgn(node)
-      collect_op_asgn(node)
-      super
-    end
-
-    def on_or_asgn(node)
-      collect_op_asgn(node)
-      super
-    end
-
-    # grab method calls
-    def on_send(node)
-      super
-      collect_send(node)
-    end
-
-    def on_csend(node)
-      super
-      collect_send(node)
-    end
-
-    def on_const(node)
-      super
-      add_call(node.name)
-    end
-
-    def on_array(node)
-      super
-      collect_commented_dynamic(node)
-    end
-
-    def on_hash(node)
-      super
-      collect_commented_dynamic(node)
-    end
-
-    # grab e.g. :to_s in each(&:to_s)
-    def on_block_pass(node)
-      super
-      add_call(node.children.first.to_sym) if node.children.first.string_or_symbol?
-    end
-
-    # grab class Constant or module Constant
-    def on_class(node)
-      # don't call super so we don't process the class name
-      # !!! (# wtf does this mean dana? what would happen instead?)
-      process_all(node.children.drop(1))
-
-      node = node.children.first
-
-      add_definition(node)
-    end
-    alias_method :on_module, :on_class
-
-    # grab Constant = Class.new or CONSTANT = 'string'.freeze
-    def on_casgn(node)
-      super
-      add_definition(node)
-      collect_dynamic(node)
-    end
-
-    # grab calls to `alias new_method original_method`
-    def on_alias(node)
-      super
-      new_method, original_method = node.children
-      add_definition(new_method, name: new_method.children.first, loc: new_method.loc.expression)
-      add_call(original_method.children.first)
-    end
-
     def add_definition(node, name: node.name, loc: node.loc.name)
-      @definitions_to_add[name] =
-        ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
+      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
     end
 
     def add_definition_set(definition_node_set)
@@ -208,25 +64,22 @@ module Leftovers
     end
 
     def definitions
-      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) }.compact +
+      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) } +
         @definition_sets_to_add.map do |definition_set|
-          next nil if definition_set.any? { |d| d.keep?(self) }
+          next if definition_set.any? { |d| d.keep?(self) }
 
           ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
-        end.compact
+        end
     end
 
     def test_line?(line)
-      @file.test? ||
-        @test_lines.include?(line)
+      @file.test? || @test_lines.include?(line)
     end
 
     def keep_line?(line)
       @allow_lines.include?(line)
     end
 
-    private
-
     def add_call(name)
       calls << name
     end
@@ -236,52 +89,29 @@ module Leftovers
       collect_dynamic(node)
     end
 
-    # just collects the call, super will collect the definition
-    def collect_var_op_asgn(node)
-      name = node.children.first
-
-      add_call(name)
-    end
-
-    def collect_send_op_asgn(node)
-      name = node.children[1]
-
-      add_call(:"#{name}=")
-    end
-
     def collect_variable_assign(node)
       add_definition(node)
-
       collect_dynamic(node)
     end
 
     def collect_op_asgn(node)
-      node = node.children.first
+      node = node.first
       case node.type
-      when :send then collect_send_op_asgn(node)
-      when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
+      # just collects the :call=, super will collect the :call
+      when :send, :csend then add_call(:"#{node.name}=")
+      # just collects the call, super will collect the definition
+      when :ivasgn, :gvasgn, :cvasgn then add_call(node.name)
       when :lvasgn then nil # we don't care about lvasgn
       # :nocov:
-      else
-        raise "Unrecognized op_asgn node type #{node.type}"
+      else raise Leftovers::UnexpectedCase, "Unhandled value #{node.type.inspect}"
         # :nocov:
       end
     end
 
     def collect_commented_dynamic(node)
-      fake_method_name = @dynamic_lines[node.loc.line]
-      return unless fake_method_name
-
-      node = build_send_wrapper_for(node, fake_method_name)
-      collect_dynamic(node)
-    end
-
-    def build_send_wrapper_for(node, name)
-      ::Leftovers::AST::Node.new(
-        :send,
-        [nil, name.to_sym, *node.arguments],
-        location: node.location
-      )
+      @dynamic_lines[node.loc.line]&.each do |fake_method_name|
+        collect_dynamic(build_send_wrapper_for(node, fake_method_name))
+      end
     end
 
     def collect_dynamic(node)
@@ -289,7 +119,16 @@ module Leftovers
 
       Leftovers.config.dynamic.process(node, self)
     rescue StandardError => e
-      raise ::Leftovers::Error, "#{e.class}: #{e.message}\nwhen processing #{node} at #{filename}:#{node.loc.line}:#{node.loc.column}", e.backtrace # rubocop:disable Layout/LineLength
+      raise ::Leftovers::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::Node.new(
+        :send, [nil, name.to_sym, *node.arguments], location: node.location
+      )
     end
   end
 end

data/lib/leftovers/matcher_builders/and_not.rb

@@ -3,11 +3,13 @@
 module Leftovers
   module MatcherBuilders
     module AndNot
-      def self.build(positive_matcher, negative_matcher)
-        ::Leftovers::MatcherBuilders::And.build([
-          positive_matcher,
-          ::Leftovers::MatcherBuilders::Unless.build(negative_matcher)
-        ])
+      class << self
+        def build(positive_matcher, negative_matcher)
+          ::Leftovers::MatcherBuilders::And.build([
+            positive_matcher,
+            ::Leftovers::MatcherBuilders::Unless.build(negative_matcher)
+          ])
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/name.rb

@@ -3,26 +3,27 @@
 module Leftovers
   module MatcherBuilders
     module Name
-      def self.build(patterns) # rubocop:disable Metrics/MethodLength
-        ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
-          case pat
-          when nil
-          when ::Array
-            ::Leftovers::MatcherBuilders::Name.build(pat)
-          when ::String
-            ::Leftovers::MatcherBuilders::String.build(pat)
-          when ::Hash
-            unless_arg = pat.delete(:unless_arg)
-
-            ::Leftovers::MatcherBuilders::AndNot.build(
-              ::Leftovers::MatcherBuilders::StringPattern.build(**pat),
-              ::Leftovers::MatcherBuilders::Name.build(unless_arg)
-            )
-          # :nocov:
-          else raise
+      class << self
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pat|
+            case pat
+            when ::String then ::Leftovers::MatcherBuilders::String.build(pat)
+            when ::Hash then build_from_hash(**pat)
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+              # :nocov:
+            end
           end
         end
+
+        private
+
+        def build_from_hash(unless_arg: nil, **pattern)
+          ::Leftovers::MatcherBuilders::AndNot.build(
+            ::Leftovers::MatcherBuilders::StringPattern.build(**pattern),
+            ::Leftovers::MatcherBuilders::Name.build(unless_arg)
+          )
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node.rb

@@ -3,45 +3,59 @@
 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,
-        type: nil,
-        privacy: 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),
-          ::Leftovers::MatcherBuilders::NodePrivacy.build(privacy),
-          ::Leftovers::MatcherBuilders::NodeType.build(type),
+        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_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
+        )
+          ::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)
+          ])
+        end
       end
     end
   end