strong_json 2.1.0 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7ff37c821f98f3d174d49ea2af07864e90ac844be26229647abda379b2f80f9
-  data.tar.gz: '05592b56d071c4eac6122667a432bfcfaf29559a10ccb854f12f450039c2b680'
+  metadata.gz: d1118cf0a2239601909e8d3af33e2b7d2809c8baccae8a0a77b2f2c6fdc814a1
+  data.tar.gz: 39a6fe29b3383722be668af971c9a78b8719dee1bb8b7e2fe1eb06ce8fe1f5f4
 SHA512:
-  metadata.gz: c79a051b24b4fd914629974c67d5aaecf32ad31f65fcda56a5da70f8cb00f7cea89ca9cf4e310b796f6f13d347c39184d0daa63c15b695af92e7160f01719ed4
-  data.tar.gz: 1f66d80fe299618161438fa17f5632106a94b5e569e85da2fc82b1b8c38853a7eaaa0e46a19253fb0a5cc31b22356cb5921db120f3f51c78652750793e2ef0ba
+  metadata.gz: bc54d705a3b26803caed812795525e64c2a08260be22c1d14e48f9e47e897b3b60acf4f256eb3ce846fb1c9afda0ed3f019d0a2932827bbfa2ec0fb65931eecb
+  data.tar.gz: 40bc0d295723533e3ed0e86f77af4b70f26e7fce0fd12498ef14cb906ea28b549b50825021a6421d702a3cd956ef1cec7d9353073124b7859380c1906793a830

data/.ruby-version

@@ -1 +1 @@
-2.5.1
+2.6.3

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 2.1.1 (2020-05-16)
+
+* [24](https://github.com/soutaro/strong_json/pull/24): Ship with RBS
+
 ## 2.1.0 (2019-07-19)
 
 * [20](https://github.com/soutaro/strong_json/pull/20): Add `integer` type

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in strong_json.gemspec
 gemspec
+
+gem "steep", path: "../steep"

data/README.md

@@ -47,7 +47,7 @@ If the input JSON data conforms to `order`'s structure, the `json` will be that
 
 If the input JSON contains attributes which is not white-listed in the definition, it will raise an exception.
 
-If an attribute has a value which does not match with given type, the `coerce` method call will raise an exception `StrongJSON::Type::Error`.
+If an attribute has a value which does not match with given type, the `coerce` method call will raise an exception `StrongJSON::Type::TypeError`.
 
 ## Catalogue of Types
 

data/Rakefile

@@ -6,11 +6,11 @@ RSpec::Core::RakeTask.new(:spec)
 task :default => [:spec, :typecheck, :"example:typecheck"]
 
 task :typecheck do
-  sh "bundle exec steep check --strict lib"
+  sh "bundle exec steep check"
 end
 
 namespace :example do
   task :typecheck do
-    sh "bundle exec steep check --strict -I sig -I example example"
+    sh "bundle exec steep check --steepfile=example/Steepfile"
   end
 end

data/Steepfile

@@ -0,0 +1,7 @@
+target :lib do
+  signature "sig"
+
+  check "lib"
+
+  library "set"
+end

data/example/Steepfile

@@ -0,0 +1,8 @@
+target :app do
+  signature "sig"
+  signature "../sig"
+
+  check "lib"
+
+  library "set"
+end

data/example/{example.rb → lib/example.rb}

@@ -12,7 +12,7 @@ person = Schema.person.coerce(nil)
 # @type var name: String
 name = person[:name]
 
-# @type var contacts: Array<email | address>
+# @type var contacts: Array[email | address]
 contacts = person[:contacts]
 
 contacts.each do |contact|

data/example/sig/example.rbs

@@ -0,0 +1,11 @@
+type address = { address: String, country: Symbol? }
+type email = { email: String }
+
+class AddressSchema < StrongJSON
+  def address: -> StrongJSON::Type::Object[address]
+  def email: -> StrongJSON::Type::Object[email]
+  def contact: -> StrongJSON::Type::Object[email | address]
+  def person: -> StrongJSON::Type::Object[{ name: String, contacts: Array[email | address] }]
+end
+
+Schema: AddressSchema

data/lib/strong_json/error_reporter.rb

@@ -18,7 +18,7 @@ class StrongJSON
       format_trace(path: path)
       where = format_aliases(path: path, where: [])
 
-      # @type var ty: Type::Enum<any>
+      # @type var ty: Type::Enum[untyped]
       if (ty = _ = path.type).is_a?(Type::Enum)
         ty.types.each do |t|
           if (a = t.alias)
@@ -67,7 +67,7 @@ class StrongJSON
     end
 
     def format_single_alias(name, type)
-      # @type const PrettyPrint: any
+      # @type const PrettyPrint: untyped
       PrettyPrint.format do |pp|
         pp.text(name.to_s)
         pp.text(" = ")
@@ -78,7 +78,7 @@ class StrongJSON
     end
 
     def pretty_str(type, expand_alias: false)
-      # @type const PrettyPrint: any
+      # @type const PrettyPrint: untyped
       PrettyPrint.singleline_format do |pp|
         pretty(type, pp, expand_alias: expand_alias)
       end

data/lib/strong_json/type.rb

@@ -20,7 +20,7 @@ class StrongJSON
 
       def with_alias(name)
         _ = dup.tap do |copy|
-          copy.instance_eval do
+          copy.instance_eval do |x|
             @alias = name
           end
         end
@@ -76,7 +76,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Base)
-          # @type var other: Base<any>
           other.type == type
         end
       end
@@ -111,7 +110,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Optional)
-          # @type var other: Optional<any>
           other.type == type
         end
       end
