leftovers 0.4.3 → 0.5.0

data/lib/leftovers/matcher_builders/node_has_argument.rb

@@ -26,6 +26,8 @@ module Leftovers
 
         ::Leftovers.each_or_self(at) do |k|
           case k
+          when '*'
+            positions << k
           when ::String, ::Hash
             keys << k
           when ::Integer
@@ -35,23 +37,25 @@ module Leftovers
             # :nocov:
           end
         end
+
         keys = nil if keys.empty?
         positions = nil if positions.empty?
 
         [keys, positions]
       end
 
-      def self.build_from_hash(at: nil, has_value: nil, has_value_type: nil, unless_arg: nil) # rubocop:disable Metrics/MethodLength
+      def self.build_from_hash( # rubocop:disable Metrics/MethodLength
+        at: nil,
+        has_value: nil,
+        unless_arg: nil
+      )
         keys, positions = separate_argument_types(at)
 
-        value_matcher = ::Leftovers::MatcherBuilders::And.build([
-          ::Leftovers::MatcherBuilders::ArgumentNodeValue.build(has_value),
-          ::Leftovers::MatcherBuilders::NodeType.build(has_value_type)
-        ])
+        value_matcher = ::Leftovers::MatcherBuilders::NodeValue.build(has_value)
         matcher = if (keys && positions) || (!keys && !positions)
           ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher),
-            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher)
+            ::Leftovers::MatcherBuilders::NodeHasPositionalArgument.build(positions, value_matcher),
+            ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)
           ])
         elsif keys
           ::Leftovers::MatcherBuilders::NodeHasKeywordArgument.build(keys, value_matcher)

data/lib/leftovers/matcher_builders/node_has_keyword_argument.rb

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

data/lib/leftovers/matcher_builders/node_has_positional_argument.rb

@@ -3,20 +3,24 @@
 module Leftovers
   module MatcherBuilders
     module NodeHasPositionalArgument
-      def self.build(positions, value_matcher) # rubocop:disable Metrics/MethodLength
-        if positions && value_matcher
-          ::Leftovers::MatcherBuilders::Or.each_or_self(positions) do |position|
-            ::Leftovers::Matchers::NodeHasPositionalArgumentWithValue.new(position, value_matcher)
-          end
-        elsif positions
-          position = positions.is_a?(Array) ? positions.min : positions
+      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(position)
-        elsif value_matcher
-          ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
-        # :nocov:
-        else raise
-          # :nocov:
+            ::Leftovers::Matchers::NodeHasPositionalArgument.new(pos)
+          elsif value_matcher
+            ::Leftovers::Matchers::NodeHasAnyPositionalArgumentWithValue.new(value_matcher)
+          end
         end
       end
     end

data/lib/leftovers/matcher_builders/node_has_receiver.rb

@@ -0,0 +1,15 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeHasReceiver
+      class << self
+        def build(pattern)
+          matcher = ::Leftovers::MatcherBuilders::NodeValue.build(pattern)
+
+          ::Leftovers::Matchers::NodeHasReceiver.new(matcher) if matcher
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders/node_type.rb

@@ -5,18 +5,19 @@ require 'set'
 module Leftovers
   module MatcherBuilders
     module NodeType
-      def self.build(types_pattern)
+      def self.build(types_pattern) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         ::Leftovers::MatcherBuilders::Or.each_or_self(types_pattern) do |type|
           case type
           when 'Symbol' then ::Leftovers::Matchers::NodeType.new(:sym)
           when 'String' then ::Leftovers::Matchers::NodeType.new(:str)
           when 'Integer' then ::Leftovers::Matchers::NodeType.new(:int)
           when 'Float' then ::Leftovers::Matchers::NodeType.new(:float)
-          # these would be neat but i can't think of a use-case
-          # when 'Array' then :array
-          # when 'Hash' then :hash
-          # when 'Method' then Set[:send, :csend, :def]
-          # when 'Constant' then Set[:const, :class, :module]
+          when 'Array' then ::Leftovers::Matchers::NodeType.new(:array)
+          when 'Hash' then ::Leftovers::Matchers::NodeType.new(:hash)
+
+          when 'Proc' then ::Leftovers::Matchers::Predicate.new(:proc?)
+          # when 'Method' then ::Leftovers::Matchers::NodeType.new(Set[:send, :csend, :def])
+          # when 'Constant' then ::Leftovers::Matchers::NodeType.new(Set[:const, :class, :module])
           # :nocov:
           else raise
             # :nocov:

data/lib/leftovers/matcher_builders/node_value.rb

