leftovers 0.7.0 → 0.10.0

data/lib/leftovers/matchers/node_has_positional_argument_with_value.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class NodeHasPositionalArgumentWithValue
+      include ComparableInstance
+
       def initialize(position, matcher)
         @position = position
         @matcher = matcher
@@ -11,7 +13,10 @@ module Leftovers
       end
 
       def ===(node)
-        value_node = node.positional_arguments[@position]
+        args = node.positional_arguments
+        return unless args
+
+        value_node = args[@position]
         @matcher === value_node if value_node
       end
 

data/lib/leftovers/matchers/node_has_receiver.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class NodeHasReceiver
+      include ComparableInstance
+
+      attr_reader :matcher
+
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/node_is_proc.rb

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

data/lib/leftovers/matchers/node_name.rb

@@ -3,14 +3,20 @@
 module Leftovers
   module Matchers
     class NodeName
-      def initialize(name_matcher)
-        @name_matcher = name_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @name_matcher === node.name
+        name = node.name
+
+        @matcher === name if name
       end
 
       freeze

data/lib/leftovers/matchers/node_pair_key.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class NodePairKey
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
+
+        freeze
+      end
+
+      def ===(node)
+        @matcher === node.first
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers/node_pair_value.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePairValue
-      def initialize(value_matcher)
-        @value_matcher = value_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @value_matcher === node.second
+        @matcher === node.second
       end
 
       freeze

data/lib/leftovers/matchers/node_path.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePath
-      def initialize(path_matcher)
-        @path_matcher = path_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @path_matcher === node.path
+        @matcher === node.path
       end
 
       freeze

data/lib/leftovers/matchers/node_privacy.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodePrivacy
-      def initialize(privacy_matcher)
-        @privacy_matcher = privacy_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @privacy_matcher === node.privacy
+        @matcher === node.privacy
       end
 
       freeze

data/lib/leftovers/matchers/node_scalar_value.rb

@@ -3,6 +3,10 @@
 module Leftovers
   module Matchers
     class NodeScalarValue
+      include ComparableInstance
+
+      attr_reader :matcher
+
       def initialize(matcher)
         @matcher = matcher
 
@@ -10,7 +14,8 @@ module Leftovers
       end
 
       def ===(node)
-        return false unless node.scalar?
+        # can't just check to_scalar_value, it might be false/nil on purpose.
+        return unless node.scalar?
 
         @matcher === node.to_scalar_value
       end

data/lib/leftovers/matchers/node_type.rb

@@ -3,14 +3,18 @@
 module Leftovers
   module Matchers
     class NodeType
-      def initialize(type_matcher)
-        @type_matcher = type_matcher
+      include ComparableInstance
+
+      attr_reader :matcher
+
+      def initialize(matcher)
+        @matcher = matcher
 
         freeze
       end
 
       def ===(node)
-        @type_matcher === node.type
+        @matcher === node.type
       end
 
       freeze

data/lib/leftovers/matchers/not.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class Not
+      include ComparableInstance
+
       def initialize(matcher)
         @matcher = matcher
 

data/lib/leftovers/matchers/or.rb

@@ -3,6 +3,8 @@
 module Leftovers
   module Matchers
     class Or
+      include ComparableInstance
+
       attr_reader :lhs, :rhs
 
       def initialize(lhs, rhs)

data/lib/leftovers/matchers/path.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Leftovers
+  module Matchers
+    class Path
+      include ComparableInstance
+
+      def initialize(fast_ignore)
+        @fast_ignore = fast_ignore
+
+        freeze
+      end
+
+      def ===(path)
+        @fast_ignore.allowed?(path, exists: true, directory: false)
+      end
+
+      freeze
+    end
+  end
+end

data/lib/leftovers/matchers.rb

@@ -10,13 +10,16 @@ module Leftovers
       :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")
@@ -24,6 +27,6 @@ module Leftovers
     autoload(:NodeType, "#{__dir__}/matchers/node_type")
     autoload(:Not, "#{__dir__}/matchers/not")
     autoload(:Or, "#{__dir__}/matchers/or")
-    autoload(:Predicate, "#{__dir__}/matchers/predicate")
+    autoload(:Path, "#{__dir__}/matchers/path")
   end
 end

data/lib/leftovers/merged_config.rb

@@ -5,12 +5,23 @@ require 'fast_ignore'
 
 module Leftovers
   class MergedConfig
+    MEMOIZED_IVARS = %i{
+      @exclude_paths
+      @include_paths
+      @test_paths
+      @precompilers
+      @dynamic
+      @keep
+      @test_only
+    }.freeze
+
     def initialize(load_defaults: false)
       @configs = []
       @loaded_configs = Set.new
       return unless load_defaults
 
       self << :ruby
+      self << :leftovers
       self << project_config
       self << project_todo
       load_bundled_gem_config
@@ -27,34 +38,6 @@ module Leftovers
       require_requires(config)
     end
 