@@ -143,7 +141,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Literal)
-          # @type var other: Literal<any>
           other.value == value
         end
       end
@@ -180,7 +177,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Array)
-          # @type var other: Array<any>
           other.type == type
         end
       end
@@ -230,7 +226,7 @@ class StrongJSON
           end
         end
 
-        # @type var result: ::Hash<Symbol, any>
+        # @type var result: ::Hash[Symbol, untyped]
         result = {}
 
         fields.each do |key, type|
@@ -240,7 +236,6 @@ class StrongJSON
         _ = result
       end
 
-      # @type method ignore: (*Symbol, ?except: Set<Symbol>?) -> self
       def ignore(*ignores, except: nil)
         if ignores.empty? && !except
           Object.new(fields, on_unknown: :ignore, exceptions: Set[])
@@ -253,7 +248,6 @@ class StrongJSON
         end
       end
 
-      # @type method reject: (*Symbol, ?except: Set<Symbol>?) -> self
       def reject(*rejecteds, except: nil)
         if rejecteds.empty? && !except
           Object.new(fields, on_unknown: :reject, exceptions: Set[])
@@ -284,7 +278,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Object)
-          # @type var other: Object<any>
           other.fields == fields &&
             other.on_unknown == on_unknown &&
             other.exceptions == exceptions
@@ -333,7 +326,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Enum)
-          # @type var other: Enum<any>
           other.types == types &&
             other.detector == detector
         end
@@ -369,7 +361,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Hash)
-          # @type var other: Hash<any>
           other.type == type
         end
       end

data/lib/strong_json/types.rb

@@ -1,6 +1,5 @@
 class StrongJSON
   module Types
-    # @type method object: (?Hash<Symbol, ty>) -> Type::Object<any>
     def object(fields = {})
       if fields.empty?
         Type::Object.new(fields, on_unknown: :ignore, exceptions: Set.new)
@@ -9,12 +8,10 @@ class StrongJSON
       end
     end
 
-    # @type method array: (?ty) -> Type::Array<any>
     def array(type = any)
       Type::Array.new(type)
     end
 
-    # @type method optional: (?ty) -> Type::Optional<any>
     def optional(type = any)
       Type::Optional.new(type)
     end
@@ -87,7 +84,6 @@ class StrongJSON
       optional(array(ty))
     end
 
-    # @type method object?: (?Hash<Symbol, ty>) -> Type::Optional<any>
     def object?(fields={})
       optional(object(fields))
     end

data/lib/strong_json/version.rb

@@ -1,5 +1,5 @@
 class StrongJSON
   # @dynamic initialize, let
 
-  VERSION = "2.1.0"
+  VERSION = "2.1.1"
 end

data/pp.rb

