leftovers 0.5.5 → 0.8.0

data/lib/leftovers/definition.rb

@@ -10,7 +10,7 @@ module Leftovers
     def initialize(
       name,
       location: method_node.loc.expression,
-      test: method_node.test_line?
+      test: method_node.test_line? || ::Leftovers.config.test_only === method_node
     )
       @name = name
       @path = location.source_buffer.name.to_s

data/lib/leftovers/definition_node.rb

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

data/lib/leftovers/definition_node_set.rb

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionNodeSet
+    attr_reader :definitions
+
+    def initialize(definitions)
+      @definitions = definitions
+    end
+  end
+end

data/lib/leftovers/definition_to_add.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Leftovers
+  class DefinitionToAdd
+    attr_reader :node, :name, :location
+
+    def initialize(node, name: node.name, location: node.loc.name)
+      @node = node
+      @name = name
+      @location = location
+    end
+
+    def privacy=(value)
+      @node.privacy = value
+    end
+
+    def keep?(file_collector)
+      @keep ||= file_collector.keep_line?(location.line) || ::Leftovers.config.keep === node
+    end
+
+    def test?(file_collector)
+      file_collector.test_line?(location.line) || ::Leftovers.config.test_only === node
+    end
+
+    def to_definition(file_collector)
+      return if keep?(file_collector)
+
+      Leftovers::Definition.new(name, location: location, test: test?(file_collector))
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/call.rb

@@ -3,10 +3,6 @@
 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
@@ -15,10 +11,11 @@ module Leftovers
       def process(node, file)
         return unless @matcher === node
 
-        call = @processor.process(nil, node, node)
-        return unless call
+        calls = @processor.process(nil, node, node)
 
-        file.calls << call
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/call_definition.rb

@@ -3,28 +3,31 @@
 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)
+      def process(node, file) # rubocop:disable Metrics/MethodLength
         return unless @matcher === node
 
-        call = @call_processor.process(nil, node, node)
-        (file.calls << call) if call
+        calls = @call_processor.process(nil, node, node)
 
-        return if node.keep_line?
+        ::Leftovers.each_or_self(calls) do |call|
+          file.calls << call
+        end
 
-        definition = @definition_processor.process(nil, node, node)
-        return unless definition
+        return if node.keep_line?
 
-        file.definitions << definition
+        definitions = @definition_processor.process(nil, node, node)
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/definition.rb

@@ -3,10 +3,6 @@
 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
@@ -16,10 +12,15 @@ module Leftovers
         return if node.keep_line?
         return unless @matcher === node
 
-        definition = @processor.process(nil, node, node)
-        return unless definition
+        definitions = @processor.process(nil, node, node)
 
-        file.definitions << definition
+        ::Leftovers.each_or_self(definitions) do |definition|
+          if definition.is_a?(DefinitionNodeSet)
+            file.add_definition_set(definition)
+          else
+            file.add_definition(definition, loc: definition.loc)
+          end
+        end
       end
     end
   end

data/lib/leftovers/dynamic_processors/set_default_privacy.rb

@@ -0,0 +1,18 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetDefaultPrivacy
+      def initialize(matcher, to)
+        @matcher = matcher
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        file.default_method_privacy = @to
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors/set_privacy.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module DynamicProcessors
+    class SetPrivacy
+      def initialize(matcher, processor, to)
+        @matcher = matcher
+        @processor = processor
+        @to = to
+      end
+
+      def process(node, file)
+        return unless @matcher === node
+
+        set_privacy = @processor.process(nil, node, node)
+
+        ::Leftovers.each_or_self(set_privacy) do |name|
+          file.set_privacy(name, @to)
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/dynamic_processors.rb

@@ -7,5 +7,7 @@ module Leftovers
     autoload(:Definition, "#{__dir__}/dynamic_processors/definition")
     autoload(:Each, "#{__dir__}/dynamic_processors/each")
     autoload(:Null, "#{__dir__}/dynamic_processors/null")
+    autoload(:SetDefaultPrivacy, "#{__dir__}/dynamic_processors/set_default_privacy")
+    autoload(:SetPrivacy, "#{__dir__}/dynamic_processors/set_privacy")
   end
 end

data/lib/leftovers/file.rb

@@ -5,7 +5,11 @@ require 'pathname'
 module Leftovers
   class File < Pathname
     def relative_path
-      @relative_path ||= relative_path_from(Leftovers.pwd)
+      @relative_path ||= begin
+        relative_path_from(Leftovers.pwd)
+      rescue ArgumentError
+        self
+      end
     end
 
     def test?
@@ -15,19 +19,15 @@ module Leftovers
     end
 
     def ruby
-      precompiler&.precompile(read, self) || read
-    end
+      read = self.read
 
-    private
+      precompiled = ::Leftovers.config.precompilers.map do |precompiler|
+        precompiler.precompile(read, self)
+      end.compact
 
-    def precompiler
-      if Leftovers.config.haml_paths.allowed?(relative_path)
-        ::Leftovers::Haml
-      elsif Leftovers.config.slim_paths.allowed?(relative_path)
-        ::Leftovers::Slim
-      elsif Leftovers.config.erb_paths.allowed?(relative_path)
-        ::Leftovers::ERB
-      end
+      return read if precompiled.empty?
+
+      precompiled.join("\n")
     end
   end
 end

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