rbs 0.9.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '094182e5d2602ec5ba9244068f67f854dfd5aa9c804fe48f2e943934da3e806b'
-  data.tar.gz: bbd2a02e2c79a092f3e3555337aebdb557301fd2dd712bc46bcfaaa3ae4f3ed5
+  metadata.gz: 29535fcd236ba4d658d2c975b5084aa58b125203c4aaa1ec4704881b92ed89c7
+  data.tar.gz: 71e165ea5cb1ccbf1b48e9683201f6058dc7c95c7a7619865bf26af2cb6485ad
 SHA512:
-  metadata.gz: 8de689c6af71a94ef511cd5efc9b64d1277f99256e759ec58ad4185505831e3ca041a8555f454ea6700713a4f03a88caeed2104009b8915b9acf5c8b4e5ba53b
-  data.tar.gz: dec9ab30d0d1261897103b71c7203d3857c2cd4150ef145f3b8f3d005b7ba3f9daa947033a1db37c7f7aaf7530725f9129707d29def747fe9334a75acbcc9a16
+  metadata.gz: 236e10d6a7372a1c9b3c07a343a4620048c3f269f750e74f82539fd819f690475deb52090eec0cf38bc338344d240586f44941339bea7759066f68f90c5a3bdb
+  data.tar.gz: 8ef6ef34e9b39c310f70138135589611c31c8840fdea06eaa606b5004fc5d6634882ddd169b030dd4140645ad9d18c7a4a796a8bba88cd917ea1a69b461efdd1

data/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## master
 