@@ -0,0 +1,27 @@
+require "prettyprint"
+
+pp = PrettyPrint.new
+
+pp.group 0 do
+	pp.text "hello = "
+
+	pp.group 0, "enum_____(", ")" do
+		pp.nest(2) do
+			pp.breakable ""
+			count = 7
+			count.times do |i|
+				pp.text "hello #{i}"
+
+				if i < count - 1
+					pp.text ","
+					pp.breakable " "
+				end
+			end
+		end
+
+		pp.breakable ""
+	end
+end
+
+pp.flush
+puts pp.output

data/sig/strong_json.rbs

@@ -0,0 +1,67 @@
+class StrongJSON
+  def initialize: { (StrongJSON) -> void } -> untyped
+  def let: (Symbol, ty) -> void
+  include StrongJSON::Types
+end
+
+StrongJSON::VERSION: String
+
+interface StrongJSON::_Schema[T]
+  def coerce: (untyped, ?path: Type::ErrorPath) -> T
+  def =~: (untyped) -> bool
+  def to_s: -> String
+  def is_a?: (untyped) -> bool
+  def `alias`: -> Symbol?
+  def with_alias: (Symbol) -> self
+  def ==: (untyped) -> bool
+  def yield_self: [X] () { (self) -> X } -> X
+end
+
+type StrongJSON::ty = _Schema[untyped]
+
+module StrongJSON::Types
+  def object: [X] (Hash[Symbol, ty]) -> Type::Object[X]
+            | () -> Type::Object[bot]
+  def object?: [X] (Hash[Symbol, ty]) -> Type::Optional[X]
+             | () -> Type::Optional[bot]
+  def any: () -> Type::Base[untyped]
+  def any?: () -> Type::Optional[untyped]
+  def optional: [X] (_Schema[X]) -> Type::Optional[X]
+              | () -> Type::Optional[untyped]
+  def string: () -> Type::Base[String]
+  def string?: () -> Type::Optional[String]
+  def number: () -> Type::Base[Numeric]
+  def number?: () -> Type::Optional[Numeric]
+  def numeric: () -> Type::Base[Numeric]
+  def numeric?: () -> Type::Optional[Numeric]
+  def integer: () -> Type::Base[Integer]
+  def integer?: () -> Type::Optional[Integer]
+  def boolean: () -> Type::Base[bool]
+  def boolean?: () -> Type::Optional[bool]
+  def symbol: () -> Type::Base[Symbol]
+  def symbol?: () -> Type::Optional[Symbol]
+  def array: [X] (_Schema[X]) -> Type::Array[X]
+           | () -> Type::Array[untyped]
+  def array?: [X] (_Schema[X]) -> Type::Optional[::Array[X]]
+  def literal: [X] (X) -> Type::Literal[X]
+  def literal?: [X] (X) -> Type::Optional[X]
+  def enum: [X] (*_Schema[untyped], ?detector: Type::detector?) -> Type::Enum[X]
+  def enum?: [X] (*_Schema[untyped], ?detector: Type::detector?) -> Type::Optional[X]
+  incompatible def hash: [X] (_Schema[X]) -> Type::Hash[X]
+  def hash?: [X] (_Schema[X]) -> Type::Optional[Hash[Symbol, X]]
+end
+
+class StrongJSON::ErrorReporter
+  attr_reader path: Type::ErrorPath
+  @string: String
+
+  def initialize: (path: Type::ErrorPath) -> untyped
+  def format: -> void
+  def pretty_str: (ty, ?expand_alias: bool) -> ::String
+
+  private
+  def format_trace: (path: Type::ErrorPath, ?index: Integer) -> void
+  def format_aliases: (path: Type::ErrorPath, where: ::Array[String]) -> ::Array[String]
+  def format_single_alias: (Symbol, ty) -> String
+  def pretty: (ty, untyped, ?expand_alias: bool) -> void
+end

data/sig/type.rbs

