leftovers 0.7.0 → 0.10.0

data/lib/leftovers/file_collector.rb

@@ -1,23 +1,24 @@
 # 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 = {}
+      @definition_collection = Leftovers::DefinitionCollection.new
       @allow_lines = Set.new.compare_by_identity
       @test_lines = Set.new.compare_by_identity
       @dynamic_lines = {}
       @ruby = ruby
       @file = file
       @default_method_privacy = :public
-      @definition_sets_to_add = []
     end
 
     def filename
@@ -25,271 +26,103 @@ 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)
+    def collect(ruby = @ruby, line = 1)
+      ast, comments = Leftovers::Parser.parse_with_comments(ruby, @file.relative_path, line)
+      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
-    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)
+      Leftovers.warn(
+        "\e[31m#{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column} " \
+          "SyntaxError: #{e.message}\e[0m"
+      )
     end
 
-    def on_hash(node)
-      super
-      collect_commented_dynamic(node)
+    def collect_subfile(string, location)
+      string = (' ' * location.column) + string # match indentation
+      collect(string, location.line)
     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?
+    def test_line?(line)
+      @file.test? || @test_lines.include?(line)
     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)
+    def keep_line?(line)
+      @allow_lines.include?(line)
     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)
+    def add_definition_set(definition_node_set)
+      @definition_collection.add_definition_set(definition_node_set)
     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)
+    def set_privacy(node, to)
+      @definition_collection.set_privacy(node, to)
     end
 
     def add_definition(node, name: node.name, loc: node.loc.name)
-      @definitions_to_add[name] =
-        ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
-    end
-
-    def add_definition_set(definition_node_set)
-      @definition_sets_to_add << definition_node_set.definitions.map do |definition_node|
-        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
-      end
+      @definition_collection.add(node, name: name, loc: loc)
     end
 
-    def set_privacy(name, to)
-      @definitions_to_add[name]&.privacy = to
+    def add_definition_node(definition_node)
+      @definition_collection.add_definition_node(definition_node)
     end
 
     def definitions
-      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) }.compact +
-        @definition_sets_to_add.map do |definition_set|
-          next nil if definition_set.any? { |d| d.keep?(self) }
-
-          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
-        end.compact
-    end
-
-    def test_line?(line)
-      @file.test? ||
-        @test_lines.include?(line)
-    end
-
-    def keep_line?(line)
-      @allow_lines.include?(line)
-    end
-
-    private
-
-    def add_call(name)
-      calls << name
+      @definitions ||= @definition_collection.to_definitions(self)
     end
 
     def collect_send(node)
-      add_call(node.name)
+      calls << node.name
       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 calls << :"#{node.name}="
+      # just collects the call, super will collect the definition
+      when :ivasgn, :gvasgn, :cvasgn then calls << 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)
+      @dynamic_lines[node.loc.line]&.each do |fake_method_name|
+        collect_dynamic(build_send_wrapper_for(node, fake_method_name))
+      end
     end
 
-    def build_send_wrapper_for(node, name)
-      ::Leftovers::AST::Node.new(
-        :send,
-        [nil, name.to_sym, *node.arguments],
-        location: node.location
-      )
+    def collect_dynamic(node)
+      Leftovers.config.dynamic.process(nil, node, node, self)
+    rescue StandardError => e
+      raise ::Leftovers::Error, "#{e.class}: #{e.message}\n" \
+        "when processing #{node} at #{filename}:#{node.loc.line}:#{node.loc.column}", e.backtrace
     end
 
-    def collect_dynamic(node)
-      node.keep_line = @allow_lines.include?(node.loc.line)
+    private
 
-      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
+    def build_send_wrapper_for(node, name)
+      ::Leftovers::AST::SendNode.new(
+        :send, [nil, name.to_sym, *node.arguments], location: node.location
+      )
     end
   end
 end

data/lib/leftovers/file_list.rb

@@ -4,11 +4,12 @@ require 'fast_ignore'
 
 module Leftovers
   class FileList < ::FastIgnore
-    def initialize
+    def initialize(**arguments)
       super(
         ignore_rules: Leftovers.config.exclude_paths,
         include_rules: Leftovers.config.include_paths,
-        root: Leftovers.pwd
+        root: Leftovers.pwd,
+        **arguments
       )
     end
 

data/lib/leftovers/matcher_builders/and.rb

@@ -3,15 +3,32 @@
 module Leftovers
   module MatcherBuilders
     module And
-      def self.build(matchers)
-        matchers = matchers.compact
-        case matchers.length
-        # :nocov:
-        when 0 then nil
-        # :nocov:
-        when 1 then matchers.first
-        when 2 then ::Leftovers::Matchers::And.new(matchers.first, matchers[1])
-        else ::Leftovers::Matchers::All.new(matchers.dup)
+      class << self
+        def build(matchers)
+          matchers = flatten(matchers).compact
+          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)
+          end
+        end
+
+        private
+
+        def flatten(value)
+          case value
+          when ::Leftovers::Matchers::And
+            [*flatten(value.lhs), *flatten(value.rhs)]
+          # :nocov: # not sure how to make this happen
+          when ::Leftovers::Matchers::All
+            flatten(value.matchers)
+          # :nocov:
+          when Array
+            value.flat_map { |v| flatten(v) }
+          else
+            [value]
+          end
         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,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,
-        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),
+        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