rbs 0.5.0 → 0.9.1

data/stdlib/logger/period.rbs

@@ -0,0 +1,7 @@
+module Logger::Period
+  def self?.next_rotate_time: (Time now, String shift_age) -> untyped
+
+  def self?.previous_period_end: (Time now, String shift_age) -> untyped
+
+  SiD: Integer
+end

data/stdlib/logger/severity.rbs

@@ -0,0 +1,8 @@
+module Logger::Severity
+  DEBUG: 0
+  INFO: 1
+  WARN: 2
+  ERROR: 3
+  FATAL: 4
+  UNKNOWN: 5
+end

data/stdlib/pty/pty.rbs

@@ -0,0 +1,159 @@
+# Creates and manages pseudo terminals (PTYs).  See also
+# http://en.wikipedia.org/wiki/Pseudo_terminal
+#
+# PTY allows you to allocate new terminals using ::open or ::spawn a new
+# terminal with a specific command.
+#
+# ## Example
+#
+# In this example we will change the buffering type in the `factor` command,
+# assuming that factor uses stdio for stdout buffering.
+#
+# If IO.pipe is used instead of PTY.open, this code deadlocks because factor's
+# stdout is fully buffered.
+#
+#     # start by requiring the standard library PTY
+#     require 'pty'
+#
+#     master, slave = PTY.open
+#     read, write = IO.pipe
+#     pid = spawn("factor", :in=>read, :out=>slave)
+#     read.close     # we dont need the read
+#     slave.close    # or the slave
+#
+#     # pipe "42" to the factor command
+#     write.puts "42"
+#     # output the response from factor
+#     p master.gets #=> "42: 2 3 7\n"
+#
+#     # pipe "144" to factor and print out the response
+#     write.puts "144"
+#     p master.gets #=> "144: 2 2 2 2 3 3\n"
+#     write.close # close the pipe
+#
+#     # The result of read operation when pty slave is closed is platform
+#     # dependent.
+#     ret = begin
+#             master.gets     # FreeBSD returns nil.
+#           rescue Errno::EIO # GNU/Linux raises EIO.
+#             nil
+#           end
+#     p ret #=> nil
+#
+# ## License
+#
+#     C) Copyright 1998 by Akinori Ito.
+#
+#     This software may be redistributed freely for this purpose, in full
+#     or in part, provided that this entire copyright notice is included
+#     on any copies of this software and applications and derivations thereof.
+#
+#     This software is provided on an "as is" basis, without warranty of any
+#     kind, either expressed or implied, as to any matter including, but not
+#     limited to warranty of fitness of purpose, or merchantability, or
+#     results obtained from use of this software.
+#
+module PTY
+  # Checks the status of the child process specified by `pid`. Returns `nil` if
+  # the process is still alive.
+  #
+  # If the process is not alive, and `raise` was true, a PTY::ChildExited
+  # exception will be raised. Otherwise it will return a Process::Status instance.
+  #
+  # `pid`
+  # :   The process id of the process to check
+  # `raise`
+  # :   If `true` and the process identified by `pid` is no longer alive a
+  #     PTY::ChildExited is raised.
+  def self.check: (Integer pid) -> (Process::Status | nil)
+                | (Integer pid, FalseClass raise) -> (Process::Status | nil)
+                | (Integer pid, TrueClass raise) -> nil
+
+  # Spawns the specified command on a newly allocated pty. You can also use the
+  # alias ::getpty.
+  #
+  # The command's controlling tty is set to the slave device of the pty and its
+  # standard input/output/error is redirected to the slave device.
+  #
+  # `command` and `command_line` are the full commands to run, given a String. Any
+  # additional `arguments` will be passed to the command.
+  #
+  # ### Return values
+  #
+  # In the non-block form this returns an array of size three, `[r, w, pid]`.
+  #
+  # In the block form these same values will be yielded to the block:
+  #
+  # `r`
+  # :   A readable IO that contains the command's standard output and standard
+  #     error
+  # `w`
+  # :   A writable IO that is the command's standard input
+  # `pid`
+  # :   The process identifier for the command.
+  def self.getpty: (*String command) -> [ IO, IO, Integer ]
+                 | (*String command) { ([ IO ,IO , Integer ]) -> untyped } -> untyped
+
+  # Allocates a pty (pseudo-terminal).
+  #
+  # In the block form, yields two arguments `master_io, slave_file` and the value
+  # of the block is returned from `open`.
+  #
+  # The IO and File are both closed after the block completes if they haven't been
+  # already closed.
+  #
+  #     PTY.open {|master, slave|
+  #       p master      #=> #<IO:masterpty:/dev/pts/1>
+  #       p slave      #=> #<File:/dev/pts/1>
+  #       p slave.path #=> "/dev/pts/1"
+  #     }
+  #
+  # In the non-block form, returns a two element array, `[master_io, slave_file]`.
+  #
+  #     master, slave = PTY.open
+  #     # do something with master for IO, or the slave file
+  #
+  # The arguments in both forms are:
+  #
+  # `master_io`
+  # :   the master of the pty, as an IO.
+  # `slave_file`
+  # :   the slave of the pty, as a File.  The path to the terminal device is
+  #     available via `slave_file.path`
+  #
+  #
+  # IO#raw! is usable to disable newline conversions:
+  #
+  #     require 'io/console'
+  #     PTY.open {|m, s|
+  #       s.raw!
+  #       ...
+  #     }
+  def self.open: () -> [ IO, File ]
+               | () { ([ IO , File ]) -> untyped } -> untyped
+
+  # Spawns the specified command on a newly allocated pty. You can also use the
+  # alias ::getpty.
+  #
+  # The command's controlling tty is set to the slave device of the pty and its
+  # standard input/output/error is redirected to the slave device.
+  #
+  # `command` and `command_line` are the full commands to run, given a String. Any
+  # additional `arguments` will be passed to the command.
+  #
+  # ### Return values
+  #
+  # In the non-block form this returns an array of size three, `[r, w, pid]`.
+  #
+  # In the block form these same values will be yielded to the block:
+  #
+  # `r`
+  # :   A readable IO that contains the command's standard output and standard
+  #     error
+  # `w`
+  # :   A writable IO that is the command's standard input
+  # `pid`
+  # :   The process identifier for the command.
+  def self.spawn: (*String command) -> [ IO, IO, Integer ]
+                | (*String command) {([ IO , IO , Integer ]) -> untyped } -> untyped
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-03 00:00:00.000000000 Z
+date: 2020-08-04 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -41,6 +41,7 @@ files:
 - docs/stdlib.md
 - docs/syntax.md
 - exe/rbs
