yard_to_rbs_inline 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecc73716bfcc2a940e6d360e85a334ce640d97cfcf47c8d9f9ef64f182e8a8a3
-  data.tar.gz: 992af7e460bd7456a16e718d79d7a993b6396a1b09a81a0aa64d20992e9959cf
+  metadata.gz: 86fdbb3d79a0b8fc087b0c561fde8b42a177d16354dc58dc44aa45df1c907c20
+  data.tar.gz: ecc100f64d44a665156193acba142037010703c9b11b943fa3868cad5f42a6ba
 SHA512:
-  metadata.gz: 02a11e36ce83ada391d9fcc937d2eb54e3c1cb292d2107a9c350f801b23892e65da5f1c027a9207cd480b36ad4e2770967b02f736d722b573e62cb4f7422acb9
-  data.tar.gz: 73a525cd918cf110c1e23a9b7b11cc8d1b58cb33849e6d80473727fd9d42600332a843a01cd1c06415a14876170d79d912c5fb9f266afdf62dd9d82bd10e183b
+  metadata.gz: 54d0d43ce951c23222a3eafc0164f24b15336dcc2e9bb7e707747c1f4d116a6a0cef87902a85ee2a31707a3bea7d4431717d3ff7b9e280115add7a7409e74362
+  data.tar.gz: 0ed86dd791e4806b68114796b1ccd26d66ca127923e0d99c6a3a323243c418aadaa99bd1ad6ff645c405fa8d4f522435158daa0b73d210be5ea4f298c7281208

data/.rubocop.yml

@@ -1,5 +1,29 @@
+require:
+  - rubocop-rbs_inline
+
 AllCops:
-  TargetRubyVersion: 2.6
+  TargetRubyVersion: 3.2
+  Exclude:
+    - lib/yard_to_rbs_inline/yard_type/parser.rb # Generated file by racc
+
+Lint/MissingSuper:
+  Enabled: false
+
+Lint/NonLocalExitFromIterator:
+  Enabled: false
+
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+
+Naming/FileName:
+  Exclude:
+    - examples/**
+
+Style/Documentation:
+  Enabled: false
+
+Style/StringConcatenation:
+  Mode: conservative
 
 Style/StringLiterals:
   Enabled: true
@@ -9,5 +33,12 @@ Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
 
+Layout/LeadingCommentSpace:
+  AllowRBSInlineAnnotation: true
+  AllowSteepAnnotation: true
+
 Layout/LineLength:
   Max: 120
+
+Metrics:
+  Enabled: false

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 ## [Unreleased]
 
+- Write `#:` instead of `#::`.
+- Configure Steep on this gem
+
 ## [0.1.0] - 2024-05-10
 
 - Initial release

data/README.md

@@ -1,15 +1,25 @@
 # yard → rbs-inline
 
-Rewrite YARD type annotations in Your codes to rbs-inline.
+Insert [rbs-inline](https://github.com/soutaro/rbs-inline) comments from [YARD type annotations](https://yardoc.org/types.html) in your codes.
 
 ## Usage
 
+Install this gem with the following command.
+
 ```console
-bundle
+gem install yard_to_rbs_inline
+```
+
+Then, run the following command to insert rbs-inline comments to your codes.
 
+```console
 # Print rewrited code to stdout.
-./exe/yard-rbs-inline --dry-run your-file.rb
+yard_to_rbs_inline --dry-run your-file.rb
 
 # Overwrite files.
-./exe/yard-rbs-inline your-file.rb
+yard_to_rbs_inline your-file.rb
 ```
+
+## Examples
+
+See: [examples](./examples)

data/Rakefile

@@ -10,13 +10,51 @@ require "bump/tasks"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+task default: %i[spec rubocop steep]
 
 desc "Build parser files generated by racc"
 task racc: [
   "lib/yard_to_rbs_inline/yard_type/parser.rb"
 ]
 
+desc "Build rbs files"
+task rbs: ["rbs:collection", "rbs:inline"]
+
+namespace :rbs do
+  desc "Install collections"
+  task :collection do
+    sh "bundle exec rbs collection install"
+  end
+
+  desc "Generate RBS files"
+  task inline: "rbs:inline:build"
+
+  namespace :inline do
+    desc "Generate RBS files from rbs-inline"
+    task :build do
+      sh "bundle exec rbs-inline lib --opt-out --output=sig/inline"
+    end
+
+    desc "Watch files to build rbs-inline"
+    task :watch do
+      require "listen"
+
+      listener = Listen.to("lib", only: /\.rb$/) do
+        Rake::Task["rbs:inline:build"].execute
+      end
+      listener.start
+      sleep
+    ensure
+      listener&.stop
+    end
+  end
+end
+
+desc "Type check the code"
+task steep: ["rbs:collection", "rbs:inline"] do
+  sh "bundle exec steep check"
+end
+
 rule ".rb" => ".y" do |t|
   sh "bundle exec racc #{t.source} -o #{t.name}"
 end

data/Steepfile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+  signature "types"
+  ignore_signature "sig/test"
+
+  check "lib" # Directory name
+  # check "path/to/source.rb"         # File name
+  # check "app/models/**/*.rb"        # Glob
+  ignore "lib/yard_to_rbs_inline/yard_type/parser.rb" # Ignore generated files
+  # ignore "lib/templates/*.rb"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.default)      # `default` diagnostics setting (applies by default)
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   unreferenced!                     # Skip type checking the `lib` code when types in `test` target is changed
+#   signature "sig/test"              # Put RBS files for tests under `sig/test`
+#   check "test"                      # Type check Ruby scripts under `test`
+#
+#   configure_code_diagnostics(D::Ruby.lenient)      # Weak type checking for test code
+#
+#   # library "pathname"              # Standard libraries
+# end