@@ -0,0 +1,42 @@
+# frozen-string-literal: true
+
+module Leftovers
+  module MatcherBuilders
+    module NodeValue
+      class << self
+        def build(pattern) # rubocop:disable Metrics/MethodLength
+          ::Leftovers::MatcherBuilders::Or.each_or_self(pattern) do |pat|
+            case pat
+            when ::Integer, true, false, nil
+              ::Leftovers::Matchers::NodeScalarValue.new(pat)
+            when ::String
+              ::Leftovers::MatcherBuilders::NodeName.build(pat)
+            when ::Hash
+              build_from_hash(pat)
+            # :nocov:
+            else raise
+              # :nocov:
+            end
+          end
+        end
+
+        private
+
+        def build_from_hash(pat) # rubocop:disable Metrics/MethodLength
+          matcher = ::Leftovers::MatcherBuilders::And.build([
+            ::Leftovers::MatcherBuilders::NodeHasArgument.build(pat.slice(:at, :has_value)),
+            ::Leftovers::MatcherBuilders::NodeName.build(
+              pat.slice(:match, :has_prefix, :has_suffix)
+            ),
+            ::Leftovers::MatcherBuilders::NodeType.build(pat[:type]),
+            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(pat[:has_receiver])
+          ])
+
+          ::Leftovers::MatcherBuilders::AndNot.build(
+            matcher, ::Leftovers::MatcherBuilders::NodeValue.build(pat[:unless_arg])
+          )
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/matcher_builders.rb

@@ -4,17 +4,18 @@ module Leftovers
   module MatcherBuilders
     autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
     autoload(:And, "#{__dir__}/matcher_builders/and")
-    autoload(:ArgumentNodeValue, "#{__dir__}/matcher_builders/argument_node_value")
     autoload(:Name, "#{__dir__}/matcher_builders/name")
+    autoload(:Node, "#{__dir__}/matcher_builders/node")
     autoload(:NodeHasArgument, "#{__dir__}/matcher_builders/node_has_argument")
     autoload(:NodeHasKeywordArgument, "#{__dir__}/matcher_builders/node_has_keyword_argument")
     autoload(:NodeHasPositionalArgument, "#{__dir__}/matcher_builders/node_has_positional_argument")
+    autoload(:NodeHasReceiver, "#{__dir__}/matcher_builders/node_has_receiver")
     autoload(:NodeName, "#{__dir__}/matcher_builders/node_name")
     autoload(:NodePairName, "#{__dir__}/matcher_builders/node_pair_name")
     autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
     autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
-    autoload(:Node, "#{__dir__}/matcher_builders/node")
+    autoload(:NodeValue, "#{__dir__}/matcher_builders/node_value")
     autoload(:Or, "#{__dir__}/matcher_builders/or")
     autoload(:Path, "#{__dir__}/matcher_builders/path")
     autoload(:StringPattern, "#{__dir__}/matcher_builders/string_pattern")

data/lib/leftovers/matchers/node_has_any_positional_argument_with_value.rb

@@ -14,7 +14,10 @@ module Leftovers
       end
 
       def ===(node)
-        node.positional_arguments.any? do |value|
+        args = node.positional_arguments
+        return false unless args
+
+        args.any? do |value|
           @matcher === value
         end
       end

data/lib/leftovers/matchers/node_has_positional_argument.rb

@@ -3,10 +3,6 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgument
-      # :nocov:
-      using ::Leftovers::Backports::SetCaseEq if defined?(::Leftovers::Backports::SetCaseEq)
-      # :nocov:
-
       def initialize(position)
         @position = position
 

data/lib/leftovers/matchers/node_has_receiver.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodeHasReceiver
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        receiver = node.receiver
+        @matcher === receiver if receiver
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/predicate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Predicate
+      def initialize(predicate)
+        @predicate = predicate
+
+        freeze
+      end
+
+      def ===(node)
+        node.send(@predicate)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -15,6 +15,7 @@ module Leftovers
       "#{__dir__}/matchers/node_has_positional_argument_with_value"
     )
     autoload(:NodeHasPositionalArgument, "#{__dir__}/matchers/node_has_positional_argument")
+    autoload(:NodeHasReceiver, "#{__dir__}/matchers/node_has_receiver")
     autoload(:NodeName, "#{__dir__}/matchers/node_name")
     autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
     autoload(:NodePath, "#{__dir__}/matchers/node_path")
@@ -22,5 +23,6 @@ module Leftovers
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")
     autoload(:Or, "#{__dir__}/matchers/or")
+    autoload(:Predicate, "#{__dir__}/matchers/predicate")
   end
 end

data/lib/leftovers/merged_config.rb

@@ -37,10 +37,12 @@ module Leftovers
       Leftovers::Config.new(:'.leftovers_todo.yml', path: Leftovers.pwd + '.leftovers_todo.yml')
     end
 
