rbs 1.1.1 → 1.2.0

data/sig/util.rbs

@@ -6,8 +6,4 @@ module RBS
 
     def hash: () -> Integer
   end
-
-  interface _ToJson
-    def to_json: (*untyped) -> String
-  end
 end

data/sig/writer.rbs

@@ -1,9 +1,15 @@
 module RBS
   class Writer
-    attr_reader out: IO
+    interface _IO
+      def puts: (*untyped) -> void
+
+      def flush: () -> void
+    end
+
+    attr_reader out: _IO
     attr_reader indentation: Array[String]
 
-    def initialize: (out: IO) -> void
+    def initialize: (out: _IO) -> void
 
     def indent: (?Integer size) { () -> void } -> void
 

data/stdlib/rubygems/0/requirement.rbs

@@ -1,3 +1,85 @@
-class Gem::Requirement
-  # TODO: Add sinatures...
+module Gem
+  # A Requirement is a set of one or more version restrictions. It supports a few
+  # (`=, !=, >, <, >=, <=, ~>`) different restriction operators.
+  #
+  # See Gem::Version for a description on how versions and requirements work
+  # together in RubyGems.
+  #
+  class Requirement
+    type operator = "=" | "!=" | ">" | "<" | ">=" | "<=" | "~>"
+
+    # Raised when a bad requirement is encountered
+    #
+    class BadRequirementError < ArgumentError
+    end
+
+    # The default requirement matches any version
+    #
+    DefaultPrereleaseRequirement: [ operator, Gem::Version ]
+
+    # The default requirement matches any non-prerelease version
+    #
+    DefaultRequirement: [ operator, Gem::Version ]
+
+    # A regular expression that matches a requirement
+    #
+    PATTERN: Regexp
+
+    # Factory method to create a Gem::Requirement object.  Input may be a Version, a
+    # String, or nil.  Intended to simplify client code.
+    #
+    # If the input is "weird", the default version requirement is returned.
+    #
+    def self.create: (*(String | Gem::Version | Gem::Requirement | nil) inputs) -> instance
+
+    def self.default: () -> instance
+
+    def self.default_prerelease: () -> instance
+
+    # Parse `obj`, returning an `[op, version]` pair. `obj` can be a String or a
+    # Gem::Version.
+    #
+    # If `obj` is a String, it can be either a full requirement specification, like
+    # `">= 1.2"`, or a simple version number, like `"1.2"`.
+    #
+    #     parse("> 1.0")                 # => [">", Gem::Version.new("1.0")]
+    #     parse("1.0")                   # => ["=", Gem::Version.new("1.0")]
+    #     parse(Gem::Version.new("1.0")) # => ["=,  Gem::Version.new("1.0")]
+    #
+    def self.parse: (String | Gem::Version obj) -> [ operator, Gem::Version ]
+
+    # Constructs a requirement from `requirements`. Requirements can be Strings,
+    # Gem::Versions, or Arrays of those. `nil` and duplicate requirements are
+    # ignored. An empty set of `requirements` is the same as `">= 0"`.
+    #
+    def initialize: (*(String | Gem::Version) requirements) -> void
+
+    # Concatenates the `new` requirements onto this requirement.
+    #
+    def concat: (Array[String | Gem::Version] new) -> void
+
+    # true if the requirement is for only an exact version
+    #
+    def exact?: () -> bool
+
+    # true if this gem has no requirements.
+    #
+    def none?: () -> bool
+
+    # A requirement is a prerelease if any of the versions inside of it are
+    # prereleases
+    #
+    def prerelease?: () -> bool
+
+    # True if `version` satisfies this Requirement.
+    #
+    def satisfied_by?: (Gem::Version version) -> bool
+
+    alias === satisfied_by?
+    alias =~ satisfied_by?
+
+    # True if the requirement will not always match the latest version.
+    #
+    def specific?: () -> bool
+  end
 end

data/stdlib/rubygems/0/version.rbs

@@ -170,7 +170,8 @@ module Gem
     #     ver2 = Version.create(ver1)       # -> (ver1)
     #     ver3 = Version.create(nil)        # -> nil
     #
-    def self.create: (_ToS | Version | nil input) -> instance?
+    def self.create: (_ToS | Version input) -> instance
+                   | (nil input) -> nil
 
     # Constructs a Version from the `version` string.  A version string is a series
     # of digits or ASCII letters separated by dots.

data/stdlib/shellwords/0/shellwords.rbs