-    def project_config
-      Leftovers::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')
-    end
-
-    MEMOIZED_IVARS = %i{
-      @exclude_paths
-      @include_paths
-      @test_paths
-      @haml_paths
-      @slim_paths
-      @yaml_paths
-      @json_paths
-      @erb_paths
-      @dynamic
-      @keep
-      @test_only
-    }.freeze
-
-    def unmemoize
-      MEMOIZED_IVARS.each do |ivar|
-        remove_instance_variable(ivar) if instance_variable_get(ivar)
-      end
-    end
-
     def exclude_paths
       @exclude_paths ||= @configs.flat_map(&:exclude_paths)
     end
@@ -67,28 +50,12 @@ module Leftovers
       @test_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:test_paths))
     end
 
-    def haml_paths
-      @haml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:haml_paths))
-    end
-
-    def slim_paths
-      @slim_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:slim_paths))
-    end
-
-    def yaml_paths
-      @yaml_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:yaml_paths))
-    end
-
-    def json_paths
-      @json_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:json_paths))
-    end
-
-    def erb_paths
-      @erb_paths ||= Leftovers::MatcherBuilders::Path.build(@configs.flat_map(&:erb_paths))
+    def precompilers
+      @precompilers ||= Leftovers::Precompilers.build(@configs.flat_map(&:precompile))
     end
 
     def dynamic
-      @dynamic ||= ::Leftovers::ProcessorBuilders::EachDynamic.build(@configs.map(&:dynamic))
+      @dynamic ||= ::Leftovers::ProcessorBuilders::Each.build(@configs.map(&:dynamic))
     end
 
     def keep
@@ -101,6 +68,20 @@ module Leftovers
 
     private
 
+    def project_config
+      Leftovers::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')
+    end
+
+    def unmemoize
+      MEMOIZED_IVARS.each do |ivar|
+        remove_instance_variable(ivar) if instance_variable_get(ivar)
+      end
+    end
+
     def require_requires(config)
       config.requires.each do |req|
         if req.is_a?(Hash) && req[:quiet]

data/lib/leftovers/parser.rb

@@ -10,14 +10,17 @@ module Leftovers
       # but with our parser
       def parse_with_comments(string, file = '(string)', line = 1)
         PARSER.reset
-        source_buffer = ::Parser::CurrentRuby.send(
-          :setup_source_buffer, file, line, string, PARSER.default_encoding
-        )
-        PARSER.parse_with_comments(source_buffer)
+        PARSER.parse_with_comments(new_source_buffer(string, file, line))
       end
 
       private
 
+      def new_source_buffer(string, file, line)
+        ::Parser::CurrentRuby.send(
+          :setup_source_buffer, file, line, string, PARSER.default_encoding
+        )
+      end
+
       # mostly copied from https://github.com/whitequark/parser/blob/master/lib/parser/base.rb
       # but with our builder
       def parser

data/lib/leftovers/precompilers/erb.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module Leftovers
+  module Precompilers
+    class ERB < ::ERB::Compiler
+      def self.precompile(erb)
+        @compiler ||= new('-')
+        @compiler.compile(erb).first
+      end
+
+      def add_insert_cmd(out, content) # leftovers:keep
+        out.push("\n#{content}\n")
+      end
+
+      def add_put_cmd(out, _content) # leftovers:keep
+        out.push("\n")
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/haml.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'haml'
+
+module Leftovers
+  module Precompilers
+    module Haml
+      def self.precompile(haml)
+        ::Haml::Engine.new(haml).precompiled
+      rescue ::Haml::SyntaxError => e
+        raise Leftovers::PrecompileError.new(e.message, line: e.line)
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/json.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Leftovers
+  module Precompilers
+    module JSON
+      class << self
+        def precompile(json)
+          "__leftovers_document(#{to_ruby_argument(::JSON.parse(json))})"
+        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/precompiler.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Leftovers
+  module Precompilers
+    class Precompiler
+      def initialize(precompiler, matcher)
+        @precompiler = precompiler
+        @matcher = matcher
+      end
+
+      def precompile(content, file)
+        return unless @matcher === file.relative_path
+
+        begin
+          @precompiler.precompile(content)
+        rescue Leftovers::PrecompileError => e
+          e.warn(path: file.relative_path)
+          ''
+        rescue StandardError => e
+          Leftovers.warn "#{e.class}: #{file.relative_path} #{e.message}"
+          ''
+        end
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/slim.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'slim'
+
+module Leftovers
+  module Precompilers
+    module Slim
+      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)
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers/yaml.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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
+
+      def self.precompile(yaml)
+        builder = ::Leftovers::Precompilers::YAML::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)
+      end
+    end
+  end
+end

data/lib/leftovers/precompilers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+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")
+
+    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] })
+          )
+        end
+      end
+
+      private
+
+      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])
+          # :nocov:
+        else raise Leftovers::UnexpectedCase, "Unhandled value #{format}"
+          # :nocov:
+        end
+      end
+
+      def constantize_precompiler(precompiler)
+        precompiler = "::#{precompiler}" unless precompiler.start_with?('::')
+
+        Object.const_get(precompiler, false)
+      rescue ::NameError
+        Leftovers.error <<~MESSAGE
+          Tried using #{precompiler}, but it wasn't available.
+          add its path to `requires:` in your .leftovers.yml
+        MESSAGE
+      end
+    end
+  end
+end