rbs 4.1.0.pre.2-java

data/lib/rdoc_plugin/parser.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module RBS
+  module RDocPlugin
+    class Parser
+
+      attr_accessor :top_level, :content
+
+      def initialize(top_level, content)
+        @top_level = top_level
+        @content = content
+      end
+
+      def scan
+        _, _, decls = ::RBS::Parser.parse_signature(@content)
+        decls.each do |decl|
+          parse_member(decl: decl, context: @top_level)
+        end
+        @top_level
+      end
+
+      def parse_member(decl:, context:, outer_name: nil)
+        case decl
+        when ::RBS::AST::Declarations::Class
+          parse_class_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Module
+          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Constant
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_constant_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Declarations::Interface
+          parse_module_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::MethodDefinition
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_method_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Alias
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_method_alias_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::AttrReader, ::RBS::AST::Members::AttrWriter, ::RBS::AST::Members::AttrAccessor
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_attr_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Include
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_include_decl(decl: decl, context: context, outer_name: outer_name)
+        when ::RBS::AST::Members::Extend
+          context = @top_level.find_class_or_module outer_name.to_s if outer_name
+          parse_extend_decl(decl: decl, context: context, outer_name: outer_name)
+        end
+      end
+
+      def parse_class_decl(decl:, context:, outer_name: nil)
+        full_name = fully_qualified_name(outer_name: outer_name, decl: decl)
+        klass = context.add_class(RDoc::NormalClass, full_name.to_s, decl.super_class&.name&.to_s || "::Object")
+        klass.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
+        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
+      end
+
+      def parse_module_decl(decl:, context:, outer_name: nil)
+        full_name = fully_qualified_name(outer_name: outer_name, decl: _ = decl)
+        kmodule = context.add_module(RDoc::NormalModule, full_name.to_s)
+        kmodule.add_comment(construct_comment(context: context, comment: comment_string(decl)), context) if decl.comment
+        decl.members.each { |member| parse_member(decl: member, context: context, outer_name: full_name) }
+      end
+
+      def parse_constant_decl(decl:, context:, outer_name: nil)
+        comment = decl.comment ? construct_comment(context: context, comment: comment_string(decl)) : nil
+        constant = RDoc::Constant.new(decl.name.to_s, decl.type.to_s, comment)
+        context.add_constant(constant)
+      end
+
+      def parse_method_decl(decl:, context:, outer_name: nil)
+        method = RDoc::AnyMethod.new(nil, decl.name.to_s)
+        method.singleton = decl.singleton?
+        method.visibility = decl.visibility
+        method.call_seq = decl.overloads.map {|overload| "#{decl.name.to_s}#{overload.method_type.to_s}" }.join("\n")
+        if loc = decl.location
+          method.start_collecting_tokens(:ruby)
+          method.add_token({ line_no: 1, char_no: 1, kind: :on_comment, text: "# File #{@top_level.relative_name}, line(s) #{loc.start_line}:#{loc.end_line}\n" })
+          method.add_token({ line_no: 1, char_no: 1, text: loc.source })
+          method.line = loc.start_line
+        end
+        method.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_method(method)
+      end
+
+      def parse_method_alias_decl(decl:, context:, outer_name: nil)
+        alias_def = RDoc::Alias.new(nil, decl.old_name.to_s, decl.new_name.to_s, nil, singleton: decl.kind == :singleton)
+        alias_def.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_alias(alias_def)
+      end
+
+      def parse_attr_decl(decl:, context:, outer_name: nil)
+        rw = case decl
+             when ::RBS::AST::Members::AttrReader
+               'R'
+             when ::RBS::AST::Members::AttrWriter
+               'W'
+             when ::RBS::AST::Members::AttrAccessor
+               'RW'
+             end
+        attribute = RDoc::Attr.new(nil, decl.name.to_s, rw, nil, singleton: decl.kind == :singleton)
+        attribute.visibility = decl.visibility
+        attribute.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_attribute(attribute)
+      end
+
+      def parse_include_decl(decl:, context:, outer_name: nil)
+        name = decl.name.to_s
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
+        qualified_name = ''
+        outer_names.each do |namespace|
+          qualified_name += namespace
+          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
+            name = module_name.full_name
+            break
+          end
+        end
+        include_decl = RDoc::Include.new(name, nil)
+        include_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_include(include_decl)
+      end
+
+      def parse_extend_decl(decl:, context:, outer_name: nil)
+        name = decl.name.to_s
+        outer_names = outer_name ? outer_name.to_s.split("::") : [] #: Array[String]
+        qualified_name = ''
+        outer_names.each do |namespace|
+          qualified_name += namespace
+          if (module_name = @top_level.find_module_named((qualified_name += "::") + name))
+            name = module_name.full_name
+            break
+          end
+        end
+        extend_decl = RDoc::Extend.new(name, nil)
+        extend_decl.comment = construct_comment(context: context, comment: comment_string(decl)) if decl.comment
+        context.add_extend(extend_decl)
+      end
+
+      private
+
+      def construct_comment(context:, comment:)
+        comment = RDoc::Comment.new(comment, context)
+        comment.format = "markdown"
+        comment
+      end
+
+      def comment_string(with_comment)
+        comment = with_comment.comment or raise "Object with `#comment` returning a object is expected"
+        comment.string
+      end
+
+      def fully_qualified_name(outer_name:, decl:)
+        if outer_name
+          (outer_name + decl.name)
+        else
+          decl.name
+        end
+      end
+    end
+  end
+end

