leftovers 0.2.0 → 0.4.0

data/lib/leftovers/definition.rb

@@ -2,57 +2,36 @@
 
 module Leftovers
   class Definition
-    attr_reader :name
+    attr_reader :name, :test, :location_s
     alias_method :names, :name
-    alias_method :full_name, :name
-    attr_reader :name_s
-    alias_method :to_s, :name_s
-    attr_reader :test
+
     alias_method :test?, :test
 
-    def initialize( # rubocop:disable Metrics/MethodLength
+    def initialize(
       name,
       method_node: nil,
       location: method_node.loc.expression,
-      file: method_node.file,
       test: method_node.test?
     )
       @name = name
-      @name_s = name.to_s.freeze
-
-      @location = location
-      @file = file
+      @location_source_line = location.source_line.to_s
+      @location_column_range_begin = location.column_range.begin.to_i
+      @location_column_range_end = location.column_range.end.to_i
+      @location_source = location.source.to_s
+      @location_s = location.to_s
       @test = test
 
       freeze
     end
 
-    def <=>(other)
-      (path <=> other.path).nonzero? ||
-        (line <=> other.line).nonzero? ||
-        (column <=> other.column)
-    end
-
-    def path
-      @file.relative_path
-    end
-
-    def line
-      @location.line
+    def to_s
+      @name.to_s
     end
 
-    def column
-      @location.column
-    end
-
-    def full_location
-      "#{path}:#{@location.line}:#{@location.column}"
-    end
-
-    def highlighted_source(highlight = "\e[31m", normal = "\e[0m") # rubocop:disable Metrics/AbcSize
-      @location.source_line.to_s[0...(@location.column_range.begin)].lstrip +
-        highlight + @location.source.to_s + normal +
-        @location.source_line.to_s[(@location.column_range.end)..-1].rstrip
+    def highlighted_source(highlight = "\e[31m", normal = "\e[0m")
+      @location_source_line[0...@location_column_range_begin].lstrip +
+        highlight + @location_source + normal +
+        @location_source_line[@location_column_range_end..-1].rstrip
     end
 
     def in_collection?
@@ -62,9 +41,5 @@ module Leftovers
     def in_test_collection?
       Leftovers.collector.test_calls.include?(@name)
     end
-
-    def skipped?
-      Leftovers.config.skip_rules.any? { |r| r.match?(@name, @name_s, path) }
-    end
   end
 end

data/lib/leftovers/definition_set.rb

@@ -1,24 +1,18 @@
 # frozen_string_literal: true
 
-require_relative 'definition'
 module Leftovers
-  class DefinitionSet < Leftovers::Definition
-    def initialize( # rubocop:disable Metrics/MethodLength
-      names,
+  class DefinitionSet < ::Leftovers::Definition
+    attr_reader :definitions
+
+    def initialize(
+      definitions,
       method_node: nil,
       location: method_node.loc.expression,
-      file: method_node.file,
       test: method_node.test?
     )
-      @definitions = names.map do |name|
-        Leftovers::Definition.new(name, test: test, location: location, file: file)
-      end
-
-      @test = test
-      @location = location
-      @file = file
+      @definitions = definitions
 
-      freeze
+      super
     end
 
     def names
@@ -36,9 +30,5 @@ module Leftovers
     def in_test_collection?
       @definitions.any?(&:in_test_collection?)
     end
-
-    def skipped?
-      @definitions.any?(&:skipped?)
-    end
   end
 end

data/lib/leftovers/dynamic_processors.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    autoload(:CallDefinition, "#{__dir__}/dynamic_processors/call_definition")
+    autoload(:Call, "#{__dir__}/dynamic_processors/call")
+    autoload(:Definition, "#{__dir__}/dynamic_processors/definition")
+    autoload(:Each, "#{__dir__}/dynamic_processors/each")
+    autoload(:Null, "#{__dir__}/dynamic_processors/null")
+  end
+end

data/lib/leftovers/dynamic_processors/call.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class Call
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher, processor)
+        @matcher = matcher
+        @processor = processor
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        call = @processor.process(nil, node, node)
+        return unless call
+
+        file.calls << call
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class CallDefinition
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher, call_processor, definition_processor)
+        @matcher = matcher
+        @call_processor = call_processor
+        @definition_processor = definition_processor
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        call = @call_processor.process(nil, node, node)
+        (file.calls << call) if call
+
+        return if node.keep_line?
+
+        definition = @definition_processor.process(nil, node, node)
+        return unless definition
+
+        file.definitions << definition
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/definition.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class Definition
+      # :nocov:
+      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
+      # :nocov:
+
+      def initialize(matcher, processor)
+        @matcher = matcher
+        @processor = processor
+      end
+
+      def process(node, file)
+        return if node.keep_line?
+        return unless @matcher === node
+
+        definition = @processor.process(nil, node, node)
+        return unless definition
+
+        file.definitions << definition
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/each.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class Each
+      attr_reader :processors
+
+      def initialize(processors)
+        @processors = processors
+      end
+
+      def process(node, file)
+        @processors.each do |processor|
+          processor.process(node, file)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/null.rb

