steep 0.15.0 → 0.16.0

data/vendor/ruby-signature/stdlib/json/json.rbs

@@ -0,0 +1,335 @@
+interface _ToJson
+  def to_json: (?JSON::State state) -> String
+end
+
+interface _JsonToWritableIO
+  def to_io: () -> _JsonWrite
+end
+
+interface _JsonWrite
+  def write: (String json) -> void
+end
+
+interface _JsonReadableIO
+  def to_io: () -> _JsonRead
+end
+
+interface _JsonRead
+  def read: () -> string
+end
+
+type json_options = Hash[Symbol, untyped]
+
+class JSON::State
+end
+
+# This module holds all the modules/classes that implement JSON's functionality
+# as C extensions.
+#
+module JSON::Ext
+end
+
+# This is the JSON generator implemented as a C extension. It can be configured
+# to be used by setting
+#
+#     JSON.generator = JSON::Ext::Generator
+#
+# with the method generator= in JSON.
+#
+module JSON::Ext::Generator
+end
+
+class JSON::Ext::Generator::State
+end
+
+module JSON::Pure
+end
+
+module JSON::Pure::Generator
+end
+
+class JSON::Pure::Generator::State
+end
+
+type json_generator = singleton(::JSON::Ext::Generator) | singleton(::JSON::Pure::Generator)
+type json_parser = singleton(::JSON::Ext::Parser) | singleton(::JSON::Pure::Parser)
+type json_state = singleton(JSON::Ext::Generator::State) | singleton(JSON::Pure::Generator::State)
+
+# # JavaScript Object Notation (JSON)
+#
+# JSON is a lightweight data-interchange format. It is easy for us humans to
+# read and write. Plus, equally simple for machines to generate or parse. JSON
+# is completely language agnostic, making it the ideal interchange format.
+#
+# Built on two universally available structures:
+#     1. A collection of name/value pairs. Often referred to as an _object_, hash table, record, struct, keyed list, or associative array.
+#     2. An ordered list of values. More commonly called an _array_, vector, sequence or list.
+#
+# To read more about JSON visit: http://json.org
+#
+# ## Parsing JSON
+#
+# To parse a JSON string received by another application or generated within
+# your existing application:
+#
+#     require 'json'
+#
+#     my_hash = JSON.parse('{"hello": "goodbye"}')
+#     puts my_hash["hello"] => "goodbye"
+#
+# Notice the extra quotes `''` around the hash notation. Ruby expects the
+# argument to be a string and can't convert objects like a hash or array.
+#
+# Ruby converts your string into a hash
+#
+# ## Generating JSON
+#
+# Creating a JSON string for communication or serialization is just as simple.
+#
+#     require 'json'
+#
+#     my_hash = {:hello => "goodbye"}
+#     puts JSON.generate(my_hash) => "{\"hello\":\"goodbye\"}"
+#
+# Or an alternative way:
+#
+#     require 'json'
+#     puts {:hello => "goodbye"}.to_json => "{\"hello\":\"goodbye\"}"
+#
+# `JSON.generate` only allows objects or arrays to be converted to JSON syntax.
+# `to_json`, however, accepts many Ruby classes even though it acts only as a
+# method for serialization:
+#
+#     require 'json'
+#
+#     1.to_json => "1"
+#
+module JSON
+  # If *object* is string-like, parse the string and return the parsed result as a
+  # Ruby data structure. Otherwise generate a JSON text from the Ruby data
+  # structure object and return it.
+  #
+  # The *opts* argument is passed through to generate/parse respectively. See
+  # generate and parse for their documentation.
+  #
+  def self.[]: (untyped object, ?json_options opts) -> untyped
+
+  # This is create identifier, which is used to decide if the *json_create* hook
+  # of a class should be called. It defaults to 'json_class'.
+  #
+  def self.create_id: () -> _ToS
+
+  def self.create_id=: (_ToS create_id) -> _ToS
+
+  def self.deep_const_get: (_ToS path) -> untyped
+  # Dumps *obj* as a JSON string, i.e. calls generate on the object and returns
+  # the result.
+  #
+  # If anIO (an IO-like object or an object that responds to the write method) was
+  # given, the resulting JSON is written to it.
+  #
+  # If the number of nested arrays or objects exceeds *limit*, an ArgumentError
+  # exception is raised. This argument is similar (but not exactly the same!) to
+  # the *limit* argument in Marshal.dump.
+  #
+  # The default options for the generator can be changed via the
+  # dump_default_options method.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  #
+  def self?.dump: (_ToJson obj, ?Integer limit) -> String
+                | (_ToJson obj, _JsonToWritableIO anIO) -> _JsonWrite
+                | (_ToJson obj, _JsonWrite anIO, ?Integer limit) -> _JsonWrite
+
+  # The global default options for the JSON.dump method:
+  #     :max_nesting: false
+  #     :allow_nan: true
+  #     :allow_blank: true
+  #
+  def self.dump_default_options: () -> json_options
+
+  def self.dump_default_options=: (json_options) -> json_options
+
+  # Generate a JSON document from the Ruby data structure *obj* and return it.
+  # This method disables the checks for circles in Ruby objects.
+  #
+  # **WARNING**: Be careful not to pass any Ruby data structures with circles as
+  # *obj* argument because this will cause JSON to go into an infinite loop.
+  #
+  def self?.fast_generate: (_ToJson obj, ?json_options opts) -> String
+
+  alias self.fast_unparse self.fast_generate
+  alias fast_unparse fast_generate
+
+  # Generate a JSON document from the Ruby data structure *obj* and return it.
+  # *state* is * a JSON::State object,
+  # *   or a Hash like object (responding to to_hash),
+  # *   an object convertible into a hash by a to_h method,
+  #
+  # that is used as or to configure a State object.
+  #
+  # It defaults to a state object, that creates the shortest possible JSON text in
+  # one line, checks for circular data structures and doesn't allow NaN, Infinity,
+  # and -Infinity.
+  #
+  # A *state* hash can have the following keys:
+  # *   **indent**: a string used to indent levels (default: ''),
+  # *   **space**: a string that is put after, a : or , delimiter (default: ''),
+  # *   **space_before**: a string that is put before a : pair delimiter (default:
+  #     ''),
+  # *   **object_nl**: a string that is put at the end of a JSON object (default:
+  #     ''),
+  # *   **array_nl**: a string that is put at the end of a JSON array (default:
+  #     ''),
+  # *   **allow_nan**: true if NaN, Infinity, and -Infinity should be generated,
+  #     otherwise an exception is thrown if these values are encountered. This
+  #     options defaults to false.
+  # *   **max_nesting**: The maximum depth of nesting allowed in the data
+  #     structures from which JSON is to be generated. Disable depth checking with
+  #     :max_nesting => false, it defaults to 100.
+  #
+  #
+  # See also the fast_generate for the fastest creation method with the least
+  # amount of sanity checks, and the pretty_generate method for some defaults for
+  # pretty output.
+  #
+  def self?.generate: (_ToJson obj, ?json_options opts) -> String
+
+  # Returns the JSON generator module that is used by JSON. This is either
+  # JSON::Ext::Generator or JSON::Pure::Generator.
+  #
+  def self.generator: () -> json_generator
+
+  def self.generator=: (json_generator generator) -> void
+
+  # Encodes string using Ruby's *String.encode*
+  #
+  def self.iconv: (encoding to, encoding from, String string) -> String
+
+  # Load a ruby data structure from a JSON *source* and return it. A source can
+  # either be a string-like object, an IO-like object, or an object responding to
+  # the read method. If *proc* was given, it will be called with any nested Ruby
+  # object as an argument recursively in depth first order. To modify the default
+  # options pass in the optional *options* argument as well.
+  #
+  # BEWARE: This method is meant to serialise data from trusted user input, like
+  # from your own database server or clients under your control, it could be
+  # dangerous to allow untrusted users to pass JSON sources into it. The default
+  # options for the parser can be changed via the load_default_options method.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  #
+  def self?.load: (string | _JsonReadableIO | _JsonRead source, ?Proc proc, ?json_options options) -> untyped
+
+  # The global default options for the JSON.load method:
+  #     :max_nesting: false
+  #     :allow_nan: true
+  #     :allow_blank: true
+  #
+  def self.load_default_options: () -> json_options
+
+  def self.load_default_options=: (json_options) -> json_options
+
+  # Parse the JSON document *source* into a Ruby data structure and return it.
+  #
+  # *opts* can have the following keys:
+  # *   **max_nesting**: The maximum depth of nesting allowed in the parsed data
+  #     structures. Disable depth checking with :max_nesting => false. It defaults
+  #     to 100.
+  # *   **allow_nan**: If set to true, allow NaN, Infinity and -Infinity in
+  #     defiance of RFC 7159 to be parsed by the Parser. This option defaults to
+  #     false.
+  # *   **symbolize_names**: If set to true, returns symbols for the names (keys)
+  #     in a JSON object. Otherwise strings are returned. Strings are the default.
+  # *   **create_additions**: If set to false, the Parser doesn't create additions
+  #     even if a matching class and create_id was found. This option defaults to
+  #     false.
+  # *   **object_class**: Defaults to Hash
+  # *   **array_class**: Defaults to Array
+  #
+  #
+  def self?.parse: (string source, ?json_options opts) -> untyped
+
+  # Parse the JSON document *source* into a Ruby data structure and return it. The
+  # bang version of the parse method defaults to the more dangerous values for the
+  # *opts* hash, so be sure only to parse trusted *source* documents.
+  #
+  # *opts* can have the following keys:
+  # *   **max_nesting**: The maximum depth of nesting allowed in the parsed data
+  #     structures. Enable depth checking with :max_nesting => anInteger. The
+  #     parse! methods defaults to not doing max depth checking: This can be
+  #     dangerous if someone wants to fill up your stack.
+  # *   **allow_nan**: If set to true, allow NaN, Infinity, and -Infinity in
+  #     defiance of RFC 7159 to be parsed by the Parser. This option defaults to
+  #     true.
+  # *   **create_additions**: If set to false, the Parser doesn't create additions
+  #     even if a matching class and create_id was found. This option defaults to
+  #     false.
+  #
+  #
+  def self?.parse!: (string source, ?json_options opts) -> untyped
+
+  # Returns the JSON parser class that is used by JSON. This is either
+  # JSON::Ext::Parser or JSON::Pure::Parser.
+  #
+  def self.parser: () -> json_parser
+
+  def self.parser=: (json_parser parser) -> void
+
+  # Generate a JSON document from the Ruby data structure *obj* and return it. The
+  # returned document is a prettier form of the document returned by #unparse.
+  #
+  # The *opts* argument can be used to configure the generator. See the generate
+  # method for a more detailed explanation.
+  #
+  def self?.pretty_generate: (_ToJson obj, ?json_options opts) -> untyped
+
+  alias self.pretty_unparse self.pretty_generate
+  alias pretty_unparse pretty_generate
+
+  # Recursively calls passed *Proc* if the parsed data structure is an *Array* or
+  # *Hash*
+  #
+  def self?.recurse_proc: (untyped result) { (*untyped) -> void } -> void
+
+  alias self.restore self.load
+  alias restore load
+
+  # Returns the JSON generator state class that is used by JSON. This is either
+  # JSON::Ext::Generator::State or JSON::Pure::Generator::State.
+  #
+  def self.state: () -> json_state
+
+  def self.state=: (json_state) -> json_state
+
+  alias self.unparse self.generate
+  alias unparse generate
+end
+
+JSON::FAST_STATE_PROTOTYPE: json_state
+
+JSON::Infinity: Float
+
+JSON::JSON_LOADED: bool
+
+JSON::MinusInfinity: Float
+
+JSON::NaN: Float
+
+JSON::PRETTY_STATE_PROTOTYPE: json_state
+
+JSON::SAFE_STATE_PROTOTYPE: json_state
+
+# JSON version
+#
+JSON::VERSION: String
+
+JSON::VERSION_ARRAY: Array
+
+JSON::VERSION_BUILD: Integer
+
+JSON::VERSION_MAJOR: Integer
+
+JSON::VERSION_MINOR: Integer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: steep
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.16.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-05 00:00:00.000000000 Z
+date: 2020-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -190,14 +190,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0.1
+        version: 3.14.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.14.0.1
+        version: 3.14.0.2
 description: Gradual Typing for Ruby
 email:
 - matsumoto@soutaro.com
