leftovers 0.2.2 → 0.4.2

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?
+      test: method_node.test_line?
     )
       @name = name
-      @name_s = name.to_s.freeze
-
-      @location = location
-      @file = file
+      @path = location.source_buffer.name.to_s
+      @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_node.rb

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+# To give to matchers before creating a Definition
+
+module Leftovers
+  class DefinitionNode
+    attr_reader :path, :name
+
+    def initialize(name, path)
+      @name = name
+      @path = path
+
+      freeze
+    end
+
+    # these are the methods checked by things in lib/leftovers/matchers
+    def kwargs
+      nil
+    end
+
+    def positional_arguments
+      nil
+    end
+
+    # these two i'm not sure are possible with the current config flags
+    # :nocov:
+    def scalar?
+      false
+    end
+
+    def type
+      :leftovers_definition
+    end
+    # :nocov:
+  end
+end

data/lib/leftovers/definition_set.rb

@@ -1,28 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'definition'
 module Leftovers
-  class DefinitionSet < Leftovers::Definition
-    def initialize( # rubocop:disable Metrics/MethodLength
-      names,
-      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
+  class DefinitionSet
+    attr_reader :definitions
 
-      freeze
-    end
+    def initialize(definitions)
+      @definitions = definitions
 
-    def full_name
-      names.join(', ')
+      freeze
     end
 
     def names
@@ -33,16 +18,24 @@ module Leftovers
       @definitions.map(&:to_s).join(', ')
     end
 
+    def location_s
+      @definitions.first.location_s
+    end
+
+    def highlighted_source(*args)
+      @definitions.first.highlighted_source(*args)
+    end
+
     def in_collection?
       @definitions.any?(&:in_collection?)
     end
 
-    def in_test_collection?
-      @definitions.any?(&:in_test_collection?)
+    def test?
+      @definitions.any?(&:test?)
     end
 
-    def skipped?
-      @definitions.any?(&:skipped?)
+    def in_test_collection?
+      @definitions.any?(&:in_test_collection?)
     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,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.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{
       []= [] ** ~ +@ -@ * / % + - >> << &
       ^ | <=> <= >= < > === == != =~ !~ !
@@ -48,15 +57,13 @@ module Leftovers
     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)\b/.freeze
-    def process_comments(comments) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    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))
-        next unless match[1]
 
         match[1].scan(NAME_RE).each { |s| add_call(s.to_sym) }
       end
@@ -64,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
@@ -134,84 +150,88 @@ 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
 
     private
 
-    def test?(loc)
-      @file.test? || @test_lines.include?(loc.line)
+    def test_line?(loc)
+      @file.test? ||
+        @test_lines.include?(loc.line)
     end
 
-    def add_definition(name, loc)
+    def test_node?(node, loc)
+      test_line?(loc) || ::Leftovers.config.test_only === node
+    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, file: @file, test: test?(loc))
+      definitions << Leftovers::Definition.new(name, location: loc, test: test_node?(node, 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_line = test_line?(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