leftovers 0.11.0 → 0.11.2

data/lib/leftovers/matcher_builders/node_value.rb

@@ -1,20 +1,19 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
     module NodeValue
       class << self
         def build(patterns)
-          ::Leftovers::MatcherBuilders::Or.each_or_self(patterns) do |pattern|
+          Or.each_or_self(patterns) do |pattern|
             case pattern
-            when ::Integer, ::Float, true, false
-              # matching scalar on nil will fall afoul of compact and each_or_self etc.
-              ::Leftovers::Matchers::NodeScalarValue.new(pattern)
-            when :_leftovers_nil_value then ::Leftovers::Matchers::NodeType.new(:nil)
-            when ::String then ::Leftovers::MatcherBuilders::NodeName.build(pattern)
+            when ::Integer, ::Float, true, false then Matchers::NodeScalarValue.new(pattern)
+            # matching scalar on nil will fall afoul of compact and each_or_self etc.
+            when :_leftovers_nil_value then Matchers::NodeType.new(:nil)
+            when ::String then NodeName.build(pattern)
             when ::Hash then build_from_hash(**pattern)
             # :nocov:
-            else raise Leftovers::UnexpectedCase, "Unhandled value #{pattern.inspect}"
+            else raise UnexpectedCase, "Unhandled value #{pattern.inspect}"
               # :nocov:
             end
           end
@@ -23,31 +22,19 @@ module Leftovers
         private
 
         def build_node_name_matcher(names, match, has_prefix, has_suffix)
-          ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeName.build(names),
-            ::Leftovers::MatcherBuilders::NodeName.build(
-              match: match, has_prefix: has_prefix, has_suffix: has_suffix
-            )
+          Or.build([
+            NodeName.build(names),
+            NodeName.build(match: match, has_prefix: has_prefix, has_suffix: has_suffix)
           ])
         end
 
         def build_node_has_argument_matcher(has_arguments, at, has_value)