+## 0.10.0 (2020-08-10)
+
+* Signature update for `Zlib`
+* Make "no type checker installed" message a debug print [#363](https://github.com/ruby/rbs/pull/363)
+* Print `...` for overloading method definitions [#362](https://github.com/ruby/rbs/pull/362)
+* Allow missing method implementation in Ruby code [#359](https://github.com/ruby/rbs/pull/359)
+* Runtime testing improvements [#356](https://github.com/ruby/rbs/pull/356)
+
 ## 0.9.1 (2020-08-04)
 
 * Ensure using Module#name [#354](https://github.com/ruby/rbs/pull/354)

data/lib/rbs/definition.rb

@@ -50,11 +50,13 @@ module RBS
       attr_reader :super_method
       attr_reader :defs
       attr_reader :accessibility
+      attr_reader :extra_annotations
 
-      def initialize(super_method:, defs:, accessibility:)
+      def initialize(super_method:, defs:, accessibility:, annotations: [])
         @super_method = super_method
         @defs = defs
         @accessibility = accessibility
+        @extra_annotations = annotations
       end
 
       def defined_in
@@ -74,7 +76,7 @@ module RBS
       end
 
       def annotations
-        @annotations ||= defs.flat_map(&:annotations)
+        @annotations ||= @extra_annotations + defs.flat_map(&:annotations)
       end
 
       # @deprecated

data/lib/rbs/definition_builder.rb

@@ -934,7 +934,8 @@ module RBS
                     implemented_in: nil
                   )
                 end,
-                accessibility: :public
+                accessibility: :public,
+                annotations: [AST::Annotation.new(location: nil, string: "rbs:test:target")]
               )
             end
           end

data/lib/rbs/test/hook.rb

@@ -7,6 +7,7 @@ module RBS
       OPERATORS = {
         :== => "eqeq",
         :=== => "eqeqeq",
+        :!= => "noteq",
         :+ => "plus",
         :- => "minus",
         :* => "star",

data/lib/rbs/test/setup.rb

@@ -58,11 +58,9 @@ TracePoint.trace :end do |tp|
 
   if class_name
     if filter.any? {|f| match(to_absolute_typename(f).to_s, class_name.to_s) } && skips.none? {|f| match(f, class_name.to_s) }
-      unless tester.targets.include?(tp.self)
-        if env.class_decls.key?(class_name)
-          logger.info "Setting up hooks for #{class_name}"
-          tester.install!(tp.self, sample_size: sample_size)
-        end
+      if env.class_decls.key?(class_name)
+        logger.info "Setting up hooks for #{class_name}"
+        tester.install!(tp.self, sample_size: sample_size)
       end
     end
   end
@@ -71,7 +69,7 @@ end
 at_exit do
   if $!.nil? || $!.is_a?(SystemExit) && $!.success?
     if tester.targets.empty?
-      logger.warn "No type checker was installed!"
+      logger.debug { "No type checker was installed!" }
     end
   end
 end

data/lib/rbs/test/tester.rb

@@ -3,10 +3,14 @@ module RBS
     class Tester
       attr_reader :env
       attr_reader :targets
+      attr_reader :instance_testers
+      attr_reader :singleton_testers
 
       def initialize(env:)
         @env = env
         @targets = []
+        @instance_testers = {}
+        @singleton_testers = {}
       end
 
       def factory
@@ -17,6 +21,22 @@ module RBS
         @builder ||= DefinitionBuilder.new(env: env)
       end
 
+      def skip_method?(type_name, method)
+        if method.implemented_in == type_name
+          if method.annotations.any? {|a| a.string == "rbs:test:skip" }
+            :skip
+          else
+            false
+          end
+        else
+          if method.annotations.any? {|a| a.string == "rbs:test:target" }
+            false
+          else
+            :implemented_in
+          end
+        end
+      end
+
       def install!(klass, sample_size:)
         RBS.logger.info { "Installing runtime type checker in #{klass}..." }
 
@@ -24,24 +44,46 @@ module RBS
 
         builder.build_instance(type_name).tap do |definition|
           instance_key = new_key(type_name, "InstanceChecker")
-          Observer.register(instance_key, MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size))
+          tester, set = instance_testers[klass] ||= [
+            MethodCallTester.new(klass, builder, definition, kind: :instance, sample_size: sample_size),
+            Set[]
+          ]
+          Observer.register(instance_key, tester)
 
           definition.methods.each do |name, method|
-            if method.implemented_in == type_name
-              RBS.logger.info { "Setting up method hook in ##{name}..." }
-              Hook.hook_instance_method klass, name, key: instance_key
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping ##{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.instance_methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in ##{name}..." }
+                Hook.hook_instance_method klass, name, key: instance_key
+                set << name
+              end
             end
           end
         end
 
         builder.build_singleton(type_name).tap do |definition|
           singleton_key = new_key(type_name, "SingletonChecker")
-          Observer.register(singleton_key, MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size))
+          tester, set = singleton_testers[klass] ||= [
+            MethodCallTester.new(klass.singleton_class, builder, definition, kind: :singleton, sample_size: sample_size),
+            Set[]
+          ]
+          Observer.register(singleton_key, tester)
 
           definition.methods.each do |name, method|
-            if method.implemented_in == type_name || name == :new
-              RBS.logger.info { "Setting up method hook in .#{name}..." }
-              Hook.hook_singleton_method klass, name, key: singleton_key
+            if reason = skip_method?(type_name, method)
+              unless reason == :implemented_in
+                RBS.logger.info { "Skipping .#{name} because of `#{reason}`..." }
+              end
+            else
+              if klass.methods(false).include?(name) && !set.include?(name)
+                RBS.logger.info { "Setting up method hook in .#{name}..." }
+                Hook.hook_singleton_method klass, name, key: singleton_key
+                set << name
+              end
             end
           end
         end

data/lib/rbs/test/type_check.rb

@@ -5,12 +5,15 @@ module RBS
       attr_reader :builder
       attr_reader :sample_size
 
+      attr_reader :const_cache
+
       DEFAULT_SAMPLE_SIZE = 100
 
       def initialize(self_class:, builder:, sample_size:)
         @self_class = self_class
         @builder = builder
         @sample_size = sample_size
+        @const_cache = {}
       end
 
       def overloaded_call(method, method_name, call, errors:)
@@ -179,8 +182,25 @@ module RBS
         end
       end
 
-      def sample(array)
-        sample_size && (array.size > sample_size) ? array.sample(sample_size) : array
+      def each_sample(array, &block)
+        if block
+          if sample_size && array.size > sample_size
+            if sample_size > 0
+              size = array.size
+              sample_size.times do
+                yield array[rand(size)]
+              end
+            end
+          else
+            array.each(&block)
+          end
+        else
+          enum_for :each_sample, array
+        end
+      end
+
+      def get_class(type_name)
+        const_cache[type_name] ||= Object.const_get(type_name.to_s)
       end
 
       def value(val, type)
@@ -204,17 +224,14 @@ module RBS
         when Types::Bases::Instance
           Test.call(val, IS_AP, self_class)
         when Types::ClassInstance
-          klass = Object.const_get(type.name.to_s)
+          klass = get_class(type.name)
           case
           when klass == ::Array
-            Test.call(val, IS_AP, klass) && sample(val).yield_self do |val|
-              val.all? {|v| value(v, type.args[0]) }
-            end
+            Test.call(val, IS_AP, klass) && each_sample(val).all? {|v| value(v, type.args[0]) }
           when klass == ::Hash
-            Test.call(val, IS_AP, klass) && sample(val.keys).yield_self do |keys|
-              values = val.values_at(*keys)
-              keys.all? {|key| value(key, type.args[0]) } && values.all? {|v| value(v, type.args[1]) }
-            end 
+            Test.call(val, IS_AP, klass) && each_sample(val.keys).all? do |key|
+              value(key, type.args[0]) && value(val[key], type.args[1])
+            end
           when klass == ::Range
             Test.call(val, IS_AP, klass) && value(val.begin, type.args[0]) && value(val.end, type.args[0])
           when klass == ::Enumerator
@@ -235,7 +252,7 @@ module RBS
                 end
               end
 
-              sample(values).all? do |v|
+              each_sample(values).all? do |v|
                 if v.size == 1
                   # Only one block argument.
                   value(v[0], type.args[0]) || value(v, type.args[0])
@@ -253,7 +270,7 @@ module RBS
             Test.call(val, IS_AP, klass)
           end
         when Types::ClassSingleton
-          klass = Object.const_get(type.name.to_s)
+          klass = get_class(type.name)
           val == klass
         when Types::Interface
           methods = Set.new(Test.call(val, METHODS))

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.9.1"
+  VERSION = "0.10.0"
 end

data/lib/rbs/writer.rb

@@ -251,8 +251,7 @@ module RBS
       string = ""
 
       attrs = member.attributes.empty? ? "" : member.attributes.join(" ") + " "
-      overload = member.overload? ? "overload " : ""
-      prefix = "#{overload}#{attrs}def #{name}:"
+      prefix = "#{attrs}def #{name}:"
       padding = " " * (prefix.size-1)
 
       string << prefix
@@ -266,6 +265,12 @@ module RBS
         string << " #{type}\n"
       end
 
+      if member.overload
+        string << padding
+        string << "|"
+        string << " ...\n"
+      end
+
       string.each_line do |line|
         puts line.chomp
       end

data/stdlib/zlib/zlib.rbs

@@ -0,0 +1,392 @@
+# This module provides access to the [zlib library](http://zlib.net). Zlib is
+# designed to be a portable, free, general-purpose, legally unencumbered -- that
+# is, not covered by any patents -- lossless data-compression library for use on
+# virtually any computer hardware and operating system.
+#
+# The zlib compression library provides in-memory compression and decompression
+# functions, including integrity checks of the uncompressed data.
+#
+# The zlib compressed data format is described in RFC 1950, which is a wrapper
+# around a deflate stream which is described in RFC 1951.
+#
+# The library also supports reading and writing files in gzip (.gz) format with
+# an interface similar to that of IO. The gzip format is described in RFC 1952
+# which is also a wrapper around a deflate stream.
+#
+# The zlib format was designed to be compact and fast for use in memory and on
+# communications channels. The gzip format was designed for single-file
+# compression on file systems, has a larger header than zlib to maintain
+# directory information, and uses a different, slower check method than zlib.
+#
+# See your system's zlib.h for further information about zlib
+#
+# ## Sample usage
+#
+# Using the wrapper to compress strings with default parameters is quite simple:
+#
+#     require "zlib"
+#
+#     data_to_compress = File.read("don_quixote.txt")
+#
+#     puts "Input size: #{data_to_compress.size}"
+#     #=> Input size: 2347740
+#
+#     data_compressed = Zlib::Deflate.deflate(data_to_compress)
+#
+#     puts "Compressed size: #{data_compressed.size}"
+#     #=> Compressed size: 887238
+#
+#     uncompressed_data = Zlib::Inflate.inflate(data_compressed)
+#
+#     puts "Uncompressed data is: #{uncompressed_data}"
+#     #=> Uncompressed data is: The Project Gutenberg EBook of Don Quixote...
+#
+# ## Class tree
+#
+# *   Zlib::Deflate
+# *   Zlib::Inflate
+# *   Zlib::ZStream
+# *   Zlib::Error
+#     *   Zlib::StreamEnd
+#     *   Zlib::NeedDict
+#     *   Zlib::DataError
+#     *   Zlib::StreamError
+#     *   Zlib::MemError
+#     *   Zlib::BufError
+#     *   Zlib::VersionError
+#
+#
+#
+# (if you have GZIP_SUPPORT)
+# *   Zlib::GzipReader
+# *   Zlib::GzipWriter
+# *   Zlib::GzipFile
+# *   Zlib::GzipFile::Error
+#     *   Zlib::GzipFile::LengthError
+#     *   Zlib::GzipFile::CRCError
+#     *   Zlib::GzipFile::NoFooter
+#
+#
+#
+module Zlib
+  # Calculates Adler-32 checksum for `string`, and returns updated value of
+  # `adler`. If `string` is omitted, it returns the Adler-32 initial value. If
+  # `adler` is omitted, it assumes that the initial value is given to `adler`.
+  #
+  # Example usage:
+  #
+  #     require "zlib"
+  #
+  #     data = "foo"
+  #     puts "Adler32 checksum: #{Zlib.adler32(data).to_s(16)}"
+  #     #=> Adler32 checksum: 2820145
+  #
+  def self.adler32: () -> Integer
+                  | (String)  -> Integer
+                  | (String, Integer) -> Integer
+
+  # Combine two Adler-32 check values in to one.  `alder1` is the first Adler-32
+  # value, `adler2` is the second Adler-32 value.  `len2` is the length of the
+  # string used to generate `adler2`.
+  #
+  def self.adler32_combine: (Integer, Integer, Integer) -> Integer
+
+  # Calculates CRC checksum for `string`, and returns updated value of `crc`. If
+  # `string` is omitted, it returns the CRC initial value. If `crc` is omitted, it
+  # assumes that the initial value is given to `crc`.
+  #
+  # FIXME: expression.
+  #
+  def self.crc32: () -> Integer
+                | (String) -> Integer
+                | (String, Integer) -> Integer
+
+  # Combine two CRC-32 check values in to one.  `crc1` is the first CRC-32 value,
+  # `crc2` is the second CRC-32 value.  `len2` is the length of the string used to
+  # generate `crc2`.
+  #
+  def self.crc32_combine: (Integer, Integer, Integer) -> Integer
+
+  # Returns the table for calculating CRC checksum as an array.
+  #
+  def self.crc_table: () -> Array[Integer]
+
+  # Compresses the given `string`. Valid values of level are Zlib::NO_COMPRESSION,
+  # Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION, Zlib::DEFAULT_COMPRESSION, or an
+  # integer from 0 to 9.
+  #
+  # This method is almost equivalent to the following code:
+  #
+  #     def deflate(string, level)
+  #       z = Zlib::Deflate.new(level)
+  #       dst = z.deflate(string, Zlib::FINISH)
+  #       z.close
+  #       dst
+  #     end
+  #
+  # See also Zlib.inflate
+  #
+  def self.deflate: (String) -> String
+                  | (String, Integer) -> String
+  # Decode the given gzipped `string`.
+  #
+  # This method is almost equivalent to the following code:
+  #
+  #     def gunzip(string)
+  #       sio = StringIO.new(string)
+  #       gz = Zlib::GzipReader.new(sio, encoding: Encoding::ASCII_8BIT)
+  #       gz.read
+  #     ensure
+  #       gz&.close
+  #     end
+  #
+  # See also Zlib.gzip
+  #
+  def self.gunzip: (String) -> String
+
+  # Gzip the given `string`. Valid values of level are Zlib::NO_COMPRESSION,
+  # Zlib::BEST_SPEED, Zlib::BEST_COMPRESSION, Zlib::DEFAULT_COMPRESSION (default),
+  # or an integer from 0 to 9.
+  #
+  # This method is almost equivalent to the following code:
+  #
+  #     def gzip(string, level: nil, strategy: nil)
+  #       sio = StringIO.new
+  #       sio.binmode
+  #       gz = Zlib::GzipWriter.new(sio, level, strategy)
+  #       gz.write(string)
+  #       gz.close
+  #       sio.string
+  #     end
+  #
+  # See also Zlib.gunzip
+  #
+  def self.gzip: (String) -> String
+               | (String, level: Integer) -> String
+               | (String, strategy: Integer) -> String
+               | (String, level: Integer, strategy: Integer) -> String
+  # Decompresses `string`. Raises a Zlib::NeedDict exception if a preset
+  # dictionary is needed for decompression.
+  #
+  # This method is almost equivalent to the following code:
+  #
+  #     def inflate(string)
+  #       zstream = Zlib::Inflate.new
+  #       buf = zstream.inflate(string)
+  #       zstream.finish
+  #       zstream.close
+  #       buf
+  #     end
+  #
+  # See also Zlib.deflate
+  #
+  def self.inflate: (String) -> String
+
+  # Returns the string which represents the version of zlib library.
+  #
+  def self.zlib_version: () -> String
+end
+
+# Represents text data as guessed by deflate.
+#
+# NOTE: The underlying constant Z_ASCII was deprecated in favor of Z_TEXT in
+# zlib 1.2.2.  New applications should not use this constant.
+#
+# See Zlib::Deflate#data_type.
+#
+#
+Zlib::ASCII: Integer
+
+# Slowest compression level, but with the best space savings.
+#
+#
+Zlib::BEST_COMPRESSION: Integer
+
+# Fastest compression level, but with the lowest space savings.
+#
+#
+Zlib::BEST_SPEED: Integer
+
+# Represents binary data as guessed by deflate.
+#
+# See Zlib::Deflate#data_type.
+#
+#
+Zlib::BINARY: Integer
+
+# Default compression level which is a good trade-off between space and time
+#
+Zlib::DEFAULT_COMPRESSION: Integer
+
+# Default deflate strategy which is used for normal data.
+#
+#
+Zlib::DEFAULT_STRATEGY: Integer
+
+# The default memory level for allocating zlib deflate compression state.
+#
+Zlib::DEF_MEM_LEVEL: Integer
+
+# Deflate strategy for data produced by a filter (or predictor). The effect of
+# FILTERED is to force more Huffman codes and less string matching; it is
+# somewhat intermediate between DEFAULT_STRATEGY and HUFFMAN_ONLY. Filtered data
+# consists mostly of small values with a somewhat random distribution.
+#
+Zlib::FILTERED: Integer
+
+# Processes all pending input and flushes pending output.
+#
+#
+Zlib::FINISH: Integer
+
+# Deflate strategy which prevents the use of dynamic Huffman codes, allowing for
+# a simpler decoder for specialized applications.
+#
+Zlib::FIXED: Integer
+
+# Flushes all output as with SYNC_FLUSH, and the compression state is reset so
+# that decompression can restart from this point if previous compressed data has
+# been damaged or if random access is desired. Like SYNC_FLUSH, using FULL_FLUSH
+# too often can seriously degrade compression.
+#
+Zlib::FULL_FLUSH: Integer
+
+# Deflate strategy which uses Huffman codes only (no string matching).
+#
+#
+Zlib::HUFFMAN_ONLY: Integer
+
+# The maximum memory level for allocating zlib deflate compression state.
+#
+Zlib::MAX_MEM_LEVEL: Integer
+
+# The maximum size of the zlib history buffer.  Note that zlib allows larger
+# values to enable different inflate modes.  See Zlib::Inflate.new for details.
+#
+Zlib::MAX_WBITS: Integer
+
+# No compression, passes through data untouched.  Use this for appending
+# pre-compressed data to a deflate stream.
+#
+Zlib::NO_COMPRESSION: Integer
+
+# NO_FLUSH is the default flush method and allows deflate to decide how much
+# data to accumulate before producing output in order to maximize compression.
+#
+Zlib::NO_FLUSH: Integer
+
+# OS code for Amiga hosts
+#
+#
+Zlib::OS_AMIGA: Integer
+
+# OS code for Atari hosts
+#
+#
+Zlib::OS_ATARI: Integer
+
+# The OS code of current host
+#
+#
+Zlib::OS_CODE: Integer
+
+# OS code for CP/M hosts
+#
+#
+Zlib::OS_CPM: Integer
+
+# OS code for Mac OS hosts
+#
+#
+Zlib::OS_MACOS: Integer
+
+# OS code for MSDOS hosts
+#
+#
+Zlib::OS_MSDOS: Integer
+
+# OS code for OS2 hosts
+#
+#
+Zlib::OS_OS2: Integer
+
+# OS code for QDOS hosts
+#
+#
+Zlib::OS_QDOS: Integer
+
+# OS code for RISC OS hosts
+#
+#
+Zlib::OS_RISCOS: Integer
+
+# OS code for TOPS-20 hosts
+#
+#
+Zlib::OS_TOPS20: Integer
+
+# OS code for UNIX hosts
+#
+#
+Zlib::OS_UNIX: Integer
+
+# OS code for unknown hosts
+#
+#
+Zlib::OS_UNKNOWN: Integer
+
+# OS code for VM OS hosts
+#
+#
+Zlib::OS_VMCMS: Integer
+
+# OS code for VMS hosts
+#
+#
+Zlib::OS_VMS: Integer
+
+# OS code for Win32 hosts
+#
+#
+Zlib::OS_WIN32: Integer
+
+# OS code for Z-System hosts
+#
+#
+Zlib::OS_ZSYSTEM: Integer
+
+# Deflate compression strategy designed to be almost as fast as HUFFMAN_ONLY,
+# but give better compression for PNG image data.
+#
+Zlib::RLE: Integer
+
+# The SYNC_FLUSH method flushes all pending output to the output buffer and the
+# output is aligned on a byte boundary. Flushing may degrade compression so it
+# should be used only when necessary, such as at a request or response boundary
+# for a network stream.
+#
+Zlib::SYNC_FLUSH: Integer
+
+# Represents text data as guessed by deflate.
+#
+# See Zlib::Deflate#data_type.
+#
+#
+Zlib::TEXT: Integer
+
+# Represents an unknown data type as guessed by deflate.
+#
+# See Zlib::Deflate#data_type.
+#
+#
+Zlib::UNKNOWN: Integer
+
+# The Ruby/zlib version string.
+#
+#
+Zlib::VERSION: String
+
+# The string which represents the version of zlib.h
+#
+#
+Zlib::ZLIB_VERSION: String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbs
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2020-08-10 00:00:00.000000000 Z
 dependencies: []
 description: RBS is the language for type signatures for Ruby and standard library
   definitions.
@@ -174,6 +174,7 @@ files:
 - stdlib/securerandom/securerandom.rbs
 - stdlib/set/set.rbs
 - stdlib/tmpdir/tmpdir.rbs
+- stdlib/zlib/zlib.rbs
 homepage: https://github.com/ruby/rbs
 licenses:
 - BSD-2-Clause