data/examples/example-converted.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+class Code
+  # @return [String]
+  attr_reader :source #: String
+
+  # @param source [String]
+  #: (String source) -> untyped
+  def initialize(source)
+    @source = source
+  end
+
+  # @param new_source [String]
+  # @return [Code]
+  #: (String new_source) -> Code
+  def rewrite(new_source)
+    @source = new_source
+
+    self
+  end
+
+  # @param recover [Boolean].
+  # @return [Array<Token>]
+  #: (?recover: bool) -> Array[Token]
+  def tokenize(recover: false)
+    parser.tokenize(source, recover: recover)
+  end
+end

data/examples/example.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Code
   # @return [String]
   attr_reader :source

data/exe/yard_to_rbs_inline

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__)) if Dir.exist?(File.join(__dir__, "..", ".git"))
+
+require "yard_to_rbs_inline"
+exit(YardToRbsInline::Cli.start(ARGV))

data/lib/yard_to_rbs_inline/cli.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
 require "optparse"

data/lib/yard_to_rbs_inline/converter/code_visitor.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
-require_relative 'subscriptable'
+require_relative "subscriptable"
 
 module YardToRbsInline
   module Converter
@@ -10,20 +12,23 @@ module YardToRbsInline
       # @!rbs
       #   type mod = PrependLine | AppendLineContent
 
-      attr_reader :source #:: Prism::Source
+      # @rbs @source: Prism::Source
+      attr_reader :source #: Prism::Source
 
-      attr_reader :comments #:: Array[Prism::InlineComment]
+      # @rbs @comments: Array[Prism::comment]
+      attr_reader :comments #: Array[Prism::comment]
 
-      attr_reader :text_with_mod #:: TextWithMod
+      # @rbs @text_with_mod: TextWithMod
+      attr_reader :text_with_mod #: TextWithMod
 
-      #:: (source: Prism::Source, comments: Array[Prism::InlineComment]) -> untyped
+      #: (source: Prism::Source, comments: Array[Prism::comment]) -> untyped
       def initialize(source:, comments:)
         @source = source
         @comments = comments
         @text_with_mod = TextWithMod.new(source.source)
       end
 
-      #:: (Prism::CallNode) -> void
+      #: (Prism::CallNode) -> void
       def visit_call_node(node)
         parse_annotation = lambda do
           annotation_comments = annotations_for(node)
@@ -35,29 +40,29 @@ module YardToRbsInline
         when :attr_reader
           annotation = parse_annotation.call
 
