leftovers 0.5.5 → 0.8.0

data/lib/leftovers/file_collector.rb

@@ -1,19 +1,25 @@
 # 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 = []
+      @definitions_to_add = {}
       @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
@@ -21,170 +27,57 @@ 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)
+      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
-    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)
-
-        next unless (match = comment.text.match(LEFTOVERS_CALL_RE))
-
-        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)
-      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
-
-    # 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)
+    def add_definition(node, name: node.name, loc: node.loc.name)
+      @definitions_to_add[name] = ::Leftovers::DefinitionToAdd.new(node, name: name, location: loc)
     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_sets_to_add << definition_node_set.definitions.map do |definition_node|
+        ::Leftovers::DefinitionToAdd.new(definition_node, location: definition_node.loc)
+      end
     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(name, to)
+      @definitions_to_add[name]&.privacy = to
     end
 
-    private
+    def definitions
+      @definitions ||= @definitions_to_add.each_value.map { |d| d.to_definition(self) } +
+        @definition_sets_to_add.map do |definition_set|
+          next if definition_set.any? { |d| d.keep?(self) }
 
-    def test_line?(loc)
-      @file.test? ||
-        @test_lines.include?(loc.line)
+          ::Leftovers::DefinitionSet.new(definition_set.map { |d| d.to_definition(self) })
+        end
     end
 
-    def test_node?(node, loc)
-      test_line?(loc) || ::Leftovers.config.test_only === node
+    def test_line?(line)
+      @file.test? || @test_lines.include?(line)
     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
-
-      definitions << Leftovers::Definition.new(name, location: loc, test: test_node?(node, loc))
+    def keep_line?(line)
+      @allow_lines.include?(line)
     end
 
     def add_call(name)
@@ -196,42 +89,46 @@ 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
-      # :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 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:
-      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_dynamic(node) # rubocop:disable Metrics/AbcSize
+    def collect_commented_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 collect_dynamic(node)
       node.keep_line = @allow_lines.include?(node.loc.line)
-      node.test_line = test_line?(node.loc) unless node.keep_line?
 
       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/document.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module Document
+      def self.build(true_arg)
+        return unless true_arg
+
+        ::Leftovers::Matchers::NodeName.new(:__leftovers_document)
+      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,39 +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,
-        paths: nil,
-        has_arguments: nil,
-        has_receiver: 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::NodePath.build(paths),
-          ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
-          ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
+        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

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -3,72 +3,67 @@
 module Leftovers
   module MatcherBuilders
     module NodeHasArgument
-      def self.build(patterns) # rubocop:disable Metrics/MethodLength
-        ::Leftovers::MatcherBuilders::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 ::Hash
-            build_from_hash(**pat)
-          # :nocov:
-          else
-            raise
+      class << self
+        def build(patterns)
+          ::Leftovers::MatcherBuilders::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 ::Hash then build_from_hash(**pat)
             # :nocov:
+            else raise Leftovers::UnexpectedCase, "Unhandled value #{pat.inspect}"
+              # :nocov:
+            end
           end
         end
-      end
 
-      def self.separate_argument_types(at) # rubocop:disable Metrics/MethodLength
-        keys = []
-        positions = []
+        private
 
-        ::Leftovers.each_or_self(at) do |k|
-          case k
-          when '*'
-            positions << k
-          when ::String, ::Hash
-            keys << k
-          when ::Integer
-            positions << k
-          # :nocov:
-          else raise
-            # :nocov:
-          end
-        end
+        def build_from_hash(at: nil, has_value: nil, unless_arg: nil)
+          value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
 
-        keys = nil if keys.empty?
-        positions = nil if positions.empty?
+          ::Leftovers::MatcherBuilders::AndNot.build(
+            build_argument_matcher(value_matcher, **separate_argument_types(at)),
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
+          )
+        end
 
-        [keys, positions]
-      end
+        def separate_argument_types(at)
+          groups = ::Leftovers.each_or_self(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}"
+              # :nocov:
+            end
+          end
 