@@ -0,0 +1,131 @@
+module StrongJSON::Type
+end
+
+module StrongJSON::Type::Match : _Schema[untyped]
+  def =~: (untyped) -> bool
+  def ===: (untyped) -> bool
+end
+
+module StrongJSON::Type::WithAlias : ::Object
+  @alias: Symbol?
+  def `alias`: -> Symbol?
+  def with_alias: (Symbol) -> self
+end
+
+type StrongJSON::base_type_name = :any | :number | :string | :boolean | :numeric | :symbol | :integer
+
+class StrongJSON::Type::Base[A]
+  include Match
+  include WithAlias
+
+  attr_reader type: base_type_name
+
+  def initialize: (base_type_name) -> untyped
+  def test: (untyped) -> bool
+  def coerce: (untyped, ?path: ErrorPath) -> A
+end
+
+class StrongJSON::Type::Optional[T]
+  include Match
+  include WithAlias
+
+  attr_reader type: _Schema[T]
+
+  def initialize: (_Schema[T]) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> (T | nil)
+end
+
+class StrongJSON::Type::Literal[T]
+  include Match
+  include WithAlias
+
+  attr_reader value: T
+
+  def initialize: (T) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> T
+end
+
+class StrongJSON::Type::Array[T]
+  include Match
+  include WithAlias
+
+  attr_reader type: _Schema[T]
+
+  def initialize: (_Schema[T]) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> ::Array[T]
+end
+
+class StrongJSON::Type::Object[T]
+  include Match
+  include WithAlias
+
+  attr_reader fields: ::Hash[Symbol, _Schema[untyped]]
+  attr_reader on_unknown: :ignore | :reject
+  attr_reader exceptions: Set[Symbol]
+
+  def initialize: (::Hash[Symbol, _Schema[T]], on_unknown: :ignore | :reject, exceptions: Set[Symbol]) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> T
+
+  # If no argument is given, it ignores all unknown attributes.
+  # If `Symbol`s are given, it ignores the listed attributes, but rejects if other unknown attributes are detected.
+  # If `except:` is specified, it rejects attributes listed in `except` are detected, but ignores other unknown attributes.
+  def ignore: (*Symbol ignores, ?except: Set[Symbol]?) -> Object[T]
+
+  # If no argument is given, it rejects on untyped unknown attribute.
+  # If `Symbol`s are given, it rejects the listed attributes are detected, but ignores other unknown attributes.
+  # If `except:` is specified, it ignores given attributes, but rejects if other unknown attributes are detected.
+  def reject: (*Symbol rejecteds, ?except: Set[Symbol]?) -> Object[T]
+
+  def update_fields: [X] { (::Hash[Symbol, _Schema[untyped]]) -> void } -> Object[X]
+end
+
+type StrongJSON::Type::detector = ^(untyped) -> _Schema[untyped]?
+
+class StrongJSON::Type::Enum[T]
+  include Match
+  include WithAlias
+
+  attr_reader types: ::Array[_Schema[untyped]]
+  attr_reader detector: detector?
+
+  def initialize: (::Array[_Schema[untyped]], ?detector?) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> T
+end
+
+class StrongJSON::Type::ErrorPath
+  attr_reader type: _Schema[untyped]
+  attr_reader parent: [Symbol | Integer | nil, ErrorPath]?
+
+  def initialize: (type: _Schema[untyped], parent: [Symbol | Integer | nil, ErrorPath]?) -> untyped
+  def dig: (key: Symbol | Integer, type: _Schema[untyped]) -> ErrorPath
+  def expand: (type: _Schema[untyped]) -> ErrorPath
+
+  def self.root: (_Schema[untyped]) -> ErrorPath
+  def root?: -> bool
+end
+
+class StrongJSON::Type::TypeError < StandardError
+  attr_reader path: ErrorPath
+  attr_reader value: untyped
+
+  def initialize: (path: ErrorPath, value: untyped) -> untyped
+  def type: -> _Schema[untyped]
+end
+
+class StrongJSON::Type::UnexpectedAttributeError < StandardError
+  attr_reader path: ErrorPath
+  attr_reader attribute: Symbol
+
+  def initialize: (path: ErrorPath, attribute: Symbol) -> untyped
+  def type: -> _Schema[untyped]
+end
+
+class StrongJSON::Type::Hash[T]
+  include Match
+  include WithAlias
+
+  attr_reader type: _Schema[T]
+
+  def initialize: (_Schema[T]) -> untyped
+  def coerce: (untyped, ?path: ErrorPath) -> ::Hash[Symbol, T]
+end

data/spec/enum_spec.rb