@@ -0,0 +1,9 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    module Null
+      def self.process(_node, _file); end
+    end
+  end
+end

data/lib/leftovers/erb.rb

@@ -9,11 +9,11 @@ module Leftovers
       @compiler.compile(erb).first
     end
 
-    def add_insert_cmd(out, content)
+    def add_insert_cmd(out, content) # leftovers:keep
       out.push("#{content}\n")
     end
 
-    def add_put_cmd(out, _content)
+    def add_put_cmd(out, _content) # leftovers:keep
       out
     end
   end

data/lib/leftovers/file.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'erb'
-require_relative 'haml'
 require 'pathname'
 
 module Leftovers
@@ -16,12 +14,12 @@ module Leftovers
       @test = Leftovers.config.test_paths.allowed?(relative_path)
     end
 
-    def ruby # rubocop:disable Metrics/MethodLength
+    def ruby
       case extname
       when '.haml'
-        Leftovers::Haml.precompile(read)
+        ::Leftovers::Haml.precompile(read, self)
       when '.rhtml', '.rjs', '.erb'
-        Leftovers::ERB.precompile(read)
+        ::Leftovers::ERB.precompile(read)
       else
         read
       end

data/lib/leftovers/file_collector.rb

@@ -1,19 +1,13 @@
 # frozen_string_literal: true
 
-require 'fast_ignore'
 require 'set'
 require 'parser'
-require 'parser/current'
-require_relative 'ast/builder'
-require_relative 'ast/node'
-require_relative 'definition'
 
 module Leftovers
-  class FileCollector < Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls
-    attr_reader :definitions
+  class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
+    attr_reader :calls, :definitions
 
-    def initialize(ruby, file) # rubocop:disable Metrics/MethodLength
+    def initialize(ruby, file) # rubocop:disable Lint/MissingSuper
       @calls = []
       @definitions = []
       @allow_lines = Set.new.compare_by_identity
@@ -27,6 +21,8 @@ module Leftovers
     end
 
     def to_h
+      squash!
+
       {
         test?: @file.test?,
         calls: calls,
@@ -34,40 +30,25 @@ module Leftovers
       }
     end
 
-    # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
-    # but with our builder
-    def self.parser # rubocop:disable Metrics/MethodLength
-      p = ::Parser::CurrentRuby.new(Leftovers::AST::Builder.new)
-      p.diagnostics.all_errors_are_fatal = true
-      p.diagnostics.ignore_warnings = true
-
-      p.diagnostics.consumer = lambda do |diagnostic|
-        warn(diagnostic.render)
-      end
-
-      p
-    end
-    PARSER = parser
-
-    # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
-    # but with our parser
-    def parse_with_comments(string, file = '(string)', line = 1)
-      PARSER.reset
-      source_buffer = ::Parser::CurrentRuby.send(
-        :setup_source_buffer, file, line, string, PARSER.default_encoding
-      )
-      PARSER.parse_with_comments(source_buffer)
+    def squash!
+      calls.flatten!
+      calls.compact!
+      calls.uniq!
+      definitions.flatten!
+      definitions.compact!
+      definitions.uniq!
+      definitions.reject! { |v| v == :keep }
     end
 
     def collect