+- goodcheck.yml
 - lib/rbs.rb
 - lib/rbs/ast/annotation.rb
 - lib/rbs/ast/comment.rb
@@ -57,6 +58,7 @@ files:
 - lib/rbs/environment_loader.rb
 - lib/rbs/environment_walker.rb
 - lib/rbs/errors.rb
+- lib/rbs/factory.rb
 - lib/rbs/location.rb
 - lib/rbs/method_type.rb
 - lib/rbs/namespace.rb
@@ -69,9 +71,11 @@ files:
 - lib/rbs/test.rb
 - lib/rbs/test/errors.rb
 - lib/rbs/test/hook.rb
+- lib/rbs/test/observer.rb
 - lib/rbs/test/setup.rb
+- lib/rbs/test/setup_helper.rb
 - lib/rbs/test/spy.rb
-- lib/rbs/test/test_helper.rb
+- lib/rbs/test/tester.rb
 - lib/rbs/test/type_check.rb
 - lib/rbs/type_name.rb
 - lib/rbs/type_name_resolver.rb
@@ -157,10 +161,16 @@ files:
 - stdlib/find/find.rbs
 - stdlib/ipaddr/ipaddr.rbs
 - stdlib/json/json.rbs
+- stdlib/logger/formatter.rbs
+- stdlib/logger/log_device.rbs
+- stdlib/logger/logger.rbs
+- stdlib/logger/period.rbs
+- stdlib/logger/severity.rbs
 - stdlib/mutex_m/mutex_m.rbs
 - stdlib/pathname/pathname.rbs
 - stdlib/prime/integer-extension.rbs
 - stdlib/prime/prime.rbs
+- stdlib/pty/pty.rbs
 - stdlib/securerandom/securerandom.rbs
 - stdlib/set/set.rbs
 - stdlib/tmpdir/tmpdir.rbs