@@ -29,7 +29,7 @@ describe StrongJSON::Type::Enum do
               id: StrongJSON::Type::Literal.new("id1"),
               value: StrongJSON::Type::Base.new(:string)
             },
-            on_unknown: :raise,
+            on_unknown: :reject,
             exceptions: Set[]
           ),
           StrongJSON::Type::Object.new(
@@ -37,7 +37,7 @@ describe StrongJSON::Type::Enum do
               id: StrongJSON::Type::Base.new(:string),
               value: StrongJSON::Type::Base.new(:symbol)
             },
-            on_unknown: :raise,
+            on_unknown: :reject,
             exceptions: Set[]
           ),
           StrongJSON::Type::Optional.new(StrongJSON::Type::Literal.new(3)),
@@ -73,7 +73,7 @@ describe StrongJSON::Type::Enum do
             regexp: StrongJSON::Type::Base.new(:string),
             option: StrongJSON::Type::Base.new(:string),
           },
-          on_unknown: :raise,
+          on_unknown: :reject,
           exceptions: Set[]
         )
       }
@@ -83,7 +83,7 @@ describe StrongJSON::Type::Enum do
           {
             literal: StrongJSON::Type::Base.new(:string)
           },
-          on_unknown: :raise,
+          on_unknown: :reject,
           exceptions: Set[]
         )
       }

data/spec/object_spec.rb

@@ -8,7 +8,7 @@ describe StrongJSON::Type::Object do
           a: StrongJSON::Type::Base.new(:numeric),
           b: StrongJSON::Type::Base.new(:string)
         },
-        on_unknown: :raise,
+        on_unknown: :reject,
         exceptions: Set.new
       )
 
@@ -85,7 +85,7 @@ describe StrongJSON::Type::Object do
         {
           a: StrongJSON::Type::Optional.new(StrongJSON::Type::Base.new(:numeric))
         },
-        on_unknown: :raise,
+        on_unknown: :reject,
         exceptions: Set[]
       )
     }
@@ -110,7 +110,7 @@ describe StrongJSON::Type::Object do
           a: StrongJSON::Type::Base.new(:numeric),
           b: StrongJSON::Type::Base.new(:string)
         },
-        on_unknown: :raise,
+        on_unknown: :reject,
         exceptions: Set[]
       )
     }
@@ -128,7 +128,7 @@ describe StrongJSON::Type::Object do
     let (:type) {
       StrongJSON::Type::Object.new(
         { a: StrongJSON::Type::Base.new(:numeric) },
-        on_unknown: :raise,
+        on_unknown: :reject,
         exceptions: Set[]
       )
     }
@@ -163,7 +163,7 @@ describe StrongJSON::Type::Object do
     let (:type) {
       StrongJSON::Type::Object.new(
         { a: StrongJSON::Type::Base.new(:numeric) },
-        on_unknown: :raise,
+        on_unknown: :reject,
         exceptions: Set[]
       )
     }

data/strong_json.gemspec

@@ -22,5 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.6"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "steep", "~> 0.10"
+  spec.add_development_dependency "steep", "~> 0.15"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.1.1
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-19 00:00:00.000000000 Z
+date: 2020-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.15'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.15'
 description: Type check JSON objects
 email:
 - matsumoto@soutaro.com
@@ -81,15 +81,18 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- example/example.rb
-- example/example.rbi
+- Steepfile
+- example/Steepfile
+- example/lib/example.rb
+- example/sig/example.rbs
 - lib/strong_json.rb
 - lib/strong_json/error_reporter.rb
 - lib/strong_json/type.rb
 - lib/strong_json/types.rb
 - lib/strong_json/version.rb
-- sig/strong_json.rbi
-- sig/type.rbi
+- pp.rb
+- sig/strong_json.rbs
+- sig/type.rbs
 - spec/array_spec.rb
 - spec/basetype_spec.rb
 - spec/case_subsumption_operator_spec.rb
@@ -121,8 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Type check JSON objects

data/example/example.rbi

@@ -1,11 +0,0 @@
-type address = { address: String, country: Symbol? }
-type email = { email: String }
-
-class AddressSchema < StrongJSON
-  def address: -> StrongJSON::Type::Object<address>
-  def email: -> StrongJSON::Type::Object<email>
-  def contact: -> StrongJSON::Type::Object<email | address>
-  def person: -> StrongJSON::Type::Object<{ name: String, contacts: Array<email | address> }>
-end
-
-Schema: AddressSchema

