rbs-inline 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1a71b1f31f0a31d47ce7d19bde6f0145203c52e830f781dad464be32f46402b
-  data.tar.gz: fbccd964aaaff4af93ee63a72a6b52e610bd3e66c5a12f3e042c180096e40d14
+  metadata.gz: 44afba2006b4ffed3719716d5ac515d474dc7ba9ee18c4f9b3298c9925441284
+  data.tar.gz: 2c008cd99c1de1a2cb80945eed727b74fe9450af07fd3d20299775d5ee728978
 SHA512:
-  metadata.gz: bbf05cddf2f37f7d1f9de08e0267c77b1af127560b6de0ed0710267579057b0c4c8000462da0faf375754d5da9a927da3b1c7df289b1614e4d60558ba1722619
-  data.tar.gz: b0af1f6f5640604ea3b812c3f6df6dbcd8cc87e41c04ef72fe325928511a5ba73520a0e898f3998151e657a2f4d346022a503f1e6bbb8de67e6dec92f810df1e
+  metadata.gz: d7d02d3e07d295c00890ac95bad4c2f7f49700a0cdddb9885dcc3c194d272ef5b387c168f675a46f2b5dc3f49aaeb5230603dbe7ebcea20087952aebb7516b66
+  data.tar.gz: 6e476d54d6db64e42cdc7a6bfe9dfb5b1454f290e2746836cc17fe77ca41db5dac2b1a01d311877af189ee7ad2bd06207f1db2aaac86e1e494dd5855e921254d

data/README.md

@@ -3,11 +3,16 @@
 RBS::Inline allows embedding RBS type declarations into Ruby code as comments. You can declare types, write the implementation, and verifies they are consistent without leaving the editor opening the Ruby code.
 
 > [!IMPORTANT]
-> The gem is experimental. We are still seeking the best syntax with your feedbacks.
+> The syntax is experimental. We are still seeking the best syntax with your feedbacks.
+
+> [!IMPORTANT]
+> This gem is a prototype for testing. We plan to merge this feature to rbs-gem and deprecate rbs-inline gem after that.
 
 Here is a quick example of embedded declarations.
 
 ```rb
+# rbs_inline: enabled
+
 class Person
   attr_reader :name #:: String
 

data/lib/rbs/inline/annotation_parser.rb

@@ -501,7 +501,7 @@ module RBS
       #
       # ```
       # Integer -- Foo        # => Returns `Integer`, tokenizer has `--` as its current token
-      # Integer[ -- Foo       # => Returns a tree for `Integer[`, tokenizer has `--` as its curren token
+      # Integer[ -- Foo       # => Returns a tree for `Integer[`, tokenizer has `--` as its current token
       # Integer[ Foo          # => Returns a tree for `Integer[ Foo`, tokenizer is at the end of the input
       # ```
       #

data/lib/rbs/inline/ast/declarations.rb

@@ -9,18 +9,8 @@ module RBS
           # @rbs returns TypeName?
           def type_name(node)
             case node
-            when Prism::ConstantReadNode
-              TypeName(node.name.to_s)
-            when Prism::ConstantPathNode
-              if node.parent
-                if parent = type_name(node.parent)
-                  if child = type_name(node.child)
-                    return parent + child
-                  end
-                end
-              else
-                type_name(node.child)&.absolute!
-              end
+            when Prism::ConstantReadNode, Prism::ConstantPathNode
+              TypeName(node.full_name)
             end
           end
         end

data/lib/rbs/inline/ast/members.rb

@@ -69,7 +69,7 @@ module RBS
           # [FIXME] It only supports `self` receiver.
           #
           # ```rb
-          # def self.foo = ()    # :sigleton
+          # def self.foo = ()    # :singleton
           # def object.foo = ()  # Not supported (returns :instance)
           # ```
           #
@@ -578,7 +578,7 @@ module RBS
               end
             RBS
 
-            _, dirs, decls = RBS::Parser.parse_signature(source)
+            _, _, decls = RBS::Parser.parse_signature(source)
 
             mod = decls[0]
             mod.is_a?(RBS::AST::Declarations::Module) or raise

data/lib/rbs/inline/cli.rb

@@ -5,6 +5,56 @@ require "optparse"
 module RBS
   module Inline
     class CLI