@@ -0,0 +1,252 @@
+# ## Manipulates strings like the UNIX Bourne shell
+#
+# This module manipulates strings according to the word parsing rules of the
+# UNIX Bourne shell.
+#
+# The shellwords() function was originally a port of shellwords.pl, but modified
+# to conform to the Shell & Utilities volume of the IEEE Std 1003.1-2008, 2016
+# Edition [1].
+#
+# ### Usage
+#
+# You can use Shellwords to parse a string into a Bourne shell friendly Array.
+#
+#     require 'shellwords'
+#
+#     argv = Shellwords.split('three blind "mice"')
+#     argv #=> ["three", "blind", "mice"]
+#
+# Once you've required Shellwords, you can use the #split alias
+# String#shellsplit.
+#
+#     argv = "see how they run".shellsplit
+#     argv #=> ["see", "how", "they", "run"]
+#
+# They treat quotes as special characters, so an unmatched quote will cause an
+# ArgumentError.
+#
+#     argv = "they all ran after the farmer's wife".shellsplit
+#          #=> ArgumentError: Unmatched quote: ...
+#
+# Shellwords also provides methods that do the opposite. Shellwords.escape, or
+# its alias, String#shellescape, escapes shell metacharacters in a string for
+# use in a command line.
+#
+#     filename = "special's.txt"
+#
+#     system("cat -- #{filename.shellescape}")
+#     # runs "cat -- special\\'s.txt"
+#
+# Note the '--'.  Without it, cat(1) will treat the following argument as a
+# command line option if it starts with '-'.  It is guaranteed that
+# Shellwords.escape converts a string to a form that a Bourne shell will parse
+# back to the original string, but it is the programmer's responsibility to make
+# sure that passing an arbitrary argument to a command does no harm.
+#
+# Shellwords also comes with a core extension for Array, Array#shelljoin.
+#
+#     dir = "Funny GIFs"
+#     argv = %W[ls -lta -- #{dir}]
+#     system(argv.shelljoin + " | less")
+#     # runs "ls -lta -- Funny\\ GIFs | less"
+#
+# You can use this method to build a complete command line out of an array of
+# arguments.
+#
+# ### Authors
+# *   Wakou Aoyama
+# *   Akinori MUSHA <knu@iDaemons.org>
+#
+#
+# ### Contact
+# *   Akinori MUSHA <knu@iDaemons.org> (current maintainer)
+#
+#
+# ### Resources
+#
+# 1: [IEEE Std 1003.1-2008, 2016 Edition, the Shell & Utilities
+# volume](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.htm
+# l)
+module Shellwords
+  # Escapes a string so that it can be safely used in a Bourne shell command line.
+  #  `str` can be a non-string object that responds to `to_s`.
+  #
+  # Note that a resulted string should be used unquoted and is not intended for
+  # use in double quotes nor in single quotes.
+  #
+  #     argv = Shellwords.escape("It's better to give than to receive")
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #     argv = "It's better to give than to receive".shellescape
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #     # Search files in lib for method definitions
+  #     pattern = "^[ \t]*def "
+  #     open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #       grep.each_line { |line|
+  #         file, lineno, matched_line = line.split(':', 3)
+  #         # ...
+  #       }
+  #     }
+  #
+  # It is the caller's responsibility to encode the string in the right encoding
+  # for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if `str` has a length of zero.
+  #
+  def self.shellescape: (String str) -> String
+
+  # Builds a command line string from an argument list, `array`.
+  #
+  # All elements are joined into a single string with fields separated by a space,
+  # where each element is escaped for the Bourne shell and stringified using
+  # `to_s`.
+  #
+  #     ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #     argv = Shellwords.join(ary)
+  #     argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #     ary = ["Don't", "rock", "the", "boat"]
+  #     argv = ary.shelljoin
+  #     argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #     output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def self.shelljoin: (Array[String] array) -> String
+
+  # Splits a string into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  #     argv = Shellwords.split('here are "two words"')
+  #     argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell metacharacters
+  # except for the single and double quotes and backslash are not treated as such.
+  #
+  #     argv = Shellwords.split('ruby my_prog.rb | less')
+  #     argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #     argv = 'here are "two words"'.shellsplit
+  #     argv #=> ["here", "are", "two words"]
+  #
+  def self.shellsplit: (String line) -> Array[String]
+
+  alias self.escape self.shellescape
+
+  alias self.join self.shelljoin
+
+  alias self.shellwords self.shellsplit
+
+  alias self.split self.shellsplit
+
+  private
+
+  # Escapes a string so that it can be safely used in a Bourne shell command line.
+  #  `str` can be a non-string object that responds to `to_s`.
+  #
+  # Note that a resulted string should be used unquoted and is not intended for
+  # use in double quotes nor in single quotes.
+  #
+  #     argv = Shellwords.escape("It's better to give than to receive")
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  # String#shellescape is a shorthand for this function.
+  #
+  #     argv = "It's better to give than to receive".shellescape
+  #     argv #=> "It\\'s\\ better\\ to\\ give\\ than\\ to\\ receive"
+  #
+  #     # Search files in lib for method definitions
+  #     pattern = "^[ \t]*def "
+  #     open("| grep -Ern -e #{pattern.shellescape} lib") { |grep|
+  #       grep.each_line { |line|
+  #         file, lineno, matched_line = line.split(':', 3)
+  #         # ...
+  #       }
+  #     }
+  #
+  # It is the caller's responsibility to encode the string in the right encoding
+  # for the shell environment where this string is used.
+  #
+  # Multibyte characters are treated as multibyte characters, not as bytes.
+  #
+  # Returns an empty quoted String if `str` has a length of zero.
+  #
+  def shellescape: (String str) -> String
+
+  # Builds a command line string from an argument list, `array`.
+  #
+  # All elements are joined into a single string with fields separated by a space,
+  # where each element is escaped for the Bourne shell and stringified using
+  # `to_s`.
+  #
+  #     ary = ["There's", "a", "time", "and", "place", "for", "everything"]
+  #     argv = Shellwords.join(ary)
+  #     argv #=> "There\\'s a time and place for everything"
+  #
+  # Array#shelljoin is a shortcut for this function.
+  #
+  #     ary = ["Don't", "rock", "the", "boat"]
+  #     argv = ary.shelljoin
+  #     argv #=> "Don\\'t rock the boat"
+  #
+  # You can also mix non-string objects in the elements as allowed in Array#join.
+  #
+  #     output = `#{['ps', '-p', $$].shelljoin}`
+  #
+  def shelljoin: (Array[String] array) -> String
+
+  # Splits a string into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  #     argv = Shellwords.split('here are "two words"')
+  #     argv #=> ["here", "are", "two words"]
+  #
+  # Note, however, that this is not a command line parser.  Shell metacharacters
+  # except for the single and double quotes and backslash are not treated as such.
+  #
+  #     argv = Shellwords.split('ruby my_prog.rb | less')
+  #     argv #=> ["ruby", "my_prog.rb", "|", "less"]
+  #
+  # String#shellsplit is a shortcut for this function.
+  #
+  #     argv = 'here are "two words"'.shellsplit
+  #     argv #=> ["here", "are", "two words"]
+  #
+  def shellsplit: (String line) -> Array[String]
+
+  alias shellwords shellsplit
+end
+
+class Array[unchecked out Elem]
+  # Builds a command line string from an argument list `array` joining all
+  # elements escaped for the Bourne shell and separated by a space.
+  #
+  # See Shellwords.shelljoin for details.
+  #
+  def shelljoin: () -> String
+end
+
+class String
+  # Escapes `str` so that it can be safely used in a Bourne shell command line.
+  #
+  # See Shellwords.shellescape for details.
+  #
+  def shellescape: () -> String
+
+  # Splits `str` into an array of tokens in the same way the UNIX Bourne shell
+  # does.
+  #
+  # See Shellwords.shellsplit for details.
+  #
+  def shellsplit: () -> Array[String]
+end

