Merge pull request #968 from jeffcarbs/dsl-by-path

Support generating DSL RBI by path

Author: paracycle

lib/tapioca/cli.rb

@@ -130,11 +130,15 @@ def todo
       type: :string,
       desc: "The path to the Rails application",
       default: "."
-    def dsl(*constants)
+    def dsl(*constant_or_paths)
       set_environment(options)
 
+      # Assume anything starting with a capital letter or colon is a class, otherwise a path
+      constants, paths = constant_or_paths.partition { |c| c =~ /\A[A-Z:]/ }
+
       command = Commands::Dsl.new(
         requested_constants: constants,
+        requested_paths: paths.map { |p| Pathname.new(p) },
         outpath: Pathname.new(options[:outdir]),
         only: options[:only],
         exclude: options[:exclude],

lib/tapioca/commands/dsl.rb

@@ -10,6 +10,7 @@ class Dsl < CommandWithoutTracker
       sig do
         params(
           requested_constants: T::Array[String],
+          requested_paths: T::Array[Pathname],
           outpath: Pathname,
           only: T::Array[String],
           exclude: T::Array[String],
@@ -27,6 +28,7 @@ class Dsl < CommandWithoutTracker
       end
       def initialize(
         requested_constants:,
+        requested_paths:,
         outpath:,
         only:,
         exclude:,
@@ -42,6 +44,7 @@ def initialize(
         app_root: "."
       )
         @requested_constants = requested_constants
+        @requested_paths = requested_paths
         @outpath = outpath
         @only = only
         @exclude = exclude
@@ -63,7 +66,7 @@ def initialize(
       def list_compilers
         Loaders::Dsl.load_application(
           tapioca_path: @tapioca_path,
-          eager_load: @requested_constants.empty?,
+          eager_load: @requested_constants.empty? && @requested_paths.empty?,
           app_root: @app_root,
         )
 
@@ -101,6 +104,15 @@ def execute
         end
         say("")
 
+        unless @requested_paths.empty?
+          constants_from_paths = Static::SymbolLoader.symbols_from_paths(@requested_paths).to_a
+          if constants_from_paths.empty?
+            say_error("\nWarning: No constants found in: #{@requested_paths.map(&:to_s).join(", ")}", :yellow)
+          end
+
+          @requested_constants += constants_from_paths
+        end
+
         outpath = @should_verify ? Pathname.new(Dir.mktmpdir) : @outpath
         rbi_files_to_purge = existing_rbi_filenames(@requested_constants)
 
@@ -153,6 +165,7 @@ def execute
       def create_pipeline
         Tapioca::Dsl::Pipeline.new(
           requested_constants: constantize(@requested_constants),
+          requested_paths: @requested_paths,
           requested_compilers: constantize_compilers(@only),
           excluded_compilers: constantize_compilers(@exclude),
           error_handler: ->(error) {
@@ -167,8 +180,9 @@ def existing_rbi_filenames(requested_constants, path: @outpath)
         filenames = if requested_constants.empty?
           Pathname.glob(path / "**/*.rbi")
         else
-          requested_constants.map do |constant_name|
-            dsl_rbi_filename(constant_name)
+          requested_constants.filter_map do |constant_name|
+            filename = dsl_rbi_filename(constant_name)
+            filename if File.exist?(filename)
           end
         end
 

lib/tapioca/dsl/pipeline.rb

@@ -12,6 +12,9 @@ class Pipeline
       sig { returns(T::Array[Module]) }
       attr_reader :requested_constants
 
+      sig { returns(T::Array[Pathname]) }
+      attr_reader :requested_paths
+
       sig { returns(T.proc.params(error: String).void) }
       attr_reader :error_handler
 
@@ -21,6 +24,7 @@ class Pipeline
       sig do
         params(
           requested_constants: T::Array[Module],
+          requested_paths: T::Array[Pathname],
           requested_compilers: T::Array[T.class_of(Compiler)],
           excluded_compilers: T::Array[T.class_of(Compiler)],
           error_handler: T.proc.params(error: String).void,
@@ -29,6 +33,7 @@ class Pipeline
       end
       def initialize(
         requested_constants:,
+        requested_paths: [],
         requested_compilers: [],
         excluded_compilers: [],
         error_handler: $stderr.method(:puts).to_proc,
@@ -39,6 +44,7 @@ def initialize(
           T::Enumerable[T.class_of(Compiler)],
         )
         @requested_constants = requested_constants
+        @requested_paths = requested_paths
         @error_handler = error_handler
         @number_of_workers = number_of_workers
         @errors = T.let([], T::Array[String])
@@ -50,11 +56,12 @@ def initialize(
         ).returns(T::Array[T.type_parameter(:T)])
       end
       def run(&blk)
-        constants_to_process = gather_constants(requested_constants)
+        constants_to_process = gather_constants(requested_constants, requested_paths)
           .select { |c| Module === c } # Filter value constants out
           .sort_by! { |c| T.must(Runtime::Reflection.name_of(c)) }
 
-        if constants_to_process.empty?
+        # It's OK if there are no constants to process if we received a valid file/path.
+        if constants_to_process.empty? && requested_paths.select { |p| File.exist?(p) }.empty?
           report_error(<<~ERROR)
             No classes/modules can be matched for RBI generation.
             Please check that the requested classes/modules include processable DSL methods.
@@ -115,12 +122,12 @@ def gather_active_compilers(requested_compilers, excluded_compilers)
         active_compilers
       end
 
-      sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
-      def gather_constants(requested_constants)
+      sig { params(requested_constants: T::Array[Module], requested_paths: T::Array[Pathname]).returns(T::Set[Module]) }
+      def gather_constants(requested_constants, requested_paths)
         constants = active_compilers.map(&:processable_constants).reduce(Set.new, :union)
         constants = filter_anonymous_and_reloaded_constants(constants)
 
-        constants &= requested_constants unless requested_constants.empty?
+        constants &= requested_constants unless requested_constants.empty? && requested_paths.empty?
         constants
       end
 

lib/tapioca/static/symbol_loader.rb

@@ -41,6 +41,20 @@ def gem_symbols(gem)
           symbols_from_paths(gem.files)
         end
 
+        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+        def symbols_from_paths(paths)
+          output = Tempfile.create("sorbet") do |file|
+            file.write(Array(paths).join("\n"))
+            file.flush
+
+            symbol_table_json_from("@#{file.path.shellescape}")
+          end
+
+          return Set.new if output.empty?
+
+          SymbolTableParser.parse_json(output)
+        end
+
         private
 
         sig { returns(T::Array[T.class_of(Rails::Engine)]) }
@@ -59,20 +73,6 @@ def engines
         def symbol_table_json_from(input, table_type: "symbol-table-json")
           sorbet("--no-config", "--quiet", "--print=#{table_type}", input).out
         end
-
-        sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
-        def symbols_from_paths(paths)
-          output = Tempfile.create("sorbet") do |file|
-            file.write(Array(paths).join("\n"))
-            file.flush
-
-            symbol_table_json_from("@#{file.path.shellescape}")
-          end
-
-          return Set.new if output.empty?
-
-          SymbolTableParser.parse_json(output)
-        end
       end
     end
   end

spec/tapioca/cli/dsl_spec.rb

@@ -726,6 +726,125 @@ class User; end
           assert_success_status(result)
         end
 
+        it "can be called by path" do
+          @project.write("lib/models/post.rb", <<~RB)
+            require "smart_properties"
+
+            class Post
+              include SmartProperties
+              property :title, accepts: String
+            end
+          RB
+
+          @project.write("lib/models/nested/user.rb", <<~RB)
+            require "smart_properties"
+
+            module Nested
+              class User
+                include SmartProperties
+                property :name, accepts: String
+              end
+            end
+          RB
+
+          @project.write("lib/job.rb", <<~RB)
+            require "smart_properties"
+
+            class User
+              include SmartProperties
+              property :name, accepts: String
+            end
+          RB
+
+          result = @project.tapioca("dsl lib/models")
+
+          assert_equal(<<~OUT, result.out)
+            Loading Rails application... Done
+            Loading DSL compiler classes... Done
+            Compiling DSL RBI files...
+
+                  create  sorbet/rbi/dsl/nested/user.rbi
+                  create  sorbet/rbi/dsl/post.rbi
+
+            Done
+
+            Checking generated RBI files...  Done
+              No errors found
+
+            All operations performed in working directory.
+            Please review changes and commit them.
+          OUT
+
+          assert_empty_stderr(result)
+
+          assert_project_file_exist("sorbet/rbi/dsl/post.rbi")
+          assert_project_file_exist("sorbet/rbi/dsl/nested/user.rbi")
+          refute_project_file_exist("sorbet/rbi/dsl/job.rbi")
+
+          assert_success_status(result)
+        end
+
+        it "does not generate anything and errors for non-existent paths" do
+          @project.write("lib/models/post.rb", <<~RB)
+            require "smart_properties"
+
+            class Post
+              include SmartProperties
+              property :title, accepts: String
+            end
+          RB
+
+          result = @project.tapioca("dsl path/to/nowhere.rb")
+
+          assert_equal(<<~OUT, result.out)
+            Loading Rails application... Done
+            Loading DSL compiler classes... Done
+            Compiling DSL RBI files...
+
+          OUT
+
+          assert_equal(<<~ERR, result.err)
+
+            Warning: No constants found in: path/to/nowhere.rb
+            No classes/modules can be matched for RBI generation.
+            Please check that the requested classes/modules include processable DSL methods.
+          ERR
+
+          refute_project_file_exist("sorbet/rbi/dsl/post.rbi")
+
+          refute_success_status(result)
+        end
+
+        it "does not generate anything but succeeds for real paths with no processable DSL" do
+          @project.write("lib/models/post.rb", <<~RB)
+            class Foo
+            end
+          RB
+
+          result = @project.tapioca("dsl lib/models")
+
+          assert_equal(<<~OUT, result.out)
+            Loading Rails application... Done
+            Loading DSL compiler classes... Done
+            Compiling DSL RBI files...
+
+
+            Done
+
+            Checking generated RBI files...  Done
+              No errors found
+
+            All operations performed in working directory.
+            Please review changes and commit them.
+          OUT
+
+          assert_empty_stderr(result)
+
+          refute_project_file_exist("sorbet/rbi/dsl/post.rbi")
+
+          assert_success_status(result)
+        end
+
         it "must run custom compilers" do
           @project.write("lib/post.rb", <<~RB)
             require "smart_properties"