+      # Calculate the path under `output_path` that has the same structure relative to one of the `base_paths`
+      #
+      # ```rb
+      # calculator = PathCalculator.new(Pathname("/rbs-inline"), [Pathname("app"), Pathname("lib")], Pathname("/tmp/sig"))
+      # calculator.calculate(Pathname("/rbs-inline/app/models/foo.rb"))   # => Pathname("/tmp/sig/models/foo.rb")
+      # calculator.calculate(Pathname("/rbs-inline/lib/bar.rb"))          # => Pathname("/tmp/sig/bar.rb")
+      # calculator.calculate(Pathname("/rbs-inline/hello/world.rb"))      # => Pathname("/tmp/sig/hello/world.rb")
+      # calculator.calculate(Pathname("/foo.rb"))                         # => nil
+      # ```
+      #
+      #
+      class PathCalculator
+        attr_reader :pwd #:: Pathname
+
+        attr_reader :base_paths #:: Array[Pathname]
+
+        attr_reader :output_path #:: Pathname
+
+        # @rbs pwd: Pathname
+        # @rbs base_paths: Array[Pathname]
+        # @rbs output_path: Pathname
+        def initialize(pwd, base_paths, output_path) #:: void
+          @pwd = pwd
+          @base_paths = base_paths
+          @output_path = output_path
+        end
+
+        #:: (Pathname) -> Pathname?
+        def calculate(path)
+          path = pwd + path if path.relative?
+          path = path.cleanpath
+          return nil unless has_prefix?(path, prefix: pwd)
+
+          if prefix = base_paths.find {|base| has_prefix?(path, prefix: pwd + base) }
+            relative_to_output = path.relative_path_from(pwd + prefix)
+          else
+            relative_to_output = path.relative_path_from(pwd)
+          end
+
+          output_path + relative_to_output
+        end
+
+        # @rbs path: Pathname
+        # @rbs prefix: Pathname
+        # @rbs returns bool
+        def has_prefix?(path, prefix:)
+          path.descend.include?(prefix)
+        end
+      end
+
       attr_reader :stdout, :stderr #:: IO
       attr_reader :logger #:: Logger
 
@@ -20,16 +70,30 @@ module RBS
       # @rbs args: Array[String]
       # @rbs returns Integer
       def run(args)
-        base_path = Pathname("lib")
+        base_paths = [Pathname("lib"), Pathname("app")]
         output_path = nil #: Pathname?
+        opt_in = true
 
         OptionParser.new do |opts|
-          opts.on("--base=[BASE]", "The path to calculate relative path of files (defaults to #{base_path})") do
-            base_path = Pathname(_1)
+          opts.on("--base=BASE", "The path to calculate relative path of files (defaults to #{base_paths.join(File::PATH_SEPARATOR)})") do |str|
+            # @type var str: String
+            base_paths = str.split(File::PATH_SEPARATOR).map {|path| Pathname(path) }
           end
 
-          opts.on("--output=[BASE]", "The directory where the RBS files are saved at (defaults to STDOUT if not specified)") do
-            output_path = Pathname(_1)
+          opts.on("--output[=DEST]", "Save the generated RBS files under `sig/generated` or DEST if specified (defaults to output to STDOUT)") do
+            if _1
+              output_path = Pathname(_1)
+            else
+              output_path = Pathname("sig/generated")
+            end
+          end
+
+          opts.on("--opt-out", "Generates RBS files by default. Opt-out with `# rbs_inline: disabled` comment") do
+            opt_in = false
+          end
+
+          opts.on("--opt-in", "Generates RBS files only for files with `# rbs_inline: enabled` comment (default)") do
+            opt_in = true
           end
 
           opts.on("--verbose") do
@@ -37,17 +101,17 @@ module RBS
           end
         end.parse!(args)
 
-        base_path = Pathname.pwd + base_path
-
-        logger.debug { "base_path = #{base_path}, output_path = #{output_path}" }
+        logger.debug { "base_paths = #{base_paths.join(File::PATH_SEPARATOR)}, output_path = #{output_path}" }
 
-        targets = args.flat_map do
-          path = Pathname(_1)
+        if output_path
+          calculator = PathCalculator.new(Pathname.pwd, base_paths, output_path)
+        end
 