-    def unmemoize
+    def unmemoize # rubocop:disable Metrics/CyclomaticComplexity
       remove_instance_variable(:@exclude_paths) if defined?(@exclude_paths)
       remove_instance_variable(:@include_paths) if defined?(@include_paths)
       remove_instance_variable(:@test_paths) if defined?(@test_paths)
+      remove_instance_variable(:@haml_paths) if defined?(@haml_paths)
+      remove_instance_variable(:@erb_paths) if defined?(@erb_paths)
       remove_instance_variable(:@dynamic) if defined?(@dynamic)
       remove_instance_variable(:@keep) if defined?(@keep)
     end
@@ -61,6 +63,22 @@ module Leftovers
       )
     end
 
+    def haml_paths
+      @haml_paths ||= FastIgnore.new(
+        include_rules: @configs.flat_map(&:haml_paths),
+        gitignore: false,
+        root: Leftovers.pwd
+      )
+    end
+
+    def erb_paths
+      @erb_paths ||= FastIgnore.new(
+        include_rules: @configs.flat_map(&:erb_paths),
+        gitignore: false,
+        root: Leftovers.pwd
+      )
+    end
+
     def dynamic
       @dynamic ||= ::Leftovers::ProcessorBuilders::EachDynamic.build(@configs.map(&:dynamic))
     end

data/lib/leftovers/todo_reporter.rb

@@ -30,12 +30,9 @@ module Leftovers
     def report_instructions
       puts <<~MESSAGE
         generated #{path.basename}.
-        running leftovers again will read this file and
-        not alert you to any unused items mentioned in it.
+        running leftovers again will read this file and not alert you to any unused items mentioned in it.
 
-        commit this file so you/your team can gradually
-        address these items while still having leftovers
-        alert you to any newly unused items.
+        commit this file so you/your team can gradually address these items while still having leftovers alert you to any newly unused items.
       MESSAGE
     end
 
@@ -108,12 +105,18 @@ module Leftovers
     def generate_list(title, list)
       <<~YML
           # #{title}
-        #{list.map { |d| print_definition(d) }.join("\n")}
+        #{print_definition_list(list)}
 
       YML
     end
 
+    def print_definition_list(definition_list)
+      definition_list.map { |definition| print_definition(definition) }.join("\n")
+    end
+
     def print_definition(definition)
+      return print_definition_list(definition.definitions) if definition.is_a?(DefinitionSet)
+
       "  - #{definition.to_s.inspect} # #{definition.location_s} #{definition.source_line.strip}"
     end
 

data/lib/leftovers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leftovers
-  VERSION = '0.4.3'
+  VERSION = '0.5.0'
 end

data/lib/leftovers.rb

@@ -3,8 +3,6 @@
 module Leftovers # rubocop:disable Metrics/ModuleLength
   class Error < ::StandardError; end
 
-  module_function
-
   autoload(:AST, "#{__dir__}/leftovers/ast")
   autoload(:Backports, "#{__dir__}/leftovers/backports")
   autoload(:CLI, "#{__dir__}/leftovers/cli")
@@ -32,124 +30,129 @@ module Leftovers # rubocop:disable Metrics/ModuleLength
   autoload(:VERSION, "#{__dir__}/leftovers/version")
 
   class << self
-    attr_accessor :parallel, :progress, :reporter
+    attr_accessor :parallel, :progress
+    attr_writer :reporter
     alias_method :parallel?, :parallel
     alias_method :progress?, :progress
-  end
 
-  def stdout
-    @stdout ||= $stdout
-  end
+    def stdout
+      @stdout ||= $stdout
+    end
 
-  def stderr
-    @stderr ||= $stderr
-  end
+    def stderr
+      @stderr ||= $stderr
+    end
 
-  def config
-    @config ||= Leftovers::MergedConfig.new(load_defaults: true)
-  end
+    def config
+      @config ||= Leftovers::MergedConfig.new(load_defaults: true)
+    end
 
-  def collector
-    @collector ||= Leftovers::Collector.new
-  end
+    def collector
+      @collector ||= Leftovers::Collector.new
+    end
 
-  def reporter
-    @reporter ||= Leftovers::Reporter.new
-  end
+    def reporter
+      @reporter ||= Leftovers::Reporter.new
+    end
 
-  def leftovers
-    @leftovers ||= begin
-      collector.collect
-      collector.definitions.reject(&:in_collection?)
+    def leftovers
+      @leftovers ||= begin
+        collector.collect
+        collector.definitions.reject(&:in_collection?)
+      end
     end
-  end
 
