rbs-relaxed 3.9.0.1

data/stdlib/securerandom/0/securerandom.rbs

@@ -0,0 +1,62 @@
+# <!-- rdoc-file=lib/securerandom.rb -->
+# ## Secure random number generator interface.
+#
+# This library is an interface to secure random number generators which are
+# suitable for generating session keys in HTTP cookies, etc.
+#
+# You can use this library in your application by requiring it:
+#
+#     require 'securerandom'
+#
+# It supports the following secure random number generators:
+#
+# *   openssl
+# *   /dev/urandom
+# *   Win32
+#
+# SecureRandom is extended by the Random::Formatter module which defines the
+# following methods:
+#
+# *   alphanumeric
+# *   base64
+# *   choose
+# *   gen_random
+# *   hex
+# *   rand
+# *   random_bytes
+# *   random_number
+# *   urlsafe_base64
+# *   uuid
+#
+# These methods are usable as class methods of SecureRandom such as
+# `SecureRandom.hex`.
+#
+# If a secure random number generator is not available, `NotImplementedError` is
+# raised.
+#
+module SecureRandom
+  extend Random::Formatter
+
+  # <!--
+  #   rdoc-file=lib/securerandom.rb
+  #   - alphanumeric(n = nil, chars: ALPHANUMERIC)
+  # -->
+  # Compatibility methods for Ruby 3.2, we can remove this after dropping to
+  # support Ruby 3.2
+  #
+  def self.alphanumeric: (?Integer?) -> String
+
+  def self.base64: (?Integer?) -> String
+
+  def self.hex: (?Integer?) -> String
+
+  def self.random_bytes: (?Integer?) -> String
+
+  def self.random_number: () -> Float
+                        | (Integer) -> Integer
+                        | (Numeric) -> Numeric
+
+  def self.urlsafe_base64: (?Integer?, ?bool?) -> String
+
+  def self.uuid: () -> String
+end

data/stdlib/shellwords/0/shellwords.rbs

@@ -0,0 +1,229 @@
+# <!-- rdoc-file=lib/shellwords.rb -->
+# ## 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](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/contents.ht
+# ml)
+#
+# ### 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)
+#
+module Shellwords
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - shellescape(str)
+  # -->
+  # 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`.
+  #
+  # `str` must not contain NUL characters because of nature of `exec` system call.
+  #
+  # 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
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - shelljoin(array)
+  # -->
+  # 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`. See also Shellwords.shellescape.
+  #
+  #     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
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - shellsplit(line)
+  # -->
+  # 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"]
+  #
+  # `line` must not contain NUL characters because of nature of `exec` system
+  # call.
+  #
+  # 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]
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - escape(str)
+  # -->
+  #
+  alias self.escape self.shellescape
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - join(array)
+  # -->
+  #
+  alias self.join self.shelljoin
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - shellwords(line)
+  # -->
+  #
+  alias self.shellwords self.shellsplit
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - split(line)
+  # -->
+  #
+  alias self.split self.shellsplit
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - shellwords(line)
+  # -->
+  #
+  alias shellwords shellsplit
+end
+
+%a{annotate:rdoc:skip}
+class Array[unchecked out Elem]
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - array.shelljoin => string
+  # -->
+  # 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
+
+%a{annotate:rdoc:skip}
+class String
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - str.shellescape => string
+  # -->
+  # Escapes `str` so that it can be safely used in a Bourne shell command line.
+  #
+  # See Shellwords.shellescape for details.
+  #
+  def shellescape: () -> String
+
+  # <!--
+  #   rdoc-file=lib/shellwords.rb
+  #   - str.shellsplit => array
+  # -->
+  # 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/stdlib/singleton/0/singleton.rbs

@@ -0,0 +1,131 @@
+# <!-- rdoc-file=lib/singleton.rb -->
+# The Singleton module implements the Singleton pattern.
+#
+# ## Usage
+#
+# To use Singleton, include the module in your class.
+#
+#     class Klass
+#        include Singleton
+#        # ...
+#     end
+#
+# This ensures that only one instance of Klass can be created.
+#
+#     a,b = Klass.instance, Klass.instance
+#
+#     a == b
+#     # => true
+#
+#     Klass.new
+#     # => NoMethodError - new is private ...
+#
+# The instance is created at upon the first call of Klass.instance().
+#
+#     class OtherKlass
+#       include Singleton
+#       # ...
+#     end
+#
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 0
+#
+#     OtherKlass.instance
+#     ObjectSpace.each_object(OtherKlass){}
+#     # => 1
+#
+# This behavior is preserved under inheritance and cloning.
+#
+# ## Implementation
+#
+# This above is achieved by:
+#
+# *   Making Klass.new and Klass.allocate private.
+#
+# *   Overriding Klass.inherited(sub_klass) and Klass.clone() to ensure that the
+#     Singleton properties are kept when inherited and cloned.
+#
+# *   Providing the Klass.instance() method that returns the same object each
+#     time it is called.
+#
+# *   Overriding Klass._load(str) to call Klass.instance().
+#
+# *   Overriding Klass#clone and Klass#dup to raise TypeErrors to prevent
+#     cloning or duping.
+#
+# ## Singleton and Marshal
+#
+# By default Singleton's #_dump(depth) returns the empty string. Marshalling by
+# default will strip state information, e.g. instance variables from the
+# instance. Classes using Singleton can provide custom _load(str) and
+# _dump(depth) methods to retain some of the previous state of the instance.
+#
+#     require 'singleton'
+#
+#     class Example
+#       include Singleton
+#       attr_accessor :keep, :strip
+#       def _dump(depth)
+#         # this strips the @strip information from the instance
+#         Marshal.dump(@keep, depth)
+#       end
+#
+#       def self._load(str)
+#         instance.keep = Marshal.load(str)
+#         instance
+#       end
+#     end
+#
+#     a = Example.instance
+#     a.keep = "keep this"
+#     a.strip = "get rid of this"
+#
+#     stored_state = Marshal.dump(a)
+#
+#     a.keep = nil
+#     a.strip = nil
+#     b = Marshal.load(stored_state)
+#     p a == b  #  => true
+#     p a.keep  #  => "keep this"
+#     p a.strip #  => nil
+#
+module Singleton
+  def self.__init__: (Class klass) -> Class
+
+  # <!--
+  #   rdoc-file=lib/singleton.rb
+  #   - instance()
+  # -->
+  # Returns the singleton instance.
+  #
+  def self.instance: () -> instance
+
+  # <!--
+  #   rdoc-file=lib/singleton.rb
+  #   - _dump(depth = -1)
+  # -->
+  # By default, do not retain any state when marshalling.
+  #
+  def _dump: (?Integer depth) -> String
+
+  # <!--
+  #   rdoc-file=lib/singleton.rb
+  #   - clone()
+  # -->
+  # Raises a TypeError to prevent cloning.
+  #
+  def clone: () -> bot
+
+  # <!--
+  #   rdoc-file=lib/singleton.rb
+  #   - dup()
+  # -->
+  # Raises a TypeError to prevent duping.
+  #
+  def dup: () -> bot
+
+  module SingletonClassMethods
+  end
+end
+
+Singleton::VERSION: String