data/steep/Gemfile.lock

@@ -1,41 +1,44 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.1.2.1)
+    activesupport (6.1.3.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
       tzinfo (~> 2.0)
       zeitwerk (~> 2.3)
     ast (2.4.2)
-    ast_utils (0.4.0)
-      parser (>= 2.7.0)
     concurrent-ruby (1.1.8)
-    ffi (1.14.2)
-    i18n (1.8.8)
+    ffi (1.15.0)
+    i18n (1.8.10)
       concurrent-ruby (~> 1.0)
-    language_server-protocol (3.15.0.1)
-    listen (3.4.1)
+    language_server-protocol (3.16.0.0)
+    listen (3.5.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    minitest (5.14.3)
+    minitest (5.14.4)
+    parallel (1.20.1)
     parser (3.0.0.0)
       ast (~> 2.4.1)
     rainbow (3.0.0)
     rb-fsevent (0.10.4)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
-    rbs (1.0.4)
-    steep (0.41.0)
+    rbs (1.1.1)
+    steep (0.43.1)
       activesupport (>= 5.1)
-      ast_utils (>= 0.4.0)
-      language_server-protocol (~> 3.15.0.1)
+      language_server-protocol (>= 3.15, < 4.0)
       listen (~> 3.0)
+      parallel (>= 1.0.0)
       parser (>= 2.7)
       rainbow (>= 2.2.2, < 4.0)
-      rbs (~> 1.0.3)
+      rbs (~> 1.1.0)
+      terminal-table (>= 2, < 4)
+    terminal-table (3.0.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
+    unicode-display_width (1.7.0)
     zeitwerk (2.4.2)
 
 PLATFORMS

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-12 00:00:00.000000000 Z
+date: 2021-04-21 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -123,6 +123,7 @@ files:
 - lib/rbs/errors.rb
 - lib/rbs/factory.rb
 - lib/rbs/location.rb
+- lib/rbs/locator.rb
 - lib/rbs/method_type.rb
 - lib/rbs/namespace.rb
 - lib/rbs/parser.rb
@@ -177,6 +178,7 @@ files:
 - sig/environment_walker.rbs
 - sig/errors.rbs
 - sig/location.rbs
+- sig/locator.rbs
 - sig/members.rbs
 - sig/method_builder.rbs
 - sig/method_types.rbs
@@ -242,6 +244,7 @@ files:
 - stdlib/rubygems/0/version.rbs
 - stdlib/securerandom/0/securerandom.rbs
 - stdlib/set/0/set.rbs
+- stdlib/shellwords/0/shellwords.rbs
 - stdlib/singleton/0/singleton.rbs
 - stdlib/strscan/0/string_scanner.rbs
 - stdlib/time/0/time.rbs