leftovers 0.3.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
-    attr_reader :test
+
     alias_method :test?, :test
 
     def initialize(
       name,
       method_node: nil,
       location: method_node.loc.expression,
-      file: method_node.file,
       test: method_node.test?
     )
       @name = name
-
-      @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 to_s
       @name.to_s
     end
 
-    def line
-      @location.line
-    end
-
-    def column
-      @location.column
-    end
-
-    def full_location
-      "#{path}:#{line}:#{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, 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, self)
+        ::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,16 +1,13 @@
 # frozen_string_literal: true
 
-require 'fast_ignore'
 require 'set'
-require_relative 'parser'
-require_relative 'definition'
+require 'parser'
 
 module Leftovers
   class FileCollector < ::Parser::AST::Processor # rubocop:disable Metrics/ClassLength
-    attr_reader :calls
-    attr_reader :definitions
+    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
@@ -24,6 +21,8 @@ module Leftovers
     end
 
     def to_h
+      squash!
+
       {
         test?: @file.test?,
         calls: calls,
@@ -31,15 +30,25 @@ module Leftovers
       }
     end
 
+    def squash!
+      calls.flatten!
+      calls.compact!
+      calls.uniq!
+      definitions.flatten!
+      definitions.compact!
+      definitions.uniq!
+      definitions.reject! { |v| v == :keep }
+    end
+
     def collect
-      ast, comments = Leftovers::Parser.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[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{
       []= [] ** ~ +@ -@ * / % + - >> << &
       ^ | <=> <= >= < > === == != =~ !~ !
@@ -49,7 +58,7 @@ 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)
@@ -62,66 +71,74 @@ module Leftovers
 
     # grab method definitions
     def on_def(node)
-      add_definition(node.name, node.loc.name)
-
+      add_definition(node)
       super
     end
 
     def on_ivasgn(node)
-      add_definition(node.name, node.loc.name)
+      collect_variable_assign(node)
+      super
+    end
 
-      collect_rules(node)
+    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.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.name)
-      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.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
 
@@ -133,26 +150,22 @@ module Leftovers
 
       node = node.children.first
 
-      add_definition(node.name, 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.name, 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
 
@@ -162,16 +175,22 @@ 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
@@ -185,6 +204,12 @@ module Leftovers
       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
@@ -195,22 +220,13 @@ module Leftovers
       end
     end
 
-    def collect_rules(node) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      Leftovers.config.rules.each do |rule|
-        next unless rule.match?(node.name, filename)
+    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 rule.skip?
-
-        calls.concat(rule.calls(node))
-
-        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 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}\nwhen processing #{node} at #{filename}:#{node.loc.line}:#{node.loc.column}", e.backtrace # rubocop:disable Layout/LineLength
     end
   end
 end