+        targets = args.flat_map { Pathname.glob(_1) }.flat_map do |path|
           if path.directory?
             pattern = path + "**/*.rb"
             Pathname.glob(pattern.to_s)
-          else 
+          else
             path
           end
         end
@@ -58,12 +122,14 @@ module RBS
         count = 0
 
         targets.each do |target|
-          relative_path = (Pathname.pwd + target).relative_path_from(base_path)
-          if output_path
-            output = output_path + relative_path.sub_ext(".rbs")
+          absolute_path = Pathname.pwd + target
 
-            unless output.to_s.start_with?(output_path.to_s)
-              raise "Cannot calculate the output file path for #{target} in #{output_path}"
+          if output_path && calculator
+            output_file_path = calculator.calculate(absolute_path)
+            if output_file_path
+              output = output_file_path.sub_ext(".rbs")
+            else
+              raise "Cannot calculate the output file path for #{target} in #{output_path}: calculated = #{output}"
             end
 
             logger.debug { "Generating #{output} from #{target} ..." }
@@ -73,7 +139,7 @@ module RBS
 
           logger.debug { "Parsing ruby file #{target}..." }
 
-          if (uses, decls = Parser.parse(Prism.parse_file(target.to_s)))
+          if (uses, decls = Parser.parse(Prism.parse_file(target.to_s), opt_in: opt_in))
             writer = Writer.new()
             writer.header("Generated from #{target.relative? ? target : target.relative_path_from(Pathname.pwd)} with RBS::Inline")
             writer.write(uses, decls)
@@ -84,14 +150,18 @@ module RBS
                 output.parent.mkpath
               end
 
-              logger.debug { "Writing RBS file to #{output}..." }
-              output.write(writer.output)
+              if output.file? && output.read == writer.output
+                logger.debug { "Skip writing identical RBS file" }
+              else
+                logger.debug { "Writing RBS file to #{output}..." }
+                output.write(writer.output)
+                count += 1
+              end
             else
               stdout.puts writer.output
               stdout.puts
+              count += 1
             end
-
-            count += 1
           else
             logger.debug { "Skipping #{target} because `# rbs_inline: enabled` comment not found" }
           end

data/lib/rbs/inline/parser.rb

@@ -38,20 +38,25 @@ module RBS
         @comments = {}
       end
 
-      # @rbs result: ParseResult[ProgramNode]
+      # @rbs result: ParseResult
+      # @rbs opt_in: bool -- `true` for *opt-out* mode, `false` for *opt-in* mode.
       # @rbs returns [Array[AST::Annotations::Use], Array[AST::Declarations::t]]?
-      def self.parse(result)
+      def self.parse(result, opt_in:)
         instance = Parser.new()
 
-        # pp result
-
         annots = AnnotationParser.parse(result.comments)
         annots.each do |result|
           instance.comments[result.line_range.end] = result
         end
 