data/rbs.gemspec

@@ -0,0 +1,68 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rbs/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbs"
+  spec.version       = RBS::VERSION
+  spec.authors       = ["Soutaro Matsumoto"]
+  spec.email         = ["matsumoto@soutaro.com"]
+
+  spec.summary       = %q{Type signature for Ruby.}
+  spec.description   = %q{RBS is the language for type signatures for Ruby and standard library definitions.}
+  spec.homepage      = "https://github.com/ruby/rbs"
+  spec.licenses      = ['BSD-2-Clause', 'Ruby']
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["homepage_uri"] = spec.homepage
+    spec.metadata["source_code_uri"] = "https://github.com/ruby/rbs.git"
+    spec.metadata["changelog_uri"] = "https://github.com/ruby/rbs/blob/master/CHANGELOG.md"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      [
+        %r{^(test|spec|features|bin|steep|benchmark|templates|rust|\.vscode)/},
+        /Gemfile/,
+      ].any? {|r| f.match(r) }
+    end
+  end
+
+  # JRuby cannot load the MRI C extension. On JRuby (and in the `java` platform
+  # gem, built with RBS_PLATFORM=java) RBS runs the WebAssembly-backed parser, so
+  # ship the prebuilt parser and the Chicory jars (assembled by
+  # `rake wasm:jruby_setup`) and skip the C extension.
+  building_java_gem = ENV["RBS_PLATFORM"] == "java"
+  on_jruby = defined?(RUBY_ENGINE) && RUBY_ENGINE == "jruby"
+
+  if building_java_gem || on_jruby
+    # Only stamp the platform when building the release gem; leave it unset for
+    # local development on JRuby so it still matches a `ruby` platform lockfile.
+    spec.platform = "java" if building_java_gem
+    spec.files += Dir.chdir(File.expand_path('..', __FILE__)) do
+      Dir.glob("lib/rbs/wasm/rbs_parser.wasm") + Dir.glob("lib/rbs/wasm/jars/*.jar")
+    end
+  else
+    spec.extensions = %w{ext/rbs_extension/extconf.rb}
+  end
+
+  if false
+    spec.required_ruby_version = ">= 3.4"
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 3.2"
+  spec.add_dependency "logger"
+  spec.add_dependency "prism", ">= 1.6.0"
+  spec.add_dependency "tsort"
+end

data/schema/annotation.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "title": "Annotation associated to a declaration or a member: `%a{rbs:test}`, `%a{steep:deprecated}`, ...",
+  "type": "object",
+  "properties": {
+    "string": {
+      "type": "string"
+    },
+    "location": {
+      "$ref": "location.json"
+    }
+  },
+  "required": ["string", "location"]
+}

data/schema/comment.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "definitions": {
+    "comment": {
+      "type": "object",
+      "properties": {
+        "string": {
+          "type": "string"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["string", "location"]
+    }
+  },
+  "title": "Comment associated with a declaration or a member",
+  "oneOf": [
+    {
+      "$ref": "#/definitions/comment"
+    },
+    {
+      "type": "null"
+    }
+  ]
+}

data/schema/decls.json

@@ -0,0 +1,326 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "definitions": {
+    "alias": {
+      "title": "Type alias declaration: `type foo = Integer`, ...",
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "type": "string",
+          "enum": ["alias"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type_params": {
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
+        },
+        "type": {
+          "$ref": "types.json"
+        },
+        "annotations": {
+          "type": "array",
+          "items": {
+            "$ref": "annotation.json"
+          }
+        },
+        "location": {
+          "$ref": "location.json"
+        },
+        "comment": {
+          "$ref": "comment.json"
+        }
+      },
+      "required": ["declaration", "name", "type_params", "type", "annotations", "location", "comment"]
+    },
+    "constant": {
+      "title": "Constant declaration: `VERSION: String`, ...",
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "type": "string",
+          "enum": ["constant"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type": {
+          "$ref": "types.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        },
+        "comment": {
+          "$ref": "comment.json"
+        }
+      },
+      "required": ["declaration", "name", "type", "comment", "location"]
+    },
+    "global": {
+      "title": "Global declaration: `$DEBUG: boolish`, ...",
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "type": "string",
+          "enum": ["global"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type": {
+          "$ref": "types.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        },
+        "comment": {
+          "$ref": "comment.json"
+        }
+      },
+      "required": ["declaration", "name", "type", "comment", "location"]
+    },
+    "classMember": {
+      "oneOf": [
+        {
+          "$ref": "members.json#/definitions/methodDefinition"
+        },
+        {
+          "$ref": "members.json#/definitions/variable"
+        },
+        {
+          "$ref": "members.json#/definitions/include"
+        },
+        {
+          "$ref": "members.json#/definitions/extend"
+        },
+        {
+          "$ref": "members.json#/definitions/prepend"
+        },
+        {
+          "$ref": "members.json#/definitions/attribute"
+        },
+        {
+          "$ref": "members.json#/definitions/visibility"
+        },
+        {
+          "$ref": "members.json#/definitions/alias"
+        },
+        {
+          "$ref": "#/definitions/alias"
+        },
+        {
+          "$ref": "#/definitions/constant"
+        },
+        {
+          "$ref": "#/definitions/class"
+        },
+        {
+          "$ref": "#/definitions/module"
+        },
+        {
+          "$ref": "#/definitions/interface"
+        }
+      ]
+    },
+    "class": {
+      "title": "Class declaration",
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "enum": ["class"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type_params": {
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
+        },
+        "members": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/classMember"
+          }
+        },
+        "super_class": {
+          "oneOf": [
+            {
+              "type": "null"
+            },
+            {
+              "type": "object",
+              "properties": {
+                "name": {
+                  "type": "string"
+                },
+                "args": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "types.json"
+                  }
+                }
+              },
+              "required": ["name", "args"]
+            }
+          ]
+        },
+        "annotations": {
+          "type": "array",
+          "items": {
+            "$ref": "annotation.json"
+          }
+        },
+        "comment": {
+          "$ref": "comment.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["declaration", "name", "type_params", "members", "super_class", "annotations", "comment", "location"]
+    },
+    "module": {
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "enum": ["module"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type_params": {
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
+        },
+        "members": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/classMember"
+          }
+        },
+        "self_types": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/moduleSelf"
+          }
+        },
+        "annotations": {
+          "type": "array",
+          "items": {
+            "$ref": "annotation.json"
+          }
+        },
+        "comment": {
+          "$ref": "comment.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["declaration", "name", "type_params", "members", "self_types", "annotations", "location", "comment"]
+    },
+    "moduleSelf": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "$ref": "types.json"
+          }
+        }
+      },
+      "required": ["name", "args"]
+    },
+    "interfaceMember": {
+      "oneOf": [
+        {
+          "allOf": [
+            {
+              "$ref": "members.json#/definitions/methodDefinition"
+            },
+            {
+              "type": "object",
+              "properties": {
+                "kind": {
+                  "enum": ["instance"]
+                }
+              }
+            }
+          ]
+        },
+        {
+          "$ref": "members.json#/definitions/include"
+        },
+        {
+          "$ref": "members.json#/definitions/alias"
+        }
+      ]
+    },
+    "interface": {
+      "type": "object",
+      "properties": {
+        "declaration": {
+          "enum": ["interface"]
+        },
+        "name": {
+          "type": "string"
+        },
+        "type_params": {
+          "type": "array",
+          "items": {
+            "$ref": "typeParam.json"
+          }
+        },
+        "members": {
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/interfaceMember"
+          }
+        },
+        "annotations": {
+          "type": "array",
+          "items": {
+            "$ref": "annotation.json"
+          }
+        },
+        "comment": {
+          "$ref": "comment.json"
+        },
+        "location": {
+          "$ref": "location.json"
+        }
+      },
+      "required": ["declaration", "name", "type_params", "members", "annotations", "comment", "location"]
+    }
+  },
+  "oneOf": [
+    {
+      "$ref": "#/definitions/alias"
+    },
+    {
+      "$ref": "#/definitions/constant"
+    },
+    {
+      "$ref": "#/definitions/global"
+    },
+    {
+      "$ref": "#/definitions/class"
+    },
+    {
+      "$ref": "#/definitions/module"
+    },
+    {
+      "$ref": "#/definitions/interface"
+    }
+  ]
+}