-  def run(stdout: StringIO.new, stderr: StringIO.new) # rubocop:disable Metrics/MethodLength
-    @stdout = stdout
-    @stderr = stderr
-    return reporter.report_success if leftovers.empty?
-
-    only_test = []
-    none = []
-    leftovers.sort_by(&:location_s).each do |definition|
-      if !definition.test? && definition.in_test_collection?
-        only_test << definition
-      else
-        none << definition
+    def run(stdout: StringIO.new, stderr: StringIO.new) # rubocop:disable Metrics/MethodLength
+      @stdout = stdout
+      @stderr = stderr
+      return reporter.report_success if leftovers.empty?
+
+      only_test = []
+      none = []
+      leftovers.sort_by(&:location_s).each do |definition|
+        if !definition.test? && definition.in_test_collection?
+          only_test << definition
+        else
+          none << definition
+        end
       end
+
+      reporter.report(only_test: only_test, none: none)
     end
 
-    reporter.report(only_test: only_test, none: none)
-  end
+    def reset # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      remove_instance_variable(:@config) if defined?(@config)
+      remove_instance_variable(:@collector) if defined?(@collector)
+      remove_instance_variable(:@reporter) if defined?(@reporter)
+      remove_instance_variable(:@leftovers) if defined?(@leftovers)
+      remove_instance_variable(:@try_require_cache) if defined?(@try_require_cache)
+      remove_instance_variable(:@stdout) if defined?(@stdout)
+      remove_instance_variable(:@stderr) if defined?(@stderr)
+      remove_instance_variable(:@parallel) if defined?(@parallel)
+      remove_instance_variable(:@pwd) if defined?(@pwd)
+    end
 
-  def reset # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-    remove_instance_variable(:@config) if defined?(@config)
-    remove_instance_variable(:@collector) if defined?(@collector)
-    remove_instance_variable(:@reporter) if defined?(@reporter)
-    remove_instance_variable(:@leftovers) if defined?(@leftovers)
-    remove_instance_variable(:@try_require) if defined?(@try_require)
-    remove_instance_variable(:@stdout) if defined?(@stdout)
-    remove_instance_variable(:@stderr) if defined?(@stderr)
-    remove_instance_variable(:@parallel) if defined?(@parallel)
-    remove_instance_variable(:@pwd) if defined?(@pwd)
-  end
+    def resolution_instructions_link
+      "https://github.com/robotdana/leftovers/tree/v#{Leftovers::VERSION}/README.md#how_to_resolve"
+    end
 
-  def resolution_instructions_link
-    "https://github.com/robotdana/leftovers/tree/v#{Leftovers::VERSION}/README.md#how_to_resolve"
-  end
+    def warn(message)
+      stderr.puts("\e[2K#{message}")
+    end
 
-  def warn(message)
-    stderr.puts("\e[2K#{message}")
-  end
+    def error(message)
+      warn(message)
+      exit 1
+    end
 
-  def error(message)
-    warn(message)
-    exit 1
-  end
+    def puts(message)
+      stdout.puts("\e[2K#{message}")
+    end
 
-  def puts(message)
-    stdout.puts("\e[2K#{message}")
-  end
+    def print(message)
+      stdout.print(message)
+    end
 
-  def print(message)
-    stdout.print(message)
-  end
+    def newline
+      stdout.puts('')
+    end
 
-  def newline
-    stdout.puts('')
-  end
+    def pwd
+      @pwd ||= Pathname.new(Dir.pwd + '/')
+    end
 
-  def pwd
-    @pwd ||= Pathname.new(Dir.pwd + '/')
-  end
+    def exit(status = 0)
+      throw :leftovers_exit, status
+    end
 
-  def exit(status = 0)
-    throw :leftovers_exit, status
-  end
+    def try_require(requirable, message: nil)
+      warn message if !try_require_cache(requirable) && message
+      try_require_cache(requirable)
+    end
 
-  def try_require(requirable, message: nil) # rubocop:disable Metrics/MethodLength
-    @try_require ||= {}
+    def each_or_self(value, &block)
+      return enum_for(__method__, value) unless block
 
-    @try_require[requirable] = begin
-      if @try_require.key?(requirable)
-        @try_require[requirable]
-      else
-        require requirable
-        true
+      case value
+      when nil then nil
+      when Array then value.each(&block)
+      else yield(value)
       end
-    rescue LoadError
-      false
     end
 
-    warn message if !@try_require[requirable] && message
-    @try_require[requirable]
-  end
+    private
 
-  def each_or_self(value, &block)
-    case value
-    when nil then nil
-    when Array then value.each(&block)
-    else yield(value)
+    def try_require_cache(requirable)
+      @try_require_cache ||= {}
+
+      @try_require_cache.fetch(requirable) do
+        begin
+          require requirable
+          @try_require_cache[requirable] = true
+        rescue LoadError
+          @try_require_cache[requirable] = false
+        end
+      end
     end
   end
 end