rbs 0.2.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2559e695400fc8d1c360aa80b1a9065f5ea0ae24b59faa91907102f7fc46d572
-  data.tar.gz: e32722dcf716317553827e15b3232e8971f3d613c3b2bd7f71a5b902e2fef8b3
+  metadata.gz: ce3b2807a94277727870ef841bdb1e3a96567098948930ab6885e9fba2fc3ccf
+  data.tar.gz: 5d4a01b26887124240ec757b8a0374c79d56c3daf8b32431a571a3ba401112cc
 SHA512:
-  metadata.gz: c26e77f6a2506cf1414d12aa74e1783bf8f7ca40d5e803831c9deb2e8b290954db119bb89fa8d26a24b76e8713b26fdd6535e557e59788808addbc3e96a07ec8
-  data.tar.gz: 10a1e4a16e16f627bda62c565258b84bb830c7a85b0d74acbd9187094626b3e76eca4f8bacc5d77758755bfa82d5dacdd7dc6a374b53f3778d0421b449013d40
+  metadata.gz: 7978edfd75f809eb604edb58e0c35ff9a1e85b0e34f7462399f76deb36c5a6a0c61030d1fc3a3bb42d689395a0372995e03e41dd47223063084703dc207294d6
+  data.tar.gz: e1216599f496cd883e8b301d1040f395984d3fc3029ba65fa6c2f63ab3e431a96bc8369ff06bd3f97390dd78e0a10279e1e556ba2c25ac4ef5af6dfaf9aafa77

data/.github/workflows/ruby.yml

@@ -24,5 +24,11 @@ jobs:
         ruby -v
         gem install bundler
         bin/setup
-        bundle exec rake
+        bundle exec rake test
+        bundle exec rake stdlib_test
+        bundle exec rake rubocop
+        bundle exec rake validate
+        bundle exec rake test_doc
         bundle exec rake build
+        RBS_GENERATE_TEST_PATH=/tmp/Array_test.rb bundle exec rake 'generate:stdlib_test[Array]'
+        ruby -c /tmp/Array_test.rb

data/.gitignore

@@ -5,8 +5,8 @@
 /pkg/
 /spec/reports/
 /tmp/
-/Gemfile.lock
 /.ruby-version
 /lib/rbs/parser.rb
 /lib/rbs/parser.output
 /vendor/sigs
+/Gemfile.lock

data/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 ## master
 
