rbs-inline 0.1.0

data/lib/rbs/inline/writer.rb

@@ -0,0 +1,210 @@
+module RBS
+  module Inline
+    class Writer
+      attr_reader :output
+      attr_reader :writer
+
+      def initialize(buffer = +"")
+        @output = buffer
+        @writer = RBS::Writer.new(out: StringIO.new(buffer))
+      end
+
+      def self.write(uses, decls)
+        writer = Writer.new()
+        writer.write(uses, decls)
+        writer.output
+      end
+
+      def header(*lines)
+        lines.each do |line|
+          writer.out.puts("# " + line)
+        end
+        writer.out.puts
+      end
+
+      def write(uses, decls)
+        use_dirs = uses.map do |use|
+          RBS::AST::Directives::Use.new(
+            clauses: use.clauses,
+            location: nil
+          )
+        end
+
+        rbs = decls.filter_map do |decl|
+          translate_decl(decl)
+        end
+
+        writer.write(use_dirs + rbs)
+      end
+
+      def translate_decl(decl)
+        case decl
+        when AST::Declarations::ClassDecl
+          translate_class_decl(decl)
+        when AST::Declarations::ModuleDecl
+          translate_module_decl(decl)
+        when AST::Declarations::ConstantDecl
+          translate_constant_decl(decl)
+        end
+      end
+
+      def translate_class_decl(decl)
+        return unless decl.class_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        decl.members.each do |member|
+          if member.is_a?(AST::Members::Base)
+            if rbs_member = translate_member(member)
+              members.concat rbs_member
+            end
+          end
+
+          if member.is_a?(AST::Declarations::Base)
+            if rbs = translate_decl(member)
+              members << rbs
+            end
+          end
+        end
+
+        RBS::AST::Declarations::Class.new(
+          name: decl.class_name,
+          type_params: decl.type_params,
+          members: members,
+          super_class: decl.super_class,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
+
+      def translate_module_decl(decl)
+        return unless decl.module_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+        end
+
+        members = [] #: Array[RBS::AST::Members::t | RBS::AST::Declarations::t]
+
+        decl.members.each do |member|
+          if member.is_a?(AST::Members::Base)
+            if rbs_member = translate_member(member)
+              members.concat rbs_member
+            end
+          end
+
+          if member.is_a?(AST::Declarations::Base)
+            if rbs = translate_decl(member)
+              members << rbs
+            end
+          end
+        end
+
+        self_types = decl.module_selfs.map { _1.constraint }.compact
+
+        RBS::AST::Declarations::Module.new(
+          name: decl.module_name,
+          type_params: decl.type_params,
+          members: members,
+          self_types: self_types,
+          annotations: [],
+          location: nil,
+          comment: comment
+        )
+      end
+
+      def translate_constant_decl(decl)
+        return unless decl.constant_name
+
+        if decl.comments
+          comment = RBS::AST::Comment.new(string: decl.comments.content, location: nil)
+        end
+
+        RBS::AST::Declarations::Constant.new(
+          name: decl.constant_name,
+          type: decl.type,
+          comment: comment,
+          location: nil
+        )
+      end
+
+      def translate_member(member)
+        case member
+        when AST::Members::RubyDef
+          if member.comments
+            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+          end
+
+          if member.override_annotation
+            return [
+              RBS::AST::Members::MethodDefinition.new(
+                name: member.method_name,
+                kind: member.method_kind,
+                overloads: [],
+                annotations: [],
+                location: nil,
+                comment: comment,
+                overloading: true,
+                visibility: member.visibility
+              )
+            ]
+          end
+
+          [
+            RBS::AST::Members::MethodDefinition.new(
+              name: member.method_name,
+              kind: member.method_kind,
+              overloads: member.method_overloads,
+              annotations: member.method_annotations,
+              location: nil,
+              comment: comment,
+              overloading: false,
+              visibility: member.visibility
+            )
+          ]
+        when AST::Members::RubyAlias
+          if member.comments
+            comment = RBS::AST::Comment.new(string: member.comments.content, location: nil)
+          end
+
+          [
+            RBS::AST::Members::Alias.new(
+              new_name: member.new_name,
+              old_name: member.old_name,
+              kind: :instance,
+              annotations: [],
+              location: nil,
+              comment: comment
+            )
+          ]
+        when AST::Members::RubyMixin
+          [member.rbs].compact
+        when AST::Members::RubyAttr
+          member.rbs
+        when AST::Members::RubyPrivate
+          [
+            RBS::AST::Members::Private.new(location: nil)
+          ]
+        when AST::Members::RubyPublic
+          [
+            RBS::AST::Members::Public.new(location: nil)
+          ]
+        when AST::Members::RBSIvar
+          [
+            member.rbs
+          ].compact
+        when AST::Members::RBSEmbedded
+          case members = member.members
+          when Array
+            members
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbs/inline.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "inline/version"
+
+require "prism"
+require "strscan"
+require "rbs"
+
+require "rbs/inline/node_utils"
+require "rbs/inline/annotation_parser"
+require "rbs/inline/ast/annotations"
+require "rbs/inline/ast/comment_lines"
+require "rbs/inline/ast/tree"
+require "rbs/inline/ast/declarations"
+require "rbs/inline/ast/members"
+require "rbs/inline/parser"
+require "rbs/inline/writer"
+
+module RBS
+  module Inline
+  end
+end

data/rbs_collection.lock.yaml

@@ -0,0 +1,68 @@
+---
+path: ".gem_rbs_collection"
+gems:
+- name: abbrev
+  version: '0'
+  source:
+    type: stdlib
+- name: fileutils
+  version: '0'
+  source:
+    type: stdlib
+- name: json
+  version: '0'
+  source:
+    type: stdlib
+- name: logger
+  version: '0'
+  source:
+    type: stdlib
+- name: minitest
+  version: '0'
+  source:
+    type: stdlib
+- name: monitor
+  version: '0'
+  source:
+    type: stdlib
+- name: mutex_m
+  version: '0'
+  source:
+    type: stdlib
+- name: optparse
+  version: '0'
+  source:
+    type: stdlib
+- name: pathname
+  version: '0'
+  source:
+    type: stdlib
+- name: prism
+  version: 0.24.0
+  source:
+    type: rubygems
+- name: rake
+  version: '13.0'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: d2e93d426c927fdab90ef12e30a9875aa05d60d6
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: rbs
+  version: 3.5.0.pre.2
+  source:
+    type: rubygems
+- name: rdoc
+  version: '0'
+  source:
+    type: stdlib
+- name: strscan
+  version: '0'
+  source:
+    type: stdlib
+- name: tsort
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,17 @@
+# 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:
+  - name: optparse

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

@@ -0,0 +1,222 @@
+# Generated from lib/rbs/inline/annotation_parser.rb with RBS::Inline
+
+module RBS
+  module Inline
+    class AnnotationParser
+      class ParsingResult
+        attr_reader comments: Array[Prism::Comment]
+
+        attr_reader annotations: Array[AST::Annotations::t]
+
+        attr_reader first_comment_offset: Integer
+
+        # @rbs first_comment: Prism::Comment
+        def initialize: (Prism::Comment first_comment) -> untyped
+
+        # @rbs returns Range[Integer]
+        def line_range: () -> Range[Integer]
+
+        # @rbs returns Prism::Comment
+        def last_comment: () -> Prism::Comment
+
+        # @rbs comment: Prism::Comment
+        # @rbs returns self?
+        def add_comment: (Prism::Comment comment) -> self?
+
+        # @rbs returns Array[[String, Prism::Comment]]
+        def lines: () -> Array[[ String, Prism::Comment ]]
+
+        # @rbs returns String
+        def content: () -> String
+      end
+
+      attr_reader input: Array[Prism::Comment]
+
+      # @rbs input: Array[Prism::Comment]
+      def initialize: (Array[Prism::Comment] input) -> untyped
+
+      # @rbs input: Array[Prism::Comment]
+      # @rbs returns Array[ParsingResult]
+      def self.parse: (Array[Prism::Comment] input) -> Array[ParsingResult]
+
+      # @rbs returns Array[ParsingResult]
+      def parse: () -> Array[ParsingResult]
+
+      private
+
+      # @rbs result: ParsingResult
+      # @rbs block: ^(Array[Prism::Comment]) -> void
+      # @rbs returns void
+      def each_annotation_paragraph: (ParsingResult result) { (Array[Prism::Comment]) -> void } -> void
+
+      class Tokenizer
+        attr_reader scanner: StringScanner
+
+        attr_reader current_token: token?
+
+        KEYWORDS: Hash[String, Symbol]
+
+        KW_RE: ::Regexp
+
+        PUNCTS: Hash[String, Symbol]
+
+        PUNCTS_RE: Regexp
+
+        # @rbs scanner: StringScanner
+        # @rbs returns void
+        def initialize: (StringScanner scanner) -> void
+
+        # @rbs tree: AST::Tree
+        # @rbs returns token?
+        def advance: (AST::Tree tree) -> token?
+
+        # Consume given token type and inserts the token to the tree or `nil`
+        #
+        # @rbs type: Array[Symbol]
+        # @rbs tree: AST::Tree
+        # @rbs returns void
+        def consume_token: (*untyped types, tree: AST::Tree) -> void
+
+        # Consume given token type and inserts the token to the tree or raise
+        #
+        # @rbs type: Array[Symbol]
+        # @rbs tree: AST::Tree
+        # @rbs returns void
+        def consume_token!: (*untyped types, tree: AST::Tree) -> void
+
+        # Test if current token has specified `type`
+        #
+        # @rbs type: Array[Symbol]
+        # @rbs returns bool
+        def type?: (*Symbol type) -> bool
+
+        # Ensure current token is one of the specified in types
+        #
+        # @rbs types: Array[Symbol]
+        # @rbs returns void
+        def type!: (*Symbol types) -> void
+
+        # Reset the current_token to incoming comment `--`
+        #
+        # Reset to the end of the input if `--` token cannot be found.
+        #
+        # @rbs returns String -- String that is skipped
+        def skip_to_comment: () -> String
+      end
+
+      # @rbs comments: AST::CommentLines
+      # @rbs returns AST::Annotations::t?
+      def parse_annotation: (AST::CommentLines comments) -> AST::Annotations::t?
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_var_decl: (Tokenizer tokenizer) -> AST::Tree
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_return_type_decl: (Tokenizer tokenizer) -> AST::Tree
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_comment: (Tokenizer tokenizer) -> AST::Tree
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_type_app: (Tokenizer tokenizer) -> AST::Tree
+
+      # Parse a RBS method type or type and returns it
+      #
+      # It tries parsing a method type, and then parsing a type if failed.
+      #
+      # If both parsing failed, it returns a Tree(`:type_syntax_error), consuming all of the remaining input.
+      #
+      # Note that this doesn't recognize `--` comment unlike `parse_type`.
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs parent_tree: AST::Tree
+      # @rbs returns MethodType | AST::Tree | Types::t | nil
+      def parse_type_method_type: (Tokenizer tokenizer, AST::Tree parent_tree) -> (MethodType | AST::Tree | Types::t | nil)
+
+      # Parse a RBS type and returns it
+      #
+      # If parsing failed, it returns a Tree(`:type_syntax_error), consuming
+      #
+      # 1. All of the input with `--` token if exists (for comments)
+      # 2. All of the input (for anything else)
+      #
+      # ```
+      # 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[ Foo`, tokenizer is at the end of the input
+      # ```
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs parent_tree: AST::Tree
+      # @rbs returns Types::t | AST::Tree | nil
+      def parse_type: (Tokenizer tokenizer, AST::Tree parent_tree) -> (Types::t | AST::Tree | nil)
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_rbs_annotation: (Tokenizer tokenizer) -> AST::Tree
+
+      # @rbs tokznier: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_inherits: (untyped tokenizer) -> AST::Tree
+
+      # Parse `@rbs override` annotation
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_override: (Tokenizer tokenizer) -> AST::Tree
+
+      # Parse `@rbs use [CLAUSES]` annotation
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_use: (Tokenizer tokenizer) -> AST::Tree
+
+      # Parses use clause
+      #
+      # Returns one of the following form:
+      #
+      # * [`::`?, [UIDENT, `::`]*, LIDENT, [`as` LIDENT]?]
+      # * [`::`?, [UIDENT, `::`]*, UIDENT, [`as` UIDENT]?]
+      # * [`::`?, [UIDENT, `::`]*, IFIDENT, [`as`, IFIDENT]?]
+      # * [`::`?, [UIDENT) `::`]*, `*`]
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_use_clause: (Tokenizer tokenizer) -> AST::Tree
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_module_self: (Tokenizer tokenizer) -> AST::Tree
+
+      # Yield the block and return the resulting tree if tokenizer has current token of `types`
+      #
+      # ```rb
+      # # Test if tokenize has `--` token, then parse comment or insert `nil` to tree
+      #
+      # tree << parse_optional(tokenizer, :kMINUS2) do
+      #   parse_comment(tokenizer)
+      # end
+      # ```
+      #
+      # @rbs tokenizer: Tokenizer
+      # @rbs types: Array[Symbol]
+      # @rbs block: ^() -> AST::Tree
+      # @rbs returns AST::Tree?
+      def parse_optional: (Tokenizer tokenizer, *Symbol types) { () -> AST::Tree } -> AST::Tree?
+
+      # @rbs tokenizer: Tokenizer
+      # @rbs returns AST::Tree
+      def parse_generic: (Tokenizer tokenizer) -> AST::Tree
+
+      # :: (Tokenizer) -> AST::Tree
+      def parse_ivar_type: (Tokenizer) -> AST::Tree
+
+      # :: (Tokenizer) -> AST::Tree
+      def parse_yields: (Tokenizer) -> AST::Tree
+    end
+  end
+end