-      def self.build_from_hash( # rubocop:disable Metrics/MethodLength
-        at: nil,
-        has_value: nil,
-        unless_arg: nil
-      )
-        keys, positions = separate_argument_types(at)
+          groups.transform_values { |v| Leftovers.unwrap_array(v) }
+        end
 
-        value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
-        matcher = if (keys && positions) || (!keys && !positions)
-          ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher),
-            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
-          ])
-        elsif keys
+        def build_has_keyword_argument(keys, value_matcher)
           ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
-        elsif positions
+        end
+
+        def build_has_positional_argument(positions, value_matcher)
           ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
-          # :nocov:
-        else raise
-          # :nocov:
         end
 
-        ::Leftovers::MatcherBuilders::AndNot.build(
-          matcher, ::Leftovers::MatcherBuilders::NodeHasArgument.build(unless_arg)
-        )
+        def build_argument_matcher(value_matcher, keys: nil, positions: nil)
+          if keys && !positions
+            build_has_keyword_argument(keys, value_matcher)
+          elsif positions && !keys
+            build_has_positional_argument(positions, value_matcher)
+          else
+            ::Leftovers::MatcherBuilders::Or.build([
+              build_has_positional_argument(positions, value_matcher),
+              build_has_keyword_argument(keys, value_matcher)
+            ])
+          end
+        end
       end
     end
   end

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

@@ -4,21 +4,24 @@ module Leftovers
   module MatcherBuilders
     module NodeHasKeywordArgument
       class << self
-        def build(keywords, value_matcher) # rubocop:disable Metrics/MethodLength
+        def build(keywords, value_matcher)
           value_matcher = ::Leftovers::MatcherBuilders::NodePairValue.build(value_matcher)
-          keyword_matcher = if ::Leftovers.each_or_self(keywords).any? { |x| x == '**' }
+          keyword_matcher = build_keyword_matcher(keywords)
+          pair_matcher = ::Leftovers::MatcherBuilders::And.build([keyword_matcher, value_matcher])
+
+          return unless pair_matcher
+
+          ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
+        end
+
+        private
+
+        def build_keyword_matcher(keywords)
+          if ::Leftovers.each_or_self(keywords).include?('**')
             ::Leftovers::Matchers::NodeType.new(:pair)
           else
             ::Leftovers::MatcherBuilders::NodePairName.build(keywords)
           end
-
-          pair_matcher = ::Leftovers::MatcherBuilders::And.build([
-            keyword_matcher, value_matcher
-          ])
-
-          return nil unless pair_matcher
-
-          ::Leftovers::Matchers::NodeHasAnyKeywordArgument.new(pair_matcher)
         end
       end
     end

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -4,22 +4,36 @@ module Leftovers
   module MatcherBuilders
     module NodeHasPositionalArgument
       class << self
-        def build(positions, value_matcher) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength
-          if positions && value_matcher
-            ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |pos|
-              if pos == '*'
-                ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
-              else
-                ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(pos, value_matcher)
-              end
-            end
-          elsif positions
-            pos = 0 if ::Leftovers.each_or_self(positions).any? { |x| x == '*' }
-            pos ||= ::Leftovers.each_or_self(positions).min
-
-            ::Leftovers::Matchers::NodeHasPositionalArgument.new(pos)
+        def build(positions, value_matcher)
+          if positions && !all_positions?(positions) && value_matcher
+            build_has_positional_value_matcher(positions, value_matcher)
+          elsif positions && !value_matcher
+            build_has_position_matcher(positions)
           elsif value_matcher
-            ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+            build_has_any_positional_value_matcher(value_matcher)
+          end
+        end
+
+        private
+
+        def all_positions?(positions)
+          ::Leftovers.each_or_self(positions).include?('*')
+        end
+
+        def build_has_position_matcher(positions)
+          position = 0 if all_positions?(positions)
+          position ||= ::Leftovers.each_or_self(positions).min
+
+          ::Leftovers::Matchers::NodeHasPositionalArgument.new(position)
+        end
+
+        def build_has_any_positional_value_matcher(value_matcher)
+          ::Leftovers::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)
           end
         end
       end