-          ::Leftovers::MatcherBuilders::Or.build([
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(has_arguments),
-            ::Leftovers::MatcherBuilders::NodeHasArgument.build(
-              at: at, has_value: has_value
-            )
+          Or.build([
+            NodeHasArgument.build(has_arguments),
+            NodeHasArgument.build(at: at, has_value: has_value)
           ])
         end
 
-        def build_unless(unless_arg)
-          return unless unless_arg
-
-          ::Leftovers::MatcherBuilders::Unless.build(
-            ::Leftovers::MatcherBuilders::NodeValue.build(unless_arg)
-          )
-        end
-
         def build_from_hash( # rubocop:disable Metrics/ParameterLists
           has_arguments: nil, at: nil, has_value: nil,
           names: nil, match: nil, has_prefix: nil, has_suffix: nil,
@@ -56,13 +43,13 @@ module Leftovers
           literal: nil,
           unless_arg: nil
         )
-          ::Leftovers::MatcherBuilders::And.build([
+          And.build([
             build_node_has_argument_matcher(has_arguments, at, has_value),
             build_node_name_matcher(names, match, has_prefix, has_suffix),
-            ::Leftovers::MatcherBuilders::NodeType.build(type),
-            ::Leftovers::MatcherBuilders::NodeHasReceiver.build(has_receiver),
-            ::Leftovers::MatcherBuilders::NodeValue.build(literal),
-            build_unless(unless_arg)
+            NodeType.build(type),
+            NodeHasReceiver.build(has_receiver),
+            NodeValue.build(literal),
+            Unless.build(build(unless_arg))
           ])
         end
       end

data/lib/leftovers/matcher_builders/or.rb

@@ -9,7 +9,7 @@ module Leftovers
         def each_or_self(value, &block)
           case value
           when nil then nil
-          when Array then build(value.map(&block))
+          when ::Array then build(value.map(&block))
           else build([yield(value)])
           end
         end
@@ -21,8 +21,8 @@ module Leftovers
           when 0 then nil
             # :nocov:
           when 1 then matchers.first
-          when 2 then ::Leftovers::Matchers::Or.new(matchers.first, matchers[1])
-          else ::Leftovers::Matchers::Any.new(matchers.dup)
+          when 2 then Matchers::Or.new(matchers.first, matchers[1])
+          else Matchers::Any.new(matchers.dup)
           end
         end
 
@@ -30,11 +30,11 @@ module Leftovers
 
         def flatten(value)
           case value
-          when ::Leftovers::Matchers::Or
+          when Matchers::Or
             [*flatten(value.lhs), *flatten(value.rhs)]
-          when ::Leftovers::Matchers::Any
+          when Matchers::Any
             flatten(value.matchers)
-          when Array, Set
+          when ::Array, ::Set
             value.flat_map { |v| flatten(v) }
           else
             [value]
@@ -51,7 +51,7 @@ module Leftovers
             end
           end
 
-          groups.transform_values { |v| Leftovers.unwrap_array(v) }
+          groups.transform_values { |v| ::Leftovers.unwrap_array(v) }
         end
 
         def mergeable?(matcher)
@@ -59,15 +59,15 @@ module Leftovers
         end
 
         def build_grouped_for_matcher(matchers)
-          return matchers unless matchers.is_a?(Array)
+          return matchers unless matchers.is_a?(::Array)
           return matchers unless mergeable?(matchers.first)
 
           matchers.first.class.new(build(matchers.map(&:matcher)))
         end
 
         def build_grouped(set: nil, regexp: nil, nil: nil, **matcher_classes) # rubocop:disable Lint/UnusedMethodArgument i want to throw away nils
-          set = set.to_set.compare_by_identity if set.is_a?(Array)
-          regexp = Regexp.union(regexp) if regexp.is_a?(Array)
+          set = set.to_set.compare_by_identity if set.is_a?(::Array)
+          regexp = ::Regexp.union(regexp) if regexp.is_a?(::Array)
           matcher_classes = matcher_classes.each_value.flat_map do |matchers|
             build_grouped_for_matcher(matchers)
           end

data/lib/leftovers/matcher_builders/path.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 require 'fast_ignore'
 
@@ -8,8 +8,8 @@ module Leftovers
       def self.build(path_pattern)
         return if path_pattern.nil? || path_pattern.empty?
 
-        ::Leftovers::Matchers::Path.new(
-          ::FastIgnore.new(include_rules: path_pattern, gitignore: false, root: Leftovers.pwd)
+        Matchers::Path.new(
+          ::FastIgnore.new(include_rules: path_pattern, gitignore: false, root: ::Leftovers.pwd)
         )
       end
     end

data/lib/leftovers/matcher_builders/string_pattern.rb

@@ -21,6 +21,8 @@ module Leftovers
           /\A#{has_prefix}/
         elsif has_suffix
           /#{has_suffix}\z/
+        else
+          nil
         end
       end
     end

data/lib/leftovers/matcher_builders/unless.rb

@@ -4,9 +4,7 @@ module Leftovers
   module MatcherBuilders
     module Unless
       def self.build(matcher)
-        return unless matcher
-
-        ::Leftovers::Matchers::Not.new(matcher)
+        Matchers::Not.new(matcher) if matcher
       end
     end
   end

data/lib/leftovers/matcher_builders.rb

@@ -1,27 +1,7 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module MatcherBuilders
-    autoload(:AndNot, "#{__dir__}/matcher_builders/and_not")
-    autoload(:And, "#{__dir__}/matcher_builders/and")
-    autoload(:Document, "#{__dir__}/matcher_builders/document")
-    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(:NodePairKey, "#{__dir__}/matcher_builders/node_pair_key")
-    autoload(:NodePairValue, "#{__dir__}/matcher_builders/node_pair_value")
-    autoload(:NodePath, "#{__dir__}/matcher_builders/node_path")
-    autoload(:NodePrivacy, "#{__dir__}/matcher_builders/node_privacy")
-    autoload(:NodeType, "#{__dir__}/matcher_builders/node_type")
-    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")
-    autoload(:String, "#{__dir__}/matcher_builders/string")
-    autoload(:Unless, "#{__dir__}/matcher_builders/unless")
+    include Autoloader
   end
 end

data/lib/leftovers/matchers/node_has_block.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    module NodeHasBlock
+      def self.===(node)
+        node.block_given?
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_scalar_value.rb

@@ -1,4 +1,4 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module Matchers

data/lib/leftovers/matchers.rb

@@ -1,32 +1,7 @@
-# frozen-string-literal: true
+# frozen_string_literal: true
 
 module Leftovers
   module Matchers
-    autoload(:All, "#{__dir__}/matchers/all")
-    autoload(:And, "#{__dir__}/matchers/and")
-    autoload(:Any, "#{__dir__}/matchers/any")
-    autoload(:NodeHasAnyKeywordArgument, "#{__dir__}/matchers/node_has_any_keyword_argument")
-    autoload(
-      :NodeHasAnyPositionalArgumentWithValue,
-      "#{__dir__}/matchers/node_has_any_positional_argument_with_value"
-    )
-    autoload(:NodeHasAnyReceiver, "#{__dir__}/matchers/node_has_any_receiver")
-    autoload(
-      :NodeHasPositionalArgumentWithValue,
-      "#{__dir__}/matchers/node_has_positional_argument_with_value"
-    )
-    autoload(:NodeHasPositionalArgument, "#{__dir__}/matchers/node_has_positional_argument")
-    autoload(:NodeHasReceiver, "#{__dir__}/matchers/node_has_receiver")
-    autoload(:NodeIsProc, "#{__dir__}/matchers/node_is_proc")
-    autoload(:NodeName, "#{__dir__}/matchers/node_name")
-    autoload(:NodePairKey, "#{__dir__}/matchers/node_pair_key")
-    autoload(:NodePairValue, "#{__dir__}/matchers/node_pair_value")
-    autoload(:NodePath, "#{__dir__}/matchers/node_path")
-    autoload(:NodePrivacy, "#{__dir__}/matchers/node_privacy")
-    autoload(:NodeScalarValue, "#{__dir__}/matchers/node_scalar_value")
-    autoload(:NodeType, "#{__dir__}/matchers/node_type")
-    autoload(:Not, "#{__dir__}/matchers/not")
-    autoload(:Or, "#{__dir__}/matchers/or")
-    autoload(:Path, "#{__dir__}/matchers/path")
+    include Autoloader
   end
 end

data/lib/leftovers/merged_config.rb

@@ -17,7 +17,7 @@ module Leftovers
 
     def initialize(load_defaults: false)
       @configs = []
-      @loaded_configs = Set.new
+      @loaded_configs = ::Set.new
       return unless load_defaults
 
       self << :ruby
@@ -28,7 +28,8 @@ module Leftovers
     end
 
     def <<(config)
-      config = Leftovers::Config.new(config) unless config.is_a?(Leftovers::Config)
+      config = Config[config]
+
       return if @loaded_configs.include?(config.name)
 
       unmemoize
@@ -47,55 +48,53 @@ module Leftovers
     end
 
     def test_paths
-      @test_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
+      @test_paths ||= MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
     end
 
     def precompilers
-      @precompilers ||= Leftovers::Precompilers.build(@configs.flat_map(&:precompile))
+      @precompilers ||= Precompilers.build(@configs.flat_map(&:precompile))
     end
 
     def dynamic
-      @dynamic ||= ::Leftovers::ProcessorBuilders::Each.build(@configs.map(&:dynamic))
+      @dynamic ||= ProcessorBuilders::Each.build(@configs.map(&:dynamic))
     end
 
     def keep
-      @keep ||= ::Leftovers::MatcherBuilders::Or.build(@configs.map(&:keep))
+      @keep ||= MatcherBuilders::Or.build(@configs.map(&:keep))
     end
 
     def test_only
-      @test_only ||= ::Leftovers::MatcherBuilders::Or.build(@configs.map(&:test_only))
+      @test_only ||= MatcherBuilders::Or.build(@configs.map(&:test_only))
     end
 
     private
 
     def project_config
-      Leftovers::Config.new(:'.leftovers.yml', path: Leftovers.pwd + '.leftovers.yml')
+      Config.new(:'.leftovers.yml', path: ::Leftovers.pwd + '.leftovers.yml')
     end
 
     def project_todo
-      Leftovers::Config.new(:'.leftovers_todo.yml', path: Leftovers.pwd + '.leftovers_todo.yml')
+      Config.new(:'.leftovers_todo.yml', path: ::Leftovers.pwd + '.leftovers_todo.yml')
     end
 
     def unmemoize
-      MEMOIZED_IVARS.each do |ivar|
-        remove_instance_variable(ivar) if instance_variable_get(ivar)
-      end
+      MEMOIZED_IVARS.each { |ivar| remove_instance_variable(ivar) if instance_variable_get(ivar) }
     end
 
     def require_requires(config)
       config.requires.each do |req|
-        if req.is_a?(Hash) && req[:quiet]
-          Leftovers.try_require(req[:quiet])
+        if req.is_a?(::Hash) && req[:quiet]
+          ::Leftovers.try_require(req[:quiet])
         else
-          Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
+          ::Leftovers.try_require(req, message: "cannot require '#{req}' from #{config.name}.yml")
         end
       end
     end
 
     def load_bundled_gem_config
-      return unless Leftovers.try_require('bundler')
+      return unless ::Leftovers.try_require('bundler')
 
-      Bundler.locked_gems.specs.each do |spec|
+      ::Bundler.locked_gems.specs.each do |spec|
         self << spec.name
       end
     end

data/lib/leftovers/parser.rb

@@ -24,7 +24,7 @@ module Leftovers
       # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
       # but with our builder
       def parser
-        p = ::Parser::CurrentRuby.new(Leftovers::AST::Builder.new)
+        p = ::Parser::CurrentRuby.new(AST::Builder.new)
         p.diagnostics.all_errors_are_fatal = true
         p.diagnostics.ignore_warnings = true
 

data/lib/leftovers/precompile_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Leftovers
+  class PrecompileError < Error
+    attr_reader :line, :column
+
+    def initialize(message, line: nil, column: nil, display_class: nil)
+      @line = line
+      @column = column
+      @display_class = display_class
+      super(message)
+    end
+
+    def warn(path:)
+      ::Leftovers.warn "#{display_class}: #{path}#{location} #{message}"
+    end
+
+    private
+
+    def display_class
+      @display_class || cause&.class || self.class
+    end
+
+    def location
+      return unless line
+      return ":#{line}" unless column
+
+      ":#{line}:#{column}"
+    end
+  end
+end

data/lib/leftovers/precompilers/haml.rb

@@ -5,10 +5,30 @@ require 'haml'
 module Leftovers
   module Precompilers
     module Haml
+      HAML_RUNTIME_ERROR_RE = %r{
+        \A
+        _buf\s=\s'' # preamble
+        [\s;]*
+        # https://github.com/haml/haml/blob/main/lib/haml/compiler.rb#L93
+        raise\s(?:::)?(?<class>.*)\.new\(%q\[(?<message>.*)\],\s(?<line>\d)+\)
+        [\s;]*
+        _buf # postamble
+        \z
+      }x.freeze
+
       def self.precompile(haml)
-        ::Haml::Engine.new(haml).precompiled
-      rescue ::Haml::SyntaxError => e
-        raise Leftovers::PrecompileError.new(e.message, line: e.line)
+        out = ::Haml::TempleEngine.new.compile(haml)
+
+        if (e = out.match(HAML_RUNTIME_ERROR_RE))
+          raise PrecompileError.new(e[:message], line: e[:line], display_class: e[:class])
+        end
+
+        out
+        # :nocov:
+        # this is for haml < 6
+      rescue ::Haml::Error => e
+        raise PrecompileError.new(e.message, line: e.line)
+        # :nocov:
       end
     end
   end

data/lib/leftovers/precompilers/json.rb

@@ -14,7 +14,7 @@ module Leftovers
 
         def to_ruby_argument(value)
           ruby = value.inspect
-          return ruby unless value.is_a?(Array)
+          return ruby unless value.is_a?(::Array)
 
           ruby.delete_prefix!('[')
           ruby.delete_suffix!(']')

data/lib/leftovers/precompilers/precompiler.rb

@@ -15,11 +15,11 @@ module Leftovers
 
         begin
           @precompiler.precompile(content)
-        rescue Leftovers::PrecompileError => e
+        rescue PrecompileError => e
           e.warn(path: file.relative_path)
           ''
-        rescue StandardError => e
-          Leftovers.warn "#{e.class}: #{file.relative_path} #{e.message}"
+        rescue ::StandardError => e
+          ::Leftovers.warn "#{e.class}: #{file.relative_path} #{e.message}"
           ''
         end
       end

data/lib/leftovers/precompilers/slim.rb

@@ -8,7 +8,7 @@ module Leftovers
       def self.precompile(file)
         ::Slim::Engine.new(file: file).call(file)
       rescue ::Slim::Parser::SyntaxError => e
-        raise Leftovers::PrecompileError.new(e.error, line: e.lineno, column: e.column)
+        raise PrecompileError.new(e.error, line: e.lineno, column: e.column)
       end
     end
   end

data/lib/leftovers/precompilers/yaml/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Precompilers
+    module YAML
+      class Builder < ::Psych::TreeBuilder
+        def initialize
+          @constants = []
+
+          super
+        end
+
+        def add_constant_for_tag(tag, value = nil)
+          match = %r{\A!ruby/[^:]*(?::(.*))?\z}.match(tag)
+          return unless match
+
+          @constants << (match[1] || value)
+        end
+
+        def start_mapping(_anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag)
+          tag = nil
+
+          super
+        end
+
+        def start_sequence(_anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag)
+          tag = nil
+
+          super
+        end
+
+        def scalar(value, _anchor, tag, *rest) # leftovers:keep
+          add_constant_for_tag(tag, value)
+          tag = nil
+
+          super
+        end
+
+        def to_ruby_file
+          <<~FILE
+            __leftovers_document(#{to_ruby_argument(root.to_ruby.first)})
+            #{@constants.join("\n")}
+          FILE
+        end
+
+        private
+
+        def to_ruby_argument(value)
+          ruby = value.inspect
+          return ruby unless value.is_a?(::Array)
+
+          ruby.delete_prefix!('[')
+          ruby.delete_suffix!(']')
+
+          ruby
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/yaml.rb

@@ -5,70 +5,17 @@ require 'yaml'
 module Leftovers
   module Precompilers
     module YAML
-      class Builder < ::Psych::TreeBuilder
-        def initialize
-          @constants = []
-
-          super
-        end
-
-        def add_constant_for_tag(tag, value = nil)
-          match = %r{\A!ruby/[^:]*(?::(.*))?\z}.match(tag)
-          return unless match
-
-          @constants << (match[1] || value)
-        end
-
-        def start_mapping(_anchor, tag, *rest) # leftovers:keep
-          add_constant_for_tag(tag)
-          tag = nil
-
-          super
-        end
-
-        def start_sequence(_anchor, tag, *rest) # leftovers:keep
-          add_constant_for_tag(tag)
-          tag = nil
-
-          super
-        end
-
-        def scalar(value, _anchor, tag, *rest) # leftovers:keep
-          add_constant_for_tag(tag, value)
-          tag = nil
-
-          super
-        end
-
-        def to_ruby_file
-          <<~FILE
-            __leftovers_document(#{to_ruby_argument(root.to_ruby.first)})
-            #{@constants.join("\n")}
-          FILE
-        end
-
-        private
-
-        def to_ruby_argument(value)
-          ruby = value.inspect
-          return ruby unless value.is_a?(Array)
-
-          ruby.delete_prefix!('[')
-          ruby.delete_suffix!(']')
-
-          ruby
-        end
-      end
+      include Autoloader
 
       def self.precompile(yaml)
-        builder = ::Leftovers::Precompilers::YAML::Builder.new
+        builder = Builder.new
         parser = ::Psych::Parser.new(builder)
         parser.parse(yaml)
 
         builder.to_ruby_file
       rescue ::Psych::SyntaxError => e
         message = [e.problem, e.context].compact.join(' ')
-        raise ::Leftovers::PrecompileError.new(message, line: e.line, column: e.column)
+        raise PrecompileError.new(message, line: e.line, column: e.column)
       end
     end
   end

data/lib/leftovers/precompilers.rb

@@ -2,19 +2,14 @@
 
 module Leftovers
   module Precompilers
-    autoload(:ERB, "#{__dir__}/precompilers/erb")
-    autoload(:Haml, "#{__dir__}/precompilers/haml")
-    autoload(:JSON, "#{__dir__}/precompilers/json")
-    autoload(:Precompiler, "#{__dir__}/precompilers/precompiler")
-    autoload(:Slim, "#{__dir__}/precompilers/slim")
-    autoload(:YAML, "#{__dir__}/precompilers/yaml")
+    include Autoloader
 
     class << self
       def build(precompilers)
         precompilers.group_by { |p| build_precompiler(p[:format]) }.map do |format, precompiler|
           Precompiler.new(
             format,
-            Leftovers::MatcherBuilders::Path.build(precompiler.flat_map { |p| p[:paths] })
+            MatcherBuilders::Path.build(precompiler.flat_map { |p| p[:paths] })
           )
         end
       end
@@ -23,14 +18,14 @@ module Leftovers
 
       def build_precompiler(format)
         case format
-        when :erb then ::Leftovers::Precompilers::ERB
-        when :haml then ::Leftovers::Precompilers::Haml
-        when :json then ::Leftovers::Precompilers::JSON
-        when :slim then ::Leftovers::Precompilers::Slim
-        when :yaml then ::Leftovers::Precompilers::YAML
-        when Hash then constantize_precompiler(format[:custom])
+        when :erb then ERB
+        when :haml then Haml
+        when :json then JSON
+        when :slim then Slim
+        when :yaml then YAML
+        when ::Hash then constantize_precompiler(format[:custom])
           # :nocov:
-        else raise Leftovers::UnexpectedCase, "Unhandled value #{format}"
+        else raise UnexpectedCase, "Unhandled value #{format}"
           # :nocov:
         end
       end
@@ -38,9 +33,9 @@ module Leftovers
       def constantize_precompiler(precompiler)
         precompiler = "::#{precompiler}" unless precompiler.start_with?('::')
 
-        Object.const_get(precompiler, false)
+        ::Object.const_get(precompiler, false)
       rescue ::NameError
-        Leftovers.error <<~MESSAGE
+        ::Leftovers.error <<~MESSAGE
           Tried using #{precompiler}, but it wasn't available.
           add its path to `requires:` in your .leftovers.yml
         MESSAGE