@@ -263,6 +263,7 @@ files:
 - lib/steep/drivers/validate.rb
 - lib/steep/drivers/vendor.rb
 - lib/steep/drivers/watch.rb
+- lib/steep/drivers/worker.rb
 - lib/steep/errors.rb
 - lib/steep/interface/interface.rb
 - lib/steep/interface/method.rb
@@ -277,6 +278,13 @@ files:
 - lib/steep/project/hover_content.rb
 - lib/steep/project/options.rb
 - lib/steep/project/target.rb
+- lib/steep/server/base_worker.rb
+- lib/steep/server/code_worker.rb
+- lib/steep/server/interaction_worker.rb
+- lib/steep/server/master.rb
+- lib/steep/server/signature_worker.rb
+- lib/steep/server/utils.rb
+- lib/steep/server/worker_process.rb
 - lib/steep/signature/errors.rb
 - lib/steep/signature/validator.rb
 - lib/steep/source.rb
@@ -552,6 +560,7 @@ files:
 - vendor/ruby-signature/stdlib/erb/erb.rbs
 - vendor/ruby-signature/stdlib/find/find.rbs
 - vendor/ruby-signature/stdlib/ipaddr/ipaddr.rbs
+- vendor/ruby-signature/stdlib/json/json.rbs
 - vendor/ruby-signature/stdlib/pathname/pathname.rbs
 - vendor/ruby-signature/stdlib/prime/integer-extension.rbs
 - vendor/ruby-signature/stdlib/prime/prime.rbs
@@ -577,7 +586,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Gradual Typing for Ruby