-          unless annotation.match?(/^\s*#(::|\s*@rbs)/)
-            docstring = YARD::DocstringParser.new.parse(annotation.gsub(/^\s*#\s*/, '')).to_docstring
+          unless annotation.match?(/^\s*#(:|\s*@rbs)/)
+            docstring = YARD::DocstringParser.new.parse(annotation.gsub(/^\s*#\s*/, "")).to_docstring
 
             sig = capture_error_to_write_comment(node) { build_return_sig(docstring) }
-            text_with_mod.mods << AppendLineContent.from_node_and_content(node, "#:: #{sig}")
+            text_with_mod.mods << AppendLineContent.from_node_and_content(node, "#: #{sig}")
           end
         end
 
         super
       end
 
-      #:: (Prism::DefNode) -> void
+      #: (Prism::DefNode) -> void
       def visit_def_node(node)
         annotation_comments = annotations_for(node)
         annotation_strs = annotation_comments.map(&method(:source_for_comment))
         annotation = annotation_strs.map(&:chomp).join("\n")
 
-        unless annotation.match?(/^\s*#(::|\s*@rbs)/)
-          docstring = YARD::DocstringParser.new.parse(annotation.gsub(/^\s*#\s*/, '')).to_docstring
+        unless annotation.match?(/^\s*#(:|\s*@rbs)/)
+          docstring = YARD::DocstringParser.new.parse(annotation.gsub(/^\s*#\s*/, "")).to_docstring
 
           sig = capture_error_to_write_comment(node) { build_signature(node.parameters, docstring) }
 
-          text_with_mod.mods << PrependLine.from_node_and_content(node, "#:: #{sig}")
+          text_with_mod.mods << PrependLine.from_node_and_content(node, "#: #{sig}")
 
           # STDERR.puts "#{node.name_loc.inspect} #{node.name}: #{sig}"
         end
@@ -67,18 +72,18 @@ module YardToRbsInline
 
       private
 
-      #:: (YARD::Docstring) -> String
+      #: (YARD::Docstring) -> String
       def build_return_sig(docstring)
-        return_tag = docstring.tag("return") #:: YARD::Tags::Tag | nil
+        return_tag = docstring.tag("return") #: YARD::Tags::Tag | nil
 
-        if return_tag&.types
-          convert_types(return_tag.types)
+        if (types = return_tag&.types)
+          convert_types(types)
         else
           "untyped"
         end
       end
 
-      #:: (Prism::ParametersNode | nil, YARD::Docstring) -> String
+      #: (Prism::ParametersNode | nil, YARD::Docstring) -> String
       def build_signature(params, docstring)
         params_sig = build_params_signature(params, docstring)
         return_sig = build_return_sig(docstring)
@@ -86,59 +91,61 @@ module YardToRbsInline
         "(#{params_sig}) -> #{return_sig}"
       end
 
-      #:: (Prism::ParametersNode | nil, YARD::Docstring) -> String
+      #: (Prism::ParametersNode | nil, YARD::Docstring) -> String
       def build_params_signature(params, docstring)
         return "" unless params
 
-        param_tags = docstring.tags("param") #:: Array[YARD::Tags::Tag]
+        param_tags = docstring.tags("param") #: Array[YARD::Tags::Tag]
 
         find_tag = proc do |name|
-          if name
-            param_tags.find { |tag| tag.name == name.to_s }
-          else
-            nil
-          end
+          param_tags.find { |tag| tag.name == name.to_s } if name
         end
 
-        param_sigs = []
+        param_sigs = [] #: Array[String]
         params.requireds.each do |param|
+          param = TypeUtils.narrow_with_name(param)
+          next unless param
+
           tag = find_tag.call(param.name)
 
-          if tag&.types
-            param_sigs << "#{convert_types(tag.types)} #{param.name}"
-          else
-            param_sigs << "untyped #{param.name}"
-          end
+          param_sigs << if tag&.types
+                          "#{convert_types(tag.types)} #{param.name}"
+                        else
+                          "untyped #{param.name}"
+                        end
         end
 
         params.optionals.each do |param|
           tag = find_tag.call(param.name)
 
-          if tag&.types
-            param_sigs << "?#{convert_types(tag.types)} #{param.name}"
-          else
-            param_sigs << "?untyped #{param.name}"
-          end
+          param_sigs << if tag&.types
+                          "?#{convert_types(tag.types)} #{param.name}"
+                        else
+                          "?untyped #{param.name}"
+                        end
         end
 
-        if (param = params.rest)
+        if (param = TypeUtils.narrow_with_name(params.rest))
           tag = find_tag.call(param.name)
 
-          if tag&.types
-            param_sigs << "*#{convert_types(tag.types)} #{param.name}"
-          else
-            param_sigs << "*untyped #{param.name}"
-          end
+          param_sigs << if tag&.types
+                          "*#{convert_types(tag.types)} #{param.name}"
+                        else
+                          "*untyped #{param.name}"
+                        end
         end
 
         params.posts.each do |param|
+          param = TypeUtils.narrow_with_name(param)
+          next unless param
+
           tag = find_tag.call(param.name)
 
-          if tag&.types
-            param_sigs << "#{convert_types(tag.types)} #{param.name}"
-          else
-            param_sigs << "untyped #{param.name}"
-          end
+          param_sigs << if tag&.types
+                          "#{convert_types(tag.types)} #{param.name}"
+                        else
+                          "untyped #{param.name}"
+                        end
         end
 
         params.keywords.each do |param|
@@ -152,43 +159,44 @@ module YardToRbsInline
               "?"
             end
 
-          if tag && tag.types
-            param_sigs << "#{prefix}#{param.name}: #{convert_types(tag.types)}"
-          else
-            param_sigs << "#{prefix}#{param.name}: untyped"
-          end
+          param_sigs << if tag&.types
+                          "#{prefix}#{param.name}: #{convert_types(tag.types)}"
+                        else
+                          "#{prefix}#{param.name}: untyped"
+                        end
         end
 
-        if (param = params.keyword_rest)
+        if (param = TypeUtils.narrow_with_name(params.keyword_rest))
+
           tag = find_tag.call(param.name)
 
-          if tag&.types
-            param_sigs << "**#{convert_types(tag.types)} #{param.name}"
-          else
-            param_sigs << "**untyped #{param.name}"
-          end
+          param_sigs << if tag&.types
+                          "**#{convert_types(tag.types)} #{param.name}"
+                        else
+                          "**untyped #{param.name}"
+                        end
         end
 
         # Remove trailing spaces for unnamed params
         param_sigs.map(&:strip).join(", ")
       end
 
-      #:: (Array[String], node: Prism::Node) -> String
+      #: (Array[String]) -> String
       def convert_types(yard_type_literals)
         new_types = yard_type_literals.map do |literal|
           yard_type = YardToRbsInline::YardType::Parser.new.parse(literal)
           convert_yard_type(yard_type)
-        rescue Racc::ParseError, Yoda::Parsing::YardType::Scanner::ScanError => e
+        rescue Racc::ParseError, YardType::Scanner::ScanError => e
           # STDERR.puts "Cannot parse #{literal}: #{e}"
           emit_error_message("Cannot parse #{literal}: #{e}")
 
-          'untyped'
+          "untyped"
         end.uniq
 
-        new_types.empty? ? 'untyped' : new_types.join(' | ')
+        new_types.empty? ? "untyped" : new_types.join(" | ")
       end
 
-      #:: (YardToRbsInline::YardType::Ast::node, node: Prism::Node) -> String
+      #: (YardToRbsInline::YardType::Ast::node) -> String
       def convert_yard_type(yard_type)
         case yard_type
         in YardType::Ast::Type(name:)
@@ -212,19 +220,19 @@ module YardToRbsInline
           content
         in YardType::Ast::GenericType(container_type:, types:)
           container_sig = container_type ? convert_yard_type(container_type) : "Array"
-          "#{container_sig}[#{types.map(&method(:convert_yard_type)).join(' | ')}]"
+          "#{container_sig}[#{types.map(&method(:convert_yard_type)).join(" | ")}]"
         in YardType::Ast::TupleType(container_type:, types:)
           container_sig = container_type ? convert_yard_type(container_type) : "Array"
-          "#{container_sig} & [#{types.map(&method(:convert_yard_type)).join(', ')}]"
+          "#{container_sig} & [#{types.map(&method(:convert_yard_type)).join(", ")}]"
         in YardType::Ast::HashType(container_type:, type_pair: [key_type, value_type])
           container_sig = container_type ? convert_yard_type(container_type) : "Hash"
           "#{container_sig}[#{convert_yard_type(key_type)}, #{convert_yard_type(value_type)}]"
         in YardType::Ast::UnionType(types:)
-          types.map(&method(:convert_yard_type)).join(' | ')
+          types.map(&method(:convert_yard_type)).join(" | ")
         end
       end
 
-      #:: (Prism::Node) -> Integer
+      #: (Prism::Node) -> Integer
       def start_line_of_node(node)
         gather_comment_targets = proc do |l|
           if l.respond_to?(:comment_targets)
@@ -237,34 +245,53 @@ module YardToRbsInline
         gather_comment_targets.call(node).map(&:start_line).min || 0
       end
 
-      #:: (Prism::Node) -> Array[Prism::InlineComment]
+      #: (Prism::Node) -> Array[Prism::comment]
       def annotations_for(node)
         start_line = start_line_of_node(node)
 
-        matched_comments = []
+        matched_comments = [] #: Array[Prism::comment]
         matched_comments += comments_by_line[start_line] if comments_by_line[start_line]
 
         (start_line - 1).downto(1) do |line|
           current_comments = comments_by_line[line]
-          if current_comments
-            matched_comments += current_comments
-          else
-            break
-          end
+          break unless current_comments
+
+          matched_comments += current_comments
         end
 
         matched_comments
       end
 
-      #:: (Prism::InlineComment) -> String
+      #: (Prism::comment) -> String
       def source_for_comment(comment)
         source.slice(comment.location.start_offset, comment.location.length)
       end
 
-      #:: () -> Hash[Integer, Array[Prism::InlineComment]]
+      # @rbs @comments_by_line: Hash[Integer, Array[Prism::comment]]?
+
+      #: () -> Hash[Integer, Array[Prism::comment]]
       def comments_by_line
         @comments_by_line ||= comments.group_by { |comment| comment.location.start_line }
       end
+
+      module TypeUtils
+        module_function
+
+        # @rbs!
+        #   interface _WithName
+        #     def name: () -> String
+        #   end
+
+        # @rbs!
+        #   interface _RespondTo
+        #     def respond_to?: (String | Symbol) -> boolish
+        #   end
+
+        #: [T < _RespondTo] (T) -> (T & _WithName)?
+        def narrow_with_name(node)
+          node.respond_to?(:name) && node #: untyped
+        end
+      end
     end
   end
 end

data/lib/yard_to_rbs_inline/converter/subscriptable.rb

@@ -1,33 +1,45 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
 module YardToRbsInline
   module Converter
+    # @rbs!
+    #   interface _TextWithModContainer
+    #     def text_with_mod: () -> TextWithMod
+    #   end
+
+    # @rbs module-self _TextWithModContainer
     module Subscriptable
       # @rbs!
       #   type subscriber = ^(String) -> void
 
-      #:: (String) -> void
+      #: (String) -> void
       def emit_error_message(error_message)
         (@subscribers || []).each { |subscriber| subscriber.call(error_message) }
       end
 
-      #:: [X] (subscriber) { () -> X } -> X
+      # @rbs @subscribers: Array[subscriber]
+
+      #: [X] (subscriber) { () -> X } -> X
       def capture_error_message(subscriber)
-        @subscribers ||= []
+        @subscribers ||= [] #: Array[subscriber]
         @subscribers.push(subscriber)
         yield
       ensure
         @subscribers.pop
       end
 
-      #:: (Prism::Node) -> subscriber
+      #: (Prism::Node) -> subscriber
       def subscriber_to_prepend_error(node)
-        lambda { |message| text_with_mod.mods << PrependLine.from_node_and_content(node, "# YARD to RBS Error: #{message}") }
+        lambda { |message|
+          text_with_mod.mods << PrependLine.from_node_and_content(node, "# YARD to RBS Error: #{message}")
+        }
       end
 
-      #:: [X] (Prism::Node) { () -> X } -> X
-      def capture_error_to_write_comment(node)
-        capture_error_message(subscriber_to_prepend_error(node)) { yield }
+      #: [X] (Prism::Node) { () -> X } -> X
+      def capture_error_to_write_comment(node, &block)
+        capture_error_message(subscriber_to_prepend_error(node), &block)
       end
     end
   end

data/lib/yard_to_rbs_inline/converter/text_with_mod.rb

@@ -1,43 +1,57 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
 module YardToRbsInline
   module Converter
-    PrependLine = Data.define(:line_num, :content) do
-      #:: (Prism::Node, String) -> PrependLine
+    class PrependLine < Data.define(:line_num, :content)
+      # @rbs!
+      #   def initialize: (line_num: Integer, content: String) -> void
+      #   attr_reader line_num: Integer
+      #   attr_reader content: String
+
+      #: (Prism::Node, String) -> PrependLine
       def self.from_node_and_content(node, comment_content)
         start_line = node.location.start_line
         start_column = node.location.start_column
 
-        line = ' ' * start_column + comment_content
+        line = " " * start_column + comment_content
 
         PrependLine.new(line_num: start_line, content: line)
       end
     end
 
-    AppendLineContent = Data.define(:line_num, :content) do
-      #:: (Prism::Node, String) -> PrependLine
+    class AppendLineContent < Data.define(:line_num, :content)
+      # @rbs!
+      #   def initialize: (line_num: Integer, content: String) -> void
+      #   attr_reader line_num: Integer
+      #   attr_reader content: String
+
+      #: (Prism::Node, String) -> AppendLineContent
       def self.from_node_and_content(node, comment_content)
         start_line = node.location.start_line
 
-        AppendLineContent.new(line_num: start_line, content: ' ' + comment_content)
+        AppendLineContent.new(line_num: start_line, content: " #{comment_content}")
       end
     end
 
+    # @rbs!
+    #   type mod = PrependLine | AppendLineContent
+
     class TextWithMod
-      attr_reader :original_text #:: Prism::Source
+      attr_reader :original_text #: Prism::Source
 
-      attr_reader :mods #:: Array[mod]
+      attr_reader :mods #: Array[mod]
 
-      #:: (String) -> untyped
+      #: (String) -> untyped
       def initialize(original_text)
         @original_text = original_text
         @mods = []
       end
 
-      #:: () -> String
-      def modified_text
-        prepended_line_nums = []
-        mods.reduce(original_text.lines(chomp: true)) do |source_lines, mod|
+      def modified_text #: String
+        prepended_line_nums = [] #: Array[String]
+        mods.each_with_object(original_text.lines.map(&:chomp)) do |mod, source_lines|
           real_line_num = mod.line_num + prepended_line_nums.map { |i| i <= mod.line_num }.length # 1-index
 
           case mod
@@ -47,8 +61,6 @@ module YardToRbsInline
           in AppendLineContent(content:)
             source_lines[real_line_num - 1] += content
           end
-
-          source_lines
         end.join("\n") + "\n"
       end
     end

data/lib/yard_to_rbs_inline/converter.rb

@@ -1,5 +1,7 @@
-require 'prism'
-require 'yard'
+# frozen_string_literal: true
+
+require "prism"
+require "yard"
 
 module YardToRbsInline
   module Converter

data/lib/yard_to_rbs_inline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module YardToRbsInline
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end

data/lib/yard_to_rbs_inline/yard_type/ast.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
 module YardToRbsInline
@@ -6,14 +8,19 @@ module YardToRbsInline
       # @rbs!
       #   type node = Type | LiteralType | DuckType | GenericType | TupleType | HashType | UnionType
 
-      Type = Struct.new(:name, keyword_init: true)
-      LiteralType = Struct.new(:content, keyword_init: true)
-      DuckType = Struct.new(:name, keyword_init: true)
-      GenericType = Struct.new(:container_type, :types, keyword_init: true)
-      TupleType = Struct.new(:container_type, :types, keyword_init: true)
-      HashType = Struct.new(:container_type, :type_pair, keyword_init: true)
-      UnionType = Struct.new(:types, keyword_init: true) do
-        #:: (untyped types) -> untyped
+      Type = Data.define(:name)
+      LiteralType = Data.define(:content)
+      DuckType = Data.define(:name)
+      GenericType = Data.define(:container_type, :types)
+      TupleType = Data.define(:container_type, :types)
+      HashType = Data.define(:container_type, :type_pair)
+
+      class UnionType < Data.define(:types)
+        # @rbs!
+        #   def initialize: (types: Array[node]) -> void
+        #   attr_reader types: Array[node]
+
+        #: (untyped types) -> untyped
         def self.build(types)
           if types.length == 1
             types.first

data/lib/yard_to_rbs_inline/yard_type/parser.rb

@@ -1,7 +1,7 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.7.1
-# from Racc grammar file "".
+# This file is automatically generated by Racc 1.8.1
+# from Racc grammar file "parser.y".
 #
 
 require 'racc/parser.rb'
@@ -14,14 +14,14 @@ module YardToRbsInline
 
 module_eval(<<'...end parser.y/module_eval...', 'parser.y', 34)
 
-#:: (String) -> Ast::node
+#: (String) -> Ast::node
 def parse(string)
   @tokens = Scanner.new(string).to_racc_tokens
 
   do_parse()
 end
 
-#:: () -> untyped
+#: () -> untyped
 def next_token
   @tokens.shift
 end
@@ -294,14 +294,12 @@ end
 end   # module YardToRbsInline
 
 
-module Yoda
-  module Parsing
-    module YardType
-      class Parser
-        # @rbs!
-        #   def parse: (String) -> Ast::node
-        #   def next_token: () -> untyped
-      end
+module YardToRbsInline
+  module YardType
+    class Parser
+      # @rbs!
+      #   def parse: (String) -> Ast::node
+      #   def next_token: () -> untyped
     end
   end
 end

data/lib/yard_to_rbs_inline/yard_type/parser.y

@@ -32,28 +32,26 @@ end
 
 ---- inner
 
-#:: (String) -> Ast::node
+#: (String) -> Ast::node
 def parse(string)
   @tokens = Scanner.new(string).to_racc_tokens
 
   do_parse()
 end
 
-#:: () -> untyped
+#: () -> untyped
 def next_token
   @tokens.shift
 end
 
 ---- footer
 
-module Yoda
-  module Parsing
-    module YardType
-      class Parser
-        # @rbs!
-        #   def parse: (String) -> Ast::node
-        #   def next_token: () -> untyped
-      end
+module YardToRbsInline
+  module YardType
+    class Parser
+      # @rbs!
+      #   def parse: (String) -> Ast::node
+      #   def next_token: () -> untyped
     end
   end
 end

data/lib/yard_to_rbs_inline/yard_type/scanner.rb

@@ -1,69 +1,76 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
-require 'strscan'
+require "strscan"
 
-module YardToRbsInline::YardType
-  class Scanner
-    class ScanError < StandardError; end
+module YardToRbsInline
+  module YardType
+    class Scanner
+      class ScanError < StandardError; end
 
-    Token = Struct.new(:kind, :content, keyword_init: true)
+      Token = Struct.new(:kind, :content, keyword_init: true)
 
-    TOKEN_PATTERNS = {
-      generic_start: /</,
-      generic_end: />/,
-      tuple_start: /\(/,
-      tuple_end: /\)/,
-      duck_symbol: /#/,
-      separator: /[,;]/,
-      arrow: /\=>/,
-      hash_start: /\{/,
-      hash_end: /\}/,
-      name: /(::|\w)+/,
-      symbol: /:\w+/,
-      string: [/\"[^"]*\"/, /\'[^']*\'/],
-      integer: /\d+/,
-      spaces: /\s+/,
-    }
+      TOKEN_PATTERNS = {
+        generic_start: /</,
+        generic_end: />/,
+        tuple_start: /\(/,
+        tuple_end: /\)/,
+        duck_symbol: /#/,
+        separator: /[,;]/,
+        arrow: /=>/,
+        hash_start: /\{/,
+        hash_end: /\}/,
+        name: /(::|\w)+/,
+        symbol: /:\w+/,
+        string: [/"[^"]*"/, /'[^']*'/],
+        integer: /\d+/,
+        spaces: /\s+/
+      }.freeze
 
-    attr_reader :text #:: String
+      attr_reader :text #: String
 
-    #:: (String text) -> untyped
-    def initialize(text)
-      @text = text
-    end
+      #: (String text) -> untyped
+      def initialize(text)
+        @text = text
+      end
 
-    #:: () -> Array[[Symbol | bool, String]]
-    def to_racc_tokens
-      tokens.map { |token| [token.kind.to_s.upcase.to_sym, token.content] } + [[false, "EOS"]]
-    end
+      #: () -> Array[[Symbol | boolish, String]]
+      def to_racc_tokens
+        tokens.map do |token| #$ [Symbol | bool, String]
+          [token.kind.to_s.upcase.to_sym, token.content]
+        end + [
+          [false, "EOS"] #: [bool, String]
+        ]
+      end
+
+      # @rbs @tokens: Array[Token]?
 
-    #:: () -> Array[Token]
-    def tokens
-      @tokens ||= begin
-        scanner = StringScanner.new(text)
-        tokens = []
+      #: () -> Array[Token]
+      def tokens
+        @tokens ||= begin
+          scanner = StringScanner.new(text)
+          tokens = [] #: Array[Token]
+
+          scan_step = lambda do
+            TOKEN_PATTERNS.each do |kind, pattern_or_patterns|
+              Array(pattern_or_patterns).each do |pattern|
+                next unless (matched = scanner.scan(pattern))
 
-        scan_step = lambda do
-          TOKEN_PATTERNS.each do |kind, pattern_or_patterns|
-            Array(pattern_or_patterns).each do |pattern|
-              if (matched = scanner.scan(pattern))
                 tokens << Token.new(kind: kind, content: matched) unless kind == :spaces
-                return
+                # For now, steep parse this as a return of the whole method
+                return # steep:ignore
               end
             end
+
+            raise ScanError, "Unknown keyword #{scanner.rest} (in #{text})"
           end
 
-          raise ScanError, "Unknown keyword #{scanner.rest} (in #{text})"
-        end
+          scan_step.call until scanner.eos?
 
-        until scanner.eos? do
-          scan_step.call
+          tokens
         end
-
-        tokens
       end
     end
   end
-
-
 end

data/lib/yard_to_rbs_inline/yard_type.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 # rbs_inline: enabled
 
 module YardToRbsInline
   module YardType
-    require_relative 'yard_type/ast'
-    require_relative 'yard_type/parser'
-    require_relative 'yard_type/scanner'
+    require_relative "yard_type/ast"
+    require_relative "yard_type/parser"
+    require_relative "yard_type/scanner"
   end
 end

data/rbs_collection.yaml

@@ -0,0 +1,19 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+# gems:
+#   # If you want to avoid installing rbs files for gems, you can specify them here.
+#   - name: GEM_NAME
+#     ignore: true

data/sig/yard_to_rbs_inline_example.rbs

@@ -1,4 +1,3 @@
 module YardToRbsInline
-  VERSION: String
   # See the writing guide of rbs: https://github.com/ruby/rbs#guides
 end

data/types/gems/racc.rbs

@@ -0,0 +1,4 @@
+module Racc
+  class ParseError < StandardError
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: yard_to_rbs_inline
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Tomoya Chiba
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-16 00:00:00.000000000 Z
+date: 2025-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -24,25 +23,12 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: bump
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Converter of yard to rbs-inline
 email:
 - tomo.asleep@gmail.com
 executables:
 - yard-to-rbs-inline
+- yard_to_rbs_inline
 extensions: []
 extra_rdoc_files: []
 files:
@@ -53,8 +39,11 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- Steepfile
+- examples/example-converted.rb
 - examples/example.rb
 - exe/yard-to-rbs-inline
+- exe/yard_to_rbs_inline
 - lib/yard_to_rbs_inline.rb
 - lib/yard_to_rbs_inline/cli.rb
 - lib/yard_to_rbs_inline/converter.rb
@@ -67,14 +56,15 @@ files:
 - lib/yard_to_rbs_inline/yard_type/parser.rb
 - lib/yard_to_rbs_inline/yard_type/parser.y
 - lib/yard_to_rbs_inline/yard_type/scanner.rb
+- rbs_collection.yaml
 - sig/yard_to_rbs_inline_example.rbs
+- types/gems/racc.rbs
 homepage: https://github.com/tomoasleep/yard_to_rbs_inline
 licenses: []
 metadata:
   homepage_uri: https://github.com/tomoasleep/yard_to_rbs_inline
   source_code_uri: https://github.com/tomoasleep/yard_to_rbs_inline
   changelog_uri: https://github.com/tomoasleep/yard_to_rbs_inline/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -82,15 +72,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Converter of yard to rbs-inline
 test_files: []