-        if result.comments.none? {|comment| comment.location.slice =~ /\A# rbs_inline: enabled\Z/}
-          return
+        with_enable_magic_comment = result.comments.any? {|comment| comment.location.slice =~ /\A# rbs_inline: enabled\Z/}
+        with_disable_magic_comment = result.comments.any? {|comment| comment.location.slice =~ /\A# rbs_inline: disabled\Z/}
+
+        return if with_disable_magic_comment # Skips if `rbs_inline: disabled`
+
+        if opt_in
+          # opt-in means the `rbs_inline: enable` is required.
+          return unless with_enable_magic_comment
         end
 
         uses = [] #: Array[AST::Annotations::Use]
@@ -71,7 +76,7 @@ module RBS
         ]
       end
 
-      # @rbs rturns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil
+      # @rbs returns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil
       def current_class_module_decl
         surrounding_decls.last
       end

data/lib/rbs/inline/version.rb

@@ -2,6 +2,6 @@
 
 module RBS
   module Inline
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/rbs_collection.lock.yaml

@@ -38,7 +38,7 @@ gems:
   source:
     type: stdlib
 - name: prism
-  version: 0.24.0
+  version: 0.29.0
   source:
     type: rubygems
 - name: rake
@@ -46,7 +46,7 @@ gems:
   source:
     type: git
     name: ruby/gem_rbs_collection
-    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
+    revision: 7a105f52053ce1c708b605dfa9c1ab8473424036
     remote: https://github.com/ruby/gem_rbs_collection.git
     repo_dir: gems
 - name: rbs

data/sig/generated/rbs/inline/annotation_parser.rbs

@@ -146,7 +146,7 @@ module RBS
       #
       # ```
       # Integer -- Foo        # => Returns `Integer`, tokenizer has `--` as its current token
-      # Integer[ -- Foo       # => Returns a tree for `Integer[`, tokenizer has `--` as its curren token
+      # Integer[ -- Foo       # => Returns a tree for `Integer[`, tokenizer has `--` as its current token
       # Integer[ Foo          # => Returns a tree for `Integer[ Foo`, tokenizer is at the end of the input
       # ```
       #

data/sig/generated/rbs/inline/ast/members.rbs

@@ -49,7 +49,7 @@ module RBS
           # [FIXME] It only supports `self` receiver.
           #
           # ```rb
-          # def self.foo = ()    # :sigleton
+          # def self.foo = ()    # :singleton
           # def object.foo = ()  # Not supported (returns :instance)
           # ```
           def method_kind: () -> RBS::AST::Members::MethodDefinition::kind

data/sig/generated/rbs/inline/cli.rbs

@@ -3,6 +3,37 @@
 module RBS
   module Inline
     class CLI
+      # Calculate the path under `output_path` that has the same structure relative to one of the `base_paths`
+      #
+      # ```rb
+      # calculator = PathCalculator.new(Pathname("/rbs-inline"), [Pathname("app"), Pathname("lib")], Pathname("/tmp/sig"))
+      # calculator.calculate(Pathname("/rbs-inline/app/models/foo.rb"))   # => Pathname("/tmp/sig/models/foo.rb")
+      # calculator.calculate(Pathname("/rbs-inline/lib/bar.rb"))          # => Pathname("/tmp/sig/bar.rb")
+      # calculator.calculate(Pathname("/rbs-inline/hello/world.rb"))      # => Pathname("/tmp/sig/hello/world.rb")
+      # calculator.calculate(Pathname("/foo.rb"))                         # => nil
+      # ```
+      #
+      class PathCalculator
+        attr_reader pwd: Pathname
+
+        attr_reader base_paths: Array[Pathname]
+
+        attr_reader output_path: Pathname
+
+        # @rbs pwd: Pathname
+        # @rbs base_paths: Array[Pathname]
+        # @rbs output_path: Pathname
+        def initialize: (Pathname pwd, Array[Pathname] base_paths, Pathname output_path) -> void
+
+        # :: (Pathname) -> Pathname?
+        def calculate: (Pathname) -> Pathname?
+
+        # @rbs path: Pathname
+        # @rbs prefix: Pathname
+        # @rbs returns bool
+        def has_prefix?: (Pathname path, prefix: Pathname) -> bool
+      end
+
       attr_reader stdout: IO
 
       attr_reader stderr: IO

data/sig/generated/rbs/inline/parser.rbs

@@ -30,12 +30,13 @@ module RBS
 
       def initialize: () -> void
 
-      # @rbs result: ParseResult[ProgramNode]
+      # @rbs result: ParseResult
+      # @rbs opt_in: bool -- `true` for *opt-out* mode, `false` for *opt-in* mode.
       # @rbs returns [Array[AST::Annotations::Use], Array[AST::Declarations::t]]?
-      def self.parse: (ParseResult[ProgramNode] result) -> [ Array[AST::Annotations::Use], Array[AST::Declarations::t] ]?
+      def self.parse: (ParseResult result, opt_in: bool) -> [ Array[AST::Annotations::Use], Array[AST::Declarations::t] ]?
 
-      # @rbs rturns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil
-      def current_class_module_decl: () -> untyped
+      # @rbs returns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil
+      def current_class_module_decl: () -> (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl | nil)
 
       # @rbs returns AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl
       def current_class_module_decl!: () -> (AST::Declarations::ModuleDecl | AST::Declarations::ClassDecl)

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: rbs-inline
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-02 00:00:00.000000000 Z
+date: 2024-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.29'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: '0.30'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.29'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 0.24.0
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement