leftovers 0.6.0 → 0.9.0

data/lib/leftovers/file_collector/comments_processor.rb

@@ -0,0 +1,57 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class FileCollector
+    module CommentsProcessor
+      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)
+      NAME_LIST_RE = /#{NAME_RE}(?:[, :]+#{NAME_RE})*/.freeze
+      LEFTOVERS_CALL_RE = /\bleftovers:call(?:s|e(?:d|rs?))? (#{NAME_LIST_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_LIST_RE})/.freeze
+
+      class << self
+        def process(comments, collector)
+          comments.each do |comment|
+            process_leftovers_keep_comment(comment, collector)
+            process_leftovers_test_comment(comment, collector)
+            process_leftovers_dynamic_comment(comment, collector)
+            process_leftovers_call_comment(comment, collector)
+          end
+        end
+
+        def process_leftovers_keep_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_ALLOW_RE)
+
+          collector.allow_lines << comment.loc.line
+        end
+
+        def process_leftovers_test_comment(comment, collector)
+          return unless comment.text.match?(LEFTOVERS_TEST_RE)
+
+          collector.test_lines << comment.loc.line
+        end
+
+        def process_leftovers_dynamic_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_DYNAMIC_RE)
+          return unless match
+
+          collector.dynamic_lines[comment.loc.line] = match[1].scan(NAME_RE)
+        end
+
+        def process_leftovers_call_comment(comment, collector)
+          match = comment.text.match(LEFTOVERS_CALL_RE)
+          return unless match
+
+          match[1].scan(NAME_RE).each { |s| collector.calls << s.to_sym }
+        end
+      end
+    end
+  end
+end

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.calls << node.name
+        super
+      end
+
+      def on_gvar(node)
+        @collector.calls << node.name
+        super
+      end
+
+      def on_cvar(node)
+        @collector.calls << 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.calls << 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.sym?
+
+        @collector.calls << 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.calls << original_method.children.first
+      end
+    end
+  end
+end

data/lib/leftovers/file_collector.rb

@@ -1,20 +1,24 @@
 # frozen_string_literal: true
 
 require 'set'
-require 'parser'
 
 module Leftovers
-  class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls, :definitions
+  class FileCollector
+    autoload(:CommentsProcessor, "#{__dir__}/file_collector/comments_processor.rb")
+    autoload(:NodeProcessor, "#{__dir__}/file_collector/node_processor.rb")
 
-    def initialize(ruby, file) # rubocop:disable Lint/MissingSuper
+    attr_reader :calls, :allow_lines, :test_lines, :dynamic_lines
+    attr_accessor :default_method_privacy
+
+    def initialize(ruby, file)
       @calls = []
-      @definitions = []
+      @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
     end
 
     def filename
@@ -22,247 +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!
-      definitions.reject! { |v| v == :keep }
+    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)
-      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)
+      Leftovers.warn(
+        "\e[31m#{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column} " \
+          "SyntaxError: #{e.message}\e[0m"
+      )
     end
 
-    def on_array(node)
-      super
-      collect_commented_dynamic(node)
+    def collect_subfile(string, location)
+      string = (' ' * location.column) + string # match indentation
+      collect(string, location.line)
     end
 
-    def on_hash(node)
-      super
-      collect_commented_dynamic(node)
+    def test_line?(line)
+      @file.test? || @test_lines.include?(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 keep_line?(line)
+      @allow_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)
-    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)
-    end
-
-    private
-
-    def test_line?(loc)
-      @file.test? ||
-        @test_lines.include?(loc.line)
-    end
-
-    def test_node?(node, loc)
-      test_line?(loc) || ::Leftovers.config.test_only === node
+    def set_privacy(node, to)
+      @definition_collection.set_privacy(node, to)
     end
 
     def add_definition(node, name: node.name, loc: node.loc.name)
-      return if @allow_lines.include?(loc.line)
-      return if Leftovers.config.keep === node
+      @definition_collection.add(node, name: name, loc: loc)
+    end
 
-      definitions << Leftovers::Definition.new(name, location: loc, test: test_node?(node, loc))
+    def add_definition_node(definition_node)
+      @definition_collection.add_definition_node(definition_node)
     end
 
-    def add_call(name)
-      calls << name
+    def definitions
+      @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
-      # :nocov: # don't need else, it's exhaustive for callers
+      node = node.first
       case node.type
+      # 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:
-      when :send then collect_send_op_asgn(node)
-      when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
+      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) # rubocop:disable Metrics/AbcSize
-      node.keep_line = @allow_lines.include?(node.loc.line)
-      node.test_line = test_line?(node.loc) unless node.keep_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