data/lib/rbs/test/test_helper.rb

@@ -1,180 +0,0 @@
-module RBS
-  module Test
-    module TypeAssertions
-      module ClassMethods
-        attr_reader :target
-
-        def library(*libs)
-          @libs = libs
-          @env = nil
-          @target = nil
-        end
-
-        def env
-          @env ||= begin
-                     loader = RBS::EnvironmentLoader.new
-                     (@libs || []).each do |lib|
-                       loader.add library: lib
-                     end
-
-                     RBS::Environment.from_loader(loader).resolve_type_names
-                   end
-        end
-
-        def builder
-          @builder ||= DefinitionBuilder.new(env: env)
-        end
-
-        def testing(type_or_string)
-          type = case type_or_string
-                 when String
-                   RBS::Parser.parse_type(type_or_string, variables: [])
-                 else
-                   type_or_string
-                 end
-
-          definition = case type
-                       when Types::ClassInstance
-                         builder.build_instance(type.name)
-                       when Types::ClassSingleton
-                         builder.build_singleton(type.name)
-                       else
-                         raise "Test target should be class instance or class singleton: #{type}"
-                       end
-
-          @target = [type, definition]
-        end
-      end
-
-      def self.included(base)
-        base.extend ClassMethods
-      end
-
-      def env
-        self.class.env
-      end
-
-      def builder
-        self.class.builder
-      end
-
-      def targets
-        @targets ||= []
-      end
-
-      def target
-        targets.last || self.class.target
-      end
-
-      def testing(type_or_string)
-        type = case type_or_string
-               when String
-                 RBS::Parser.parse_type(type_or_string, variables: [])
-               else
-                 type_or_string
-               end
-
-        definition = case type
-                     when Types::ClassInstance
-                       builder.build_instance(type.name)
-                     when Types::ClassSingleton
-                       builder.build_singleton(type.name)
-                     else
-                       raise "Test target should be class instance or class singleton: #{type}"
-                     end
-
-        targets.push [type, definition]
-
-        if block_given?
-          begin
-            yield
-          ensure
-            targets.pop
-          end
-        else
-          [type, definition]
-        end
-      end
-
-      ruby2_keywords def assert_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }, "Call trace does not match with given method type: #{trace.last.inspect}"
-
-        type, definition = target
-        method_types = case
-                       when definition.instance_type?
-                         subst = Substitution.build(definition.type_params, type.args)
-                         definition.methods[method].method_types.map do |method_type|
-                           method_type.sub(subst)
-                         end
-                       when definition.class_type?
-                         definition.methods[method].method_types
-                       end
-
-        all_errors = method_types.map {|t| typecheck.method_call(method, t, trace.last, errors: []) }
-        assert all_errors.any? {|es| es.empty? }, "Call trace does not match one of method definitions:\n  #{trace.last.inspect}\n  #{method_types.join(" | ")}"
-
-        if exception
-          raise exception
-        end
-      end
-
-      ruby2_keywords def refute_send_type(method_type, receiver, method, *args, &block)
-        trace = []
-        spy = Spy.wrap(receiver, method)
-        spy.callback = -> (result) { trace << result }
-
-        exception = nil
-        begin
-          spy.wrapped_object.__send__(method, *args, &block)
-        rescue Exception => exn
-          exception = exn
-        end
-
-        mt = case method_type
-             when String
-               RBS::Parser.parse_method_type(method_type, variables: [])
-             when RBS::MethodType
-               method_type
-             end
-
-        mt = mt.update(block: if mt.block
-                                MethodType::Block.new(
-                                  type: mt.block.type.with_return_type(Types::Bases::Any.new(location: nil)),
-                                  required: mt.block.required
-                                )
-                              end,
-                       type: mt.type.with_return_type(Types::Bases::Any.new(location: nil)))
-
-        typecheck = TypeCheck.new(self_class: receiver.class, builder: builder)
-        errors = typecheck.method_call(method, mt, trace.last, errors: [])
-
-        assert_operator exception, :is_a?, ::Exception
-        assert_empty errors.map {|x| RBS::Test::Errors.to_string(x) }
-
-        exception
-      end
-    end
-  end
-end