data/sig/strong_json.rbi

@@ -1,68 +0,0 @@
-class StrongJSON
-  def initialize: { (self) -> void } -> any
-  def let: (Symbol, ty) -> void
-  include StrongJSON::Types
-end
-
-StrongJSON::VERSION: String
-
-class StandardError
-  def initialize: (String) -> any
-end
-
-interface StrongJSON::_Schema<'type>
-  def coerce: (any, ?path: Type::ErrorPath) -> 'type
-  def =~: (any) -> bool
-  def to_s: -> String
-  def is_a?: (any) -> bool
-  def alias: -> Symbol?
-  def with_alias: (Symbol) -> self
-  def ==: (any) -> bool
-  def yield_self: <'a> () { (self) -> 'a } -> 'a
-end
-
-type StrongJSON::ty = _Schema<any>
-
-module StrongJSON::Types
-  def object: <'x> (Hash<Symbol, ty>) -> Type::Object<'x>
-            | () -> Type::Object<{}>
-  def object?: <'x> (Hash<Symbol, ty>) -> Type::Optional<'x>
-             | () -> Type::Optional<{}>
-  def any: () -> Type::Base<any>
-  def any?: () -> Type::Optional<any>
-  def optional: <'x> (_Schema<'x>) -> Type::Optional<'x>
-              | () -> Type::Optional<any>
-  def string: () -> Type::Base<String>
-  def string?: () -> Type::Optional<String>
-  def number: () -> Type::Base<Numeric>
-  def number?: () -> Type::Optional<Numeric>
-  def numeric: () -> Type::Base<Numeric>
-  def numeric?: () -> Type::Optional<Numeric>
-  def integer: () -> Type::Base<Integer>
-  def integer?: () -> Type::Optional<Integer>
-  def boolean: () -> Type::Base<bool>
-  def boolean?: () -> Type::Optional<bool>
-  def symbol: () -> Type::Base<Symbol>
-  def symbol?: () -> Type::Optional<Symbol>
-  def array: <'x> (_Schema<'x>) -> Type::Array<'x>
-           | () -> Type::Array<any>
-  def array?: <'x> (_Schema<'x>) -> Type::Optional<::Array<'x>>
-  def literal: <'x> ('x) -> Type::Literal<'x>
-  def literal?: <'x> ('x) -> Type::Optional<'x>
-  def enum: <'x> (*_Schema<any>, ?detector: Type::detector?) -> Type::Enum<'x>
-  def enum?: <'x> (*_Schema<any>, ?detector: Type::detector?) -> Type::Optional<'x>
-  def (incompatible) hash: <'x> (_Schema<'x>) -> Type::Hash<'x>
-  def hash?: <'x> (_Schema<'x>) -> Type::Optional<Hash<Symbol, 'x>>
-end
-
-class StrongJSON::ErrorReporter
-  attr_reader path: Type::ErrorPath
-  @string: String
-  def initialize: (path: Type::ErrorPath) -> any
-  def format: -> void
-  def (private) format_trace: (path: Type::ErrorPath, ?index: Integer) -> void
-  def (private) format_aliases: (path: Type::ErrorPath, where: ::Array<String>) -> ::Array<String>
-  def (private) format_single_alias: (Symbol, ty) -> String
-  def (private) pretty: (ty, any, ?expand_alias: bool) -> void
-  def pretty_str: (ty, ?expand_alias: bool) -> ::String
-end

data/sig/type.rbi

