WIP: Support unconvention compilers

lib/ruby_lsp/tapioca/addon.rb

@@ -71,22 +71,32 @@ def version
 
       sig { params(changes: T::Array[{ uri: String, type: Integer }]).void }
       def workspace_did_change_watched_files(changes)
+        T.must(@outgoing_queue) << Notification.window_log_message("***: did_change")
         return unless T.must(@global_state).enabled_feature?(:tapiocaAddon)
         return unless @rails_runner_client # Client is not ready
 
+        T.must(@outgoing_queue) << Notification.window_log_message("***: collecting")
+
         constants = changes.flat_map do |change|
           path = URI(change[:uri]).to_standardized_path
+          T.must(@outgoing_queue) << Notification.window_log_message("***: path: #{path}")
           next if path.end_with?("_test.rb", "_spec.rb")
           next unless file_updated?(change, path)
 
-          entries = T.must(@index).entries_for(change[:uri])
-          next unless entries
+          entries = T.must(@index).entries_for(change[:uri]) || []
+          # unless entries
+          #   T.must(@outgoing_queue) << Notification.window_log_message("***: nexting")
+          #   next
+          # end
+          T.must(@outgoing_queue) << Notification.window_log_message("***: nexting")
 
           entries.filter_map do |entry|
             entry.name if entry.class == RubyIndexer::Entry::Class || entry.class == RubyIndexer::Entry::Module
-          end
+          end + [path]
         end.compact
 
+        T.must(@outgoing_queue) << Notification.window_log_message("***: #{constants}")
+
         return if constants.empty?
 
         @rails_runner_client.trigger_reload

lib/tapioca/commands/abstract_dsl.rb

@@ -131,7 +131,7 @@ def load_application
       def create_pipeline
         Tapioca::Dsl::Pipeline.new(
           requested_constants:
-            constantize(@requested_constants) + constantize(constants_from_requested_paths, ignore_missing: true),
+            constantize(@requested_constants) + constantize(constants_from_requested_paths, ignore_missing: true), # constants_from_requested_paths
           requested_paths: @requested_paths,
           requested_compilers: constantize_compilers(@only),
           excluded_compilers: constantize_compilers(@exclude),

lib/tapioca/dsl/compiler.rb

@@ -35,6 +35,11 @@ def handles?(constant)
           processable_constants.include?(constant)
         end
 
+        sig { params(path: String).returns(T::Boolean) }
+        def handles_path?(path)
+          path.end_with?(".rb")
+        end
+
         sig { abstract.returns(T::Enumerable[Module]) }
         def gather_constants; end
 

lib/tapioca/dsl/compilers/active_record_fixtures.rb

@@ -66,6 +66,12 @@ def gather_constants
 
             [ActiveSupport::TestCase]
           end
+
+          sig { params(path: String).returns(T::Boolean) }
+          def handles_path?(path)
+            # TODO: `spec` too?
+            File.fnmatch("test/fixtures/**/*.yml{,.erb}", path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+          end
         end
 
         private

lib/tapioca/dsl/pipeline.rb

@@ -73,6 +73,18 @@ def run(&blk)
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
         # It's OK if there are no constants to process if we received a valid file/path.
+        # binding.break
+
+        requested_paths.each do |requested_path|
+          @active_compilers.each do |compiler|
+            next unless compiler.handles_path?(requested_path.to_s)
+
+            # TODO: generalize for other types
+            # constants_to_process << compiler.gather_constants
+            constants_to_process += compiler.gather_constants
+          end
+        end
+        # binding.break
         if constants_to_process.empty? && requested_paths.none? { |p| File.exist?(p) }
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
@@ -84,6 +96,7 @@ def run(&blk)
           abort_if_pending_migrations!
         end
 
+        # binding.break
         result = Executor.new(
           constants_to_process,
           number_of_workers: @number_of_workers,
@@ -205,6 +218,7 @@ def rbi_for_constant(constant)
           next unless compiler_class.handles?(constant)
 
           compiler = compiler_class.new(self, file.root, constant, @compiler_options)
+          # binding.break
           compiler.decorate
         rescue
           $stderr.puts("Error: `#{compiler_class.name}` failed to generate RBI for `#{constant}`")

spec/tapioca/dsl/compilers/active_record_fixtures_spec.rb

@@ -230,6 +230,16 @@ def posts(fixture_name = nil, *other_fixtures); end
               assert_equal(expected, rbi_for("ActiveSupport::TestCase"))
             end
           end
+
+          describe "#handles_path?" do
+            it "matches the fixtures path" do
+              assert(ActiveRecordFixtures.handles_path?("test/fixtures/posts.yml"))
+              assert(ActiveRecordFixtures.handles_path?("test/fixtures/posts.yml.erb"))
+              assert(ActiveRecordFixtures.handles_path?("test/fixtures/more/posts.yml"))
+              refute(ActiveRecordFixtures.handles_path?("test/fixtures/posts.rb"))
+              refute(ActiveRecordFixtures.handles_path?("test/elsewhere/posts.yml"))
+            end
+          end
         end
 
         private