-      ast, comments = parse_with_comments(@ruby, @file)
+      ast, comments = Leftovers::Parser.parse_with_comments(@ruby, @file.relative_path)
       process_comments(comments)
       process(ast)
-    rescue Parser::SyntaxError => e
-      Leftovers.warn "#{e.class}: #{e.message} #{filename}:#{e.diagnostic.location.line}:#{e.diagnostic.location.column}" # rubocop:disable Layout/LineLength
+    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
+    METHOD_NAME_RE = /[[:alpha:]_][[:alnum:]_]*\b[?!=]?/.freeze
     NON_ALNUM_METHOD_NAME_RE = Regexp.union(%w{
       []= [] ** ~ +@ -@ * / % + - >> << &
       ^ | <=> <= >= < > === == != =~ !~ !
@@ -77,14 +58,12 @@ module Leftovers
     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)\b/.freeze
-    def process_comments(comments) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    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))
-        next unless match[1]
 
         match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
       end
@@ -92,66 +71,75 @@ module Leftovers
 
     # grab method definitions
     def on_def(node)
-      add_definition(node.children.first, node.loc.name)
-
+      add_definition(node)
       super
     end
 
     def on_ivasgn(node)
-      add_definition(node.children.first, node.loc.name)
+      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
-    alias_method :on_gvasgn, :on_ivasgn
-    alias_method :on_cvasgn, :on_ivasgn
 
     def on_ivar(node)
-      add_call(node.children.first)
+      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
-    alias_method :on_gvar, :on_ivar
-    alias_method :on_cvar, :on_ivar
 
     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
 
-      add_call(node.children[1])
-
-      collect_rules(node)
+    def on_csend(node)
+      super
+      collect_send(node)
     end
-    alias_method :on_csend, :on_send
 
     def on_const(node)
       super
-
-      add_call(node.children[1])
+      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?
+      add_call(node.children.first.to_sym) if node.children.first.string_or_symbol?
     end
 
     # grab class Constant or module Constant
@@ -162,26 +150,22 @@ module Leftovers
 
       node = node.children.first
 
-      add_definition(node.children[1], node.loc.name)
+      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.children[1], node.loc.name)
-
-      collect_rules(node)
+      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.children.first, new_method.loc.expression)
+      add_definition(new_method, name: new_method.children.first, loc: new_method.loc.expression)
       add_call(original_method.children.first)
     end
 
@@ -191,55 +175,58 @@ module Leftovers
       @file.test? || @test_lines.include?(loc.line)
     end
 
-    def add_definition(name, loc)
+    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, file: @file, test: test?(loc))
+      definitions << Leftovers::Definition.new(name, location: loc, test: test?(loc))
     end
 
     def add_call(name)
       calls << name
     end
 
+    def collect_send(node)
+      add_call(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
 
-      return unless name
-
       add_call(name)
     end
 
     def collect_send_op_asgn(node)
       name = node.children[1]
 
-      return unless name
-
       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
       case node.type
+      # :nocov:
       when :send then collect_send_op_asgn(node)
       when :ivasgn, :gvasgn, :cvasgn then collect_var_op_asgn(node)
       end
     end
 
-    def collect_rules(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      Leftovers.config.rules.each do |rule|
-        next unless rule.match?(node.name, node.name_s, filename)
-
-        next if rule.skip?
-
-        calls.concat(rule.calls(node))
+    def collect_dynamic(node) # rubocop:disable Metrics/AbcSize
+      node.keep_line = @allow_lines.include?(node.loc.line)
+      node.test = test?(node.loc) unless node.keep_line?
 
-        next if @allow_lines.include?(node.loc.line)
-
-        node.file = @file
-        node.test = test?(node.loc)
-        definitions.concat(rule.definitions(node))
-      end
+      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
     end
   end
 end