@@ -1,135 +0,0 @@
-module StrongJSON::Type
-end
-
-module StrongJSON::Type::Match: _Schema<any>
-  def =~: (any) -> bool
-  def ===: (any) -> bool
-end
-
-module StrongJSON::Type::WithAlias: ::Object
-  @alias: Symbol?
-  def alias: -> Symbol?
-  def with_alias: (Symbol) -> self
-end
-
-type StrongJSON::base_type_name = :any | :number | :string | :boolean | :numeric | :symbol | :integer
-
-class StrongJSON::Type::Base<'a>
-  include Match
-  include WithAlias
-
-  attr_reader type: base_type_name
-
-  def initialize: (base_type_name) -> any
-  def test: (any) -> bool
-  def coerce: (any, ?path: ErrorPath) -> 'a
-end
-
-class StrongJSON::Type::Optional<'t>
-  include Match
-  include WithAlias
-
-  attr_reader type: _Schema<'t>
-
-  def initialize: (_Schema<'t>) -> any
-  def coerce: (any, ?path: ErrorPath) -> ('t | nil)
-end
-
-class StrongJSON::Type::Literal<'t>
-  include Match
-  include WithAlias
-
-  attr_reader value: 't
-
-  def initialize: ('t) -> any
-  def coerce: (any, ?path: ErrorPath) -> 't
-end
-
-class StrongJSON::Type::Array<'t>
-  include Match
-  include WithAlias
-
-  attr_reader type: _Schema<'t>
-
-  def initialize: (_Schema<'t>) -> any
-  def coerce: (any, ?path: ErrorPath) -> ::Array<'t>
-end
-
-class StrongJSON::Type::Object<'t>
-  include Match
-  include WithAlias
-
-  attr_reader fields: ::Hash<Symbol, _Schema<any>>
-  attr_reader on_unknown: :ignore | :reject
-  attr_reader exceptions: Set<Symbol>
-
-  def initialize: (::Hash<Symbol, _Schema<'t>>, on_unknown: :ignore | :reject, exceptions: Set<Symbol>) -> any
-  def coerce: (any, ?path: ErrorPath) -> 't
-
-  # If no argument is given, it ignores all unknown attributes.
-  # If `Symbol`s are given, it ignores the listed attributes, but rejects if other unknown attributes are detected.
-  # If `except:` is specified, it rejects attributes listed in `except` are detected, but ignores other unknown attributes.
-  def ignore: () -> self
-            | (*Symbol) -> self
-            | (?except: Set<Symbol>) -> self
-
-  # If no argument is given, it rejects on any unknown attribute.
-  # If `Symbol`s are given, it rejects the listed attributes are detected, but ignores other unknown attributes.
-  # If `except:` is specified, it ignores given attributes, but rejects if other unknown attributes are detected.
-  def reject: () -> self
-            | (*Symbol) -> self
-            | (?except: Set<Symbol>) -> self
-
-  def update_fields: <'x> { (::Hash<Symbol, _Schema<any>>) -> void } -> Object<'x>
-end
-
-type StrongJSON::Type::detector = ^(any) -> _Schema<any>?
-
-class StrongJSON::Type::Enum<'t>
-  include Match
-  include WithAlias
-
-  attr_reader types: ::Array<_Schema<any>>
-  attr_reader detector: detector?
-
-  def initialize: (::Array<_Schema<any>>, ?detector?) -> any
-  def coerce: (any, ?path: ErrorPath) -> 't
-end
-
-class StrongJSON::Type::ErrorPath
-  attr_reader type: _Schema<any>
-  attr_reader parent: [Symbol | Integer | nil, instance]?
-
-  def initialize: (type: _Schema<any>, parent: [Symbol | Integer | nil, instance]?) -> any
-  def (constructor) dig: (key: Symbol | Integer, type: _Schema<any>) -> self
-  def (constructor) expand: (type: _Schema<any>) -> self
-
-  def self.root: (_Schema<any>) -> instance
-  def root?: -> bool
-end
-
-class StrongJSON::Type::TypeError < StandardError
-  attr_reader path: ErrorPath
-  attr_reader value: any
-
-  def initialize: (path: ErrorPath, value: any) -> any
-  def type: -> _Schema<any>
-end
-
-class StrongJSON::Type::UnexpectedAttributeError < StandardError
-  attr_reader path: ErrorPath
-  attr_reader attribute: Symbol
-
-  def initialize: (path: ErrorPath, attribute: Symbol) -> any
-  def type: -> _Schema<any>
-end
-
-class StrongJSON::Type::Hash<'t>
-  include Match
-  include WithAlias
-
-  attr_reader type: _Schema<'t>
-
-  def initialize: (_Schema<'t>) -> any
-  def coerce: (any, ?path: ErrorPath) -> ::Hash<Symbol, 't>
-end