Allow to configure parsers in packwerk

USAGE.md

@@ -80,6 +80,28 @@ Packwerk reads from the `packwerk.yml` configuration file in the root directory.
 | cache                | false                                     | when true, caches the results of parsing files |
 | cache_directory      | tmp/cache/packwerk                        | the directory that will hold the packwerk cache |
 
+### Using custom parsers
+
+You can specify a custom parser to parse different file formats (e.g. slim or haml)
+
+```ruby
+class SlimParser
+  include ParserInterface
+
+  REGEX = /\.slim\Z/
+
+  def call
+    # Your parsing logic here
+  end
+
+  def match?(path)
+    REGEX.match?(path)
+  end
+end
+
+Packwerk::Parsers::Factory.instance.parsers.append(SlimParser)
+```
+
 ### Using a custom ERB parser
 
 You can specify a custom ERB parser if needed. For example, if you're using `<%graphql>` tags from https://github.com/github/graphql-client in your ERBs, you can use a custom parser subclass to comment them out so that Packwerk can parse the rest of the file:
@@ -99,7 +121,7 @@ class CustomParser < Packwerk::Parsers::Erb
   end
 end
 
-Packwerk::Parsers::Factory.instance.erb_parser_class = CustomParser
+Packwerk::Parsers::Factory.instance.parsers = [Packwerk::Parsers::Ruby, CustomParser]
 ```
 
 ## Using the cache

lib/packwerk/parsers/erb.rb

@@ -11,6 +11,9 @@ module Parsers
     class Erb
       include ParserInterface
 
+      ERB_REGEX = /\.erb\Z/
+      private_constant :ERB_REGEX
+
       def initialize(parser_class: BetterHtml::Parser, ruby_parser: Ruby.new)
         @parser_class = parser_class
         @ruby_parser = ruby_parser
@@ -33,6 +36,10 @@ def parse_buffer(buffer, file_path:)
         raise Parsers::ParseError, result
       end
 
+      def self.match?(path)
+        ERB_REGEX.match?(path)
+      end
+
       private
 
       def to_ruby_ast(erb_ast, file_path)

lib/packwerk/parsers/factory.rb

@@ -9,34 +9,24 @@ class Factory
       extend T::Sig
       include Singleton
 
-      RUBY_REGEX = %r{
-        # Although not important for regex, these are ordered from most likely to match to least likely.
-        \.(rb|rake|builder|gemspec|ru)\Z
-        |
-        (Gemfile|Rakefile)\Z
-      }x
-      private_constant :RUBY_REGEX
+      DEFAULT_PARSERS = T.let([
+        Ruby,
+        Erb,
+      ], T::Array[ParserInterface])
 
-      ERB_REGEX = /\.erb\Z/
-      private_constant :ERB_REGEX
+      sig { returns(T::Array[ParserInterface]) }
+      attr_accessor :parsers
 
-      sig { params(path: String).returns(T.nilable(ParserInterface)) }
-      def for_path(path)
-        case path
-        when RUBY_REGEX
-          @ruby_parser ||= Ruby.new
-        when ERB_REGEX
-          @erb_parser ||= erb_parser_class.new
-        end
+      sig { void }
+      def initialize
+        @parsers = T.let(DEFAULT_PARSERS, T::Array[ParserInterface])
       end
 
-      def erb_parser_class
-        @erb_parser_class ||= Erb
-      end
+      sig { params(path: String).returns(T.nilable(ParserInterface)) }
+      def for_path(path)
+        parser_for_path = parsers.find { |parser| parser.match?(path) }
 
-      def erb_parser_class=(klass)
-        @erb_parser_class = klass
-        @erb_parser = nil
+        parser_for_path&.new
       end
     end
   end

lib/packwerk/parsers/parser_interface.rb

@@ -12,6 +12,10 @@ module ParserInterface
       sig { abstract.params(io: File, file_path: String).returns(T.untyped) }
       def call(io:, file_path:)
       end
+
+      sig { abstract.params(path: String).returns(T.boolean) }
+      def self.match?(path:)
+      end
     end
   end
 end

lib/packwerk/parsers/ruby.rb

@@ -9,6 +9,14 @@ module Parsers
     class Ruby
       include ParserInterface
 
+      RUBY_REGEX = %r{
+        # Although not important for regex, these are ordered from most likely to match to least likely.
+        \.(rb|rake|builder|gemspec|ru)\Z
+        |
+        (Gemfile|Rakefile)\Z
+      }x
+      private_constant :RUBY_REGEX
+
       class RaiseExceptionsParser < Parser::CurrentRuby
         def initialize(builder)
           super(builder)
@@ -39,6 +47,10 @@ def call(io:, file_path: "<unknown>")
         result = ParseResult.new(file: file_path, message: "Syntax error: #{e}")
         raise Parsers::ParseError, result
       end
+
+      def self.match?(path)
+        RUBY_REGEX.match?(path)
+      end
     end
   end
 end

test/unit/parsers/factory_test.rb

@@ -23,13 +23,19 @@ class FactoryTest < Minitest::Test
         assert_instance_of(Parsers::Erb, factory.for_path("foo.html.erb"))
         assert_instance_of(Parsers::Erb, factory.for_path("foo.md.erb"))
         assert_instance_of(Parsers::Erb, factory.for_path("/sub/directory/foo.erb"))
+      end
 
-        fake_class = Class.new do
+      test "#for_path gives custom parser for paths the parser is defined to match" do
+        fake_erb_parser_class = Class.new do
           T.unsafe(self).include(ParserInterface)
+
+          def self.match?(path)
+            /\.erb\Z/.match?(path)
+          end
         end
 
-        with_erb_parser_class(fake_class) do
-          assert_instance_of(fake_class, factory.for_path("foo.html.erb"))
+        with_parser_class(fake_erb_parser_class) do
+          assert_instance_of(fake_erb_parser_class, factory.for_path("foo.html.erb"))
         end
       end
 
@@ -41,11 +47,11 @@ class FactoryTest < Minitest::Test
 
       private
 
-      def with_erb_parser_class(klass)
-        factory.erb_parser_class = klass
+      def with_parser_class(klass)
+        factory.parsers = [klass]
         yield
       ensure
-        factory.erb_parser_class = nil
+        factory.parsers = Parsers::Factory::DEFAULT_PARSERS
       end
 
       def factory