data/schema/function.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "http://json-schema.org/draft-04/schema#",
+  "definitions": {
+    "param": {
+      "title": "Function parameter with type and optional name: `Integer size`, `::String name`, `untyped`, ...",
+      "type": "object",
+      "properties": {
+        "type": {
+          "$ref": "types.json"
+        },
+        "name": {
+          "oneOf": [
+            {
+              "type": "string"
+            },
+            {
+              "type": "null"
+            }
+          ]
+        }
+      },
+      "required": ["type", "name"]
+    }
+  },
+  "properties": {
+    "required_positionals": {
+      "title": "Required positional parameters",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/param"
+      }
+    },
+    "optional_positionals": {
+      "title": "Optional positional parameters",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/param"
+      }
+    },
+    "rest_positionals": {
+      "title": "Rest parameter",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/param"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "trailing_positionals": {
+      "title": "Trailing potisional parameters",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/param"
+      }
+    },
+    "required_keywords": {
+      "title": "Required keyword parameters",
+      "additionalProperties": {
+        "$ref": "#/definitions/param"
+      }
+    },
+    "optional_keywords": {
+      "title": "Optional keyword parameters",
+      "additionalProperties": {
+        "$ref": "#/definitions/param"
+      }
+    },
+    "rest_keywords": {
+      "title": "Rest keyword parameters",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/param"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "return_type": {
+      "title": "Return type of a function",
+      "$ref": "types.json"
+    }
+  },
+  "required": ["required_positionals", "optional_positionals", "rest_positionals", "trailing_positionals", "required_keywords", "optional_keywords", "rest_keywords", "return_type"]
+}