+## 0.6.0 (2020-07-12)
+
+* Signature update for `Logger`.
+* Clean `Environment#inspect`. [#331](https://github.com/ruby/rbs/pull/331)
+* Module self type syntax update. [#329](https://github.com/ruby/rbs/pull/329)
+* Better validation. [#328](https://github.com/ruby/rbs/pull/328)
+* Parser performance improvement. [#327](https://github.com/ruby/rbs/pull/327)
+* Runtime type checking performance improvements with sampling [#323](https://github.com/ruby/rbs/pull/323)
+
+## 0.5.0 (2020-07-04)
+
+* Signature updates for `Mutex_m`, `IO`, and `Enumerable`.
+* Syntax update. [#307](https://github.com/ruby/rbs/pull/307)
+* AST command prints _absolute_ type names with file name filtering. [#312](https://github.com/ruby/rbs/pull/312)
+* Improve CLI message. [#309](https://github.com/ruby/rbs/pull/309)
+
+## 0.4.0 (2020-06-15)
+
+* Signature update for `Fiber`, `Encoding`, and `Enumerator`.
+* Fix syntax error for underscore and `!` `?` [#304](https://github.com/ruby/rbs/pull/304)
+* Improved return type inference in `rbs prototype rb` [#303](https://github.com/ruby/rbs/pull/303)
+* Skip anonymous modules/classes in `rbs prototype runtime` [#302](https://github.com/ruby/rbs/pull/302)
+* Fix `--require-relative` option in `rbs prototype runtime` [#299](https://github.com/ruby/rbs/pull/299)
+* Add JSON schema for `rbs ast` [#295](https://github.com/ruby/rbs/pull/295)
+
+## 0.3.1 (2020-05-22)
+
+* Fix constant resolution again [#289](https://github.com/ruby/rbs/pull/289)
+
+## 0.3.0 (2020-05-20)
+
+* Fix constant resolution [#288](https://github.com/ruby/rbs/pull/288)
+
+## 0.2.0
+
 * The first release of RBS gem.
 
 ## 0.1.0

data/COPYING

@@ -1,4 +1,4 @@
-ruby-signature is copyrighted free software by Soutaro Matsumoto <matsumoto@soutaro.com>.
+rbs is copyrighted free software by Soutaro Matsumoto <matsumoto@soutaro.com>.
 You can redistribute it and/or modify it under either the terms of the
 2-clause BSDL (see the file BSDL), or the conditions below:
 

data/Gemfile

@@ -1,6 +1,20 @@
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in ruby-signature.gemspec
+# Specify your gem's dependencies in rbs.gemspec
 gemspec
 
-gem "ruby-signature-amber", path: "test/assets/test-gem"
+# Development dependencies
+gem "rake"
+gem "minitest"
+gem "racc"
+gem "rubocop"
+gem "rubocop-rubycw"
+gem "minitest-reporters"
+gem "json"
+gem "json-schema"
+gem 'stackprof'
+gem "goodcheck"
+
+# Test gems
+gem "rbs-amber", path: "test/assets/test-gem"
+

data/README.md

@@ -1,79 +1,118 @@
 # RBS
 
-RBS provides syntax and semantics definition for the `Ruby Signature` language, `.rbs` files.
-It consists of a parser, the syntax, and class definition interpreter, the semantics.
+RBS is a language to describe the structure of Ruby programs.
+You can write down the definition of a class or module: methods defined in the class, instance variables and their types, and inheritance/mix-in relations.
+It also allows declaring constants and global variables.
 
-## Build
+The following is a small example of RBS for a chat app.
 
-We haven't published a gem yet.
-You need to install the dependencies, and build its parser with `bin/setup`.
+<!-- run-start:a.rbs:bundle exec rbs -I a.rbs validate -->
+```rbs
+module ChatApp
+  VERSION: String
 
-```
-$ bin/setup
-$ bundle exec exe/rbs
-```
+  class User
+    attr_reader login: String
+    attr_reader email: String
 
-## Usage
+    def initialize: (login: String, email: String) -> void
+  end
 
-```
-$ rbs list
-$ rbs ancestors ::Object
-$ rbs methods ::Object
-$ rbs method ::Object tap
-```
+  class Bot
+    attr_reader name: String
+    attr_reader email: String
+    attr_reader owner: User
 
-### rbs [--class|--module|interface] list
+    def initialize: (name: String, owner: User) -> void
+  end
 
-```
-$ rbs list
-```
+  class Message
+    attr_reader id: String
+    attr_reader string: String
+    attr_reader from: User | Bot                     # `|` means union types: `#from` can be `User` or `Bot`
+    attr_reader reply_to: Message?                   # `?` means optional type: `#reply_to` can be `nil`
 
-This command lists all of the classes/modules/interfaces defined in `.rbs` files.
+    def initialize: (from: User | Bot, string: String) -> void
 
-### rbs ancestors [--singleton|--instance] CLASS
+    def reply: (from: User | Bot, string: String) -> Message
+  end
 
+  class Channel
+    attr_reader name: String
+    attr_reader messages: Array[Message]
+    attr_reader users: Array[User]
+    attr_reader bots: Array[Bot]
+
+    def initialize: (name: String) -> void
+
+    def each_member: () { (User | Bot) -> void } -> void  # `{` and `}` means block.
+                   | () -> Enumerable[User | Bot, void]   # Method can be overloaded.
+  end
+end
 ```
-$ rbs ancestors Array                    # ([].class.ancestors)
-$ rbs ancestors --singleton Array        # (Array.class.ancestors)
-```
+<!-- run-end -->
 
-This command prints the _ancestors_ of the class.
-The name of the command is borrowed from `Class#ancestors`, but the semantics is a bit different.
-The `ancestors` command is more precise (I believe).
+## Installation
 
-### rbs methods [--singleton|--instance] CLASS
+Install the `rbs` gem. `$ gem install rbs` from the command line, or add a line in your `Gemfile`.
 
-```
-$ rbs methods ::Integer                  # 1.methods
-$ rbs methods --singleton ::Object       # Object.methods
+```rb
+gem "rbs"
 ```
 
-This command prints all methods provided for the class.
+## CLI
 
-### rbs method [--singleton|--instance] CLASS METHOD
+The gem ships with the `rbs` command line tool to demonstrate what it can do and help develop RBS.
 
-```
-$ rbs method ::Integer '+'               # 1+2
-$ rbs method --singleton ::Object tap    # Object.tap { ... }
+```bash
+$ rbs version
+$ rbs list
+$ rbs ancestors ::Object
+$ rbs methods ::Object
+$ rbs method Object then
 ```
 
-This command prints type and properties of the method.
+## Library
 
-### Options
+There are two important concepts, _environment_ and _definition_. 
 
-It accepts two global options, `-r` and `-I`.
+An _environment_ is a dictionary that keeps track of all declarations. What is the declaration associated with `String` class? An _environment_ will give you the answer.
 
-`-r` is for libraries. You can specify the names of libraries.
+A _definition_ gives you the detail of the class. What is the type of the return value of `gsub` method of the `String` class? The _definition_ for `String` class knows the list of methods it provides and their types.
 
-```
-$ rbs -r set list
-```
+The following is a small code to retrieve the definition of the `String#gsub` method.
 
-`-I` is for application signatures. You can specify the name of directory.
+<!-- run-start:a.rb:bundle exec ruby a.rb -->
+```rb
+require "rbs"
 
+loader = RBS::EnvironmentLoader.new()
+
+# loader.add(path: Pathname("sig"))   # Load .rbs files from `sig` directory
+# loader.add(library: "pathname")     # Load pathname library
+
+environment = RBS::Environment.from_loader(loader).resolve_type_names
+
+# ::String
+string = RBS::TypeName.new(name: :String, namespace: RBS::Namespace.root)
+
+# Class declaration for ::String
+decl = environment.class_decls[string]
+
+# Builder provides the translation from `declaration` to `definition`
+builder = RBS::DefinitionBuilder.new(env: environment)
+
+# Definition of instance of String
+instance = builder.build_instance(string)
+# Print the types of `gsub` method
+puts instance.methods[:gsub].method_types.join("\n")
+
+# Definition of singleton of String
+singleton = builder.build_singleton(string)
+# No `gsub` method for String singleton
+puts singleton.methods[:gsub]
 ```
-$ rbs -I sig list
-```
+<!-- run-end -->
 
 ## Guides
 
@@ -90,4 +129,4 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/ruby-signature.
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/rbs.

data/Rakefile

@@ -9,10 +9,23 @@ Rake::TestTask.new(:test) do |t|
   end
 end
 
-multitask :default => [:test, :stdlib_test, :rubocop, :validate]
+multitask :default => [:test, :stdlib_test, :rubocop, :validate, :test_doc]
+
+task :test_doc => :parser do
+  files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").select do |file| Pathname(file).extname == ".md" end
+  end
+
+  sh "ruby bin/run_in_md.rb #{files.join(" ")}"
+end
 
 task :validate => :parser do
   sh "rbs validate"
+
+  FileList["stdlib/*"].each do |path|
+    next if path =~ %r{stdlib/builtin}
+    sh "rbs -r#{File.basename(path)} validate"
+  end
 end
 
 FileList["test/stdlib/**/*_test.rb"].each do |test|
@@ -41,11 +54,11 @@ namespace :generate do
       raise "Class name is necessary. e.g. rake 'generate:stdlib_test[String]'"
     end
 
-    path = Pathname("test/stdlib/#{klass}_test.rb")
+    path = Pathname(ENV["RBS_GENERATE_TEST_PATH"] || "test/stdlib/#{klass}_test.rb")
     raise "#{path} already exists!" if path.exist?
 
     require "erb"
-    require "ruby/signature"
+    require "rbs"
 
     class TestTemplateBuilder
       attr_reader :klass, :env
@@ -53,35 +66,54 @@ namespace :generate do
       def initialize(klass)
         @klass = klass
 
-        @env = Ruby::Signature::Environment.new
-        Ruby::Signature::EnvironmentLoader.new.load(env: @env)
+        loader = RBS::EnvironmentLoader.new
+        Dir['stdlib/*'].each do |lib|
+          next if lib.end_with?('builtin')
+
+          loader.add(library: File.basename(lib))
+        end
+        @env = RBS::Environment.from_loader(loader).resolve_type_names
       end
 
       def call
         ERB.new(<<~ERB, trim_mode: "-").result(binding)
           require_relative "test_helper"
 
-          class <%= klass %>Test < StdlibTest
-            target <%= klass %>
+          <%- unless class_methods.empty? -%>
+          class <%= klass %>SingletonTest < Minitest::Test
+            include TypeAssertions
+
             # library "pathname", "set", "securerandom"     # Declare library signatures to load
-            using hook.refinement
+            testing "singleton(::<%= klass %>)"
+
           <%- class_methods.each do |method_name, definition| %>
-            def test_class_method_<%= test_name_for(method_name) %>
-            <%- definition.method_types.each do |method_type| -%>
-              # <%= method_type %>
-              <%= klass %>.<%= method_name %>
-            <%- end -%>
+            def test_<%= test_name_for(method_name) %>
+          <%- definition.method_types.each do |method_type| -%>
+              assert_send_type  "<%= method_type %>",
+                                <%= klass %>, :<%= method_name %>
+          <%- end -%>
             end
           <%- end -%>
+          end
+          <%- end -%>
+
+          <%- unless instance_methods.empty? -%>
+          class <%= klass %>Test < Minitest::Test
+            include TypeAssertions
+
+            # library "pathname", "set", "securerandom"     # Declare library signatures to load
+            testing "::<%= klass %>"
+
           <%- instance_methods.each do |method_name, definition| %>
             def test_<%= test_name_for(method_name) %>
-            <%- definition.method_types.each do |method_type| -%>
-              # <%= method_type %>
-              <%= klass %>.new.<%= method_name %>
-            <%- end -%>
+          <%- definition.method_types.each do |method_type| -%>
+              assert_send_type  "<%= method_type %>",
+                                <%= klass %>.new, :<%= method_name %>
+          <%- end -%>
             end
           <%- end -%>
           end
+          <%- end -%>
         ERB
       end
 
@@ -117,18 +149,18 @@ namespace :generate do
       end
 
       def type_name
-        @type_name ||= Ruby::Signature::TypeName.new(name: klass.to_sym, namespace: Ruby::Signature::Namespace.new(path: [], absolute: true))
+        @type_name ||= RBS::TypeName.new(name: klass.to_sym, namespace: RBS::Namespace.new(path: [], absolute: true))
       end
 
       def class_methods
-        @class_methods ||= Ruby::Signature::DefinitionBuilder.new(env: env).build_singleton(type_name).methods.select {|_, definition|
-          definition.implemented_in.name.absolute! == type_name
+        @class_methods ||= RBS::DefinitionBuilder.new(env: env).build_singleton(type_name).methods.select {|_, definition|
+          definition.implemented_in == type_name
         }
       end
 
       def instance_methods
-        @instance_methods ||= Ruby::Signature::DefinitionBuilder.new(env: env).build_instance(type_name).methods.select {|_, definition|
-          definition.implemented_in.name.absolute! == type_name
+        @instance_methods ||= RBS::DefinitionBuilder.new(env: env).build_instance(type_name).methods.select {|_, definition|
+          definition.implemented_in == type_name
         }
       end
     end

data/bin/rbs-prof

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require "stackprof"
+
+out = ENV["RBS_STACKPROF_OUT"] || 'tmp/stackprof-cpu-rbs.dump'
+
+StackProf.run(mode: :cpu, out: out) do
+  load File.join(__dir__, "../exe/rbs")
+end

data/bin/run_in_md.rb

@@ -0,0 +1,49 @@
+require "tmpdir"
+require "shellwords"
+
+ARGV.each do |path|
+  puts "~~~~~~~ Checking #{path} ~~~~~~"
+  content = File.read(path)
+
+  snippets = []
+  lines = []
+  content.lines.each.with_index do |line, index|
+    case line
+    when /run-start:/
+      lines = [[line, index+1]]
+    when /run-end/
+      lines << [line, index+1]
+      snippets << lines
+      lines = []
+    else
+      lines << [line, index+1]
+    end
+  end
+
+  snippets.each do |lines|
+    puts ">>> Code detected: "
+    hd, _, *code_lines, _, _ = lines
+
+    head = hd[0]
+    head.gsub!(/^<!-- +/, "").gsub!(/ +-->$/, "")
+    _,name,command = head.split(/:/)
+
+    puts "# command=#{Shellwords.split(command).inspect}"
+    puts "# name=#{name}"
+    puts code_lines.map {|line, i| "#{"%4d" % i}  #{line}" }.join
+
+    code = code_lines.map(&:first).join
+
+    puts ">>> Running..."
+    Dir.mktmpdir do |dir|
+      File.write(File.join(dir, name), code)
+      pid = spawn({ "BUNDLE_GEMFILE" => File.join(__dir__, "../Gemfile") },
+                  *Shellwords.split(command),
+                  chdir: dir)
+
+      _, status = Process.waitpid2(pid)
+
+      status.success? or raise "Failed to execute code: #{code_lines.join}"
+    end
+  end
+end