strong_json 2.1.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1118cf0a2239601909e8d3af33e2b7d2809c8baccae8a0a77b2f2c6fdc814a1
-  data.tar.gz: 39a6fe29b3383722be668af971c9a78b8719dee1bb8b7e2fe1eb06ce8fe1f5f4
+  metadata.gz: 3024051238c907ceb915ad211936b82d0c4422f6980f2abeff76a667017f6a0a
+  data.tar.gz: 9f9d1efa03cb0d35155837928577062ae696066841d50a6495c33f40f7fee6ec
 SHA512:
-  metadata.gz: bc54d705a3b26803caed812795525e64c2a08260be22c1d14e48f9e47e897b3b60acf4f256eb3ce846fb1c9afda0ed3f019d0a2932827bbfa2ec0fb65931eecb
-  data.tar.gz: 40bc0d295723533e3ed0e86f77af4b70f26e7fce0fd12498ef14cb906ea28b549b50825021a6421d702a3cd956ef1cec7d9353073124b7859380c1906793a830
+  metadata.gz: 99a431a8d8f686604b8b0a44a1827e0440c61144d9d1b5f1253fbf79b6707dfb10f60a54de337b4dc87b7d27f31b6bd5f3c20f0a6a8a2dff2f48c2a144020827
+  data.tar.gz: 38953830ba84e56e13ee9ab8ff91b97f305bdea2cc81ca12655f2d474932f1ea36bc4c9b1971dd17b123af18ff1036df317ea69bdc93c60002d4fe73cc1654f3

data/.github/workflows/ruby.yml

@@ -0,0 +1,29 @@
+name: Ruby
+
+on:
+  push:
+    branches:
+      - master
+  pull_request: {}
+
+jobs:
+  test:
+    runs-on: "ubuntu-latest"
+    strategy:
+      matrix:
+        container_tag:
+        - master-nightly-bionic
+        - 2.6.5-bionic
+        - 2.7.0-bionic
+    container:
+      image: rubylang/ruby:${{ matrix.container_tag }}
+    steps:
+    - uses: actions/checkout@v1
+    - name: Install
+      run: |
+        ruby -v
+        gem install bundler
+        bundle install
+    - name: Run test
+      run: |
+        bundle exec rake

data/.ruby-version

@@ -1 +1 @@
-2.6.3
+2.6.6

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
-  - "2.5.3"
-  - "2.6.3"
+  - "2.5.8"
+  - "2.6.6"
+  - "2.7.1"

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 2.1.2
+
+* Update Steep
+
 ## 2.1.1 (2020-05-16)
 
 * [24](https://github.com/soutaro/strong_json/pull/24): Ship with RBS

data/Gemfile

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

data/lib/strong_json/error_reporter.rb

@@ -67,7 +67,6 @@ class StrongJSON
     end
 
     def format_single_alias(name, type)
-      # @type const PrettyPrint: untyped
       PrettyPrint.format do |pp|
         pp.text(name.to_s)
         pp.text(" = ")
@@ -78,7 +77,6 @@ class StrongJSON
     end
 
     def pretty_str(type, expand_alias: false)
-      # @type const PrettyPrint: untyped
       PrettyPrint.singleline_format do |pp|
         pretty(type, pp, expand_alias: expand_alias)
       end

data/lib/strong_json/version.rb

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

data/sig/polyfill.rbs

@@ -0,0 +1,13 @@
+class PrettyPrint
+  def text: (String) -> void
+
+  def group: (?Integer, ?String, ?String) { () -> void } -> void
+
+  def nest: (Integer) { () -> void } -> void
+
+  def breakable: (String) -> void
+
+  def self.format: { (instance) -> void } -> String
+
+  def self.singleline_format: { (instance) -> void } -> String
+end

data/sig/strong_json.rbs

@@ -1,67 +1,67 @@
 class StrongJSON
   def initialize: { (StrongJSON) -> void } -> untyped
   def let: (Symbol, ty) -> void
-  include StrongJSON::Types
-end
+  include Types
 
-StrongJSON::VERSION: String
+  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
+  interface _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]
+  type 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
+  module 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]
+    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
+  class 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
+    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
+    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, PrettyPrint, ?expand_alias: bool) -> void
+  end
 end

data/sig/type.rbs

@@ -1,131 +1,132 @@
-module StrongJSON::Type
-end
+class StrongJSON
+  module Type
+    module Match : _Schema[untyped]
+      def =~: (untyped) -> bool
+      def ===: (untyped) -> bool
+    end
 
-module StrongJSON::Type::Match : _Schema[untyped]
-  def =~: (untyped) -> bool
-  def ===: (untyped) -> bool
-end
+    module WithAlias : ::Object
+      @alias: Symbol?
+      def `alias`: -> Symbol?
+      def with_alias: (Symbol) -> self
+    end
 
-module StrongJSON::Type::WithAlias : ::Object
-  @alias: Symbol?
-  def `alias`: -> Symbol?
-  def with_alias: (Symbol) -> self
-end
+    type base_type_name = :any | :number | :string | :boolean | :numeric | :symbol | :integer
 
-type StrongJSON::base_type_name = :any | :number | :string | :boolean | :numeric | :symbol | :integer
+    class Base[A]
+      include Match
+      include WithAlias
 
-class StrongJSON::Type::Base[A]
-  include Match
-  include WithAlias
+      attr_reader type: base_type_name
 
-  attr_reader type: base_type_name
+      def initialize: (base_type_name) -> untyped
+      def test: (untyped) -> bool
+      def coerce: (untyped, ?path: ErrorPath) -> A
+    end
 
-  def initialize: (base_type_name) -> untyped
-  def test: (untyped) -> bool
-  def coerce: (untyped, ?path: ErrorPath) -> A
-end
+    class Optional[T]
+      include Match
+      include WithAlias
 
-class StrongJSON::Type::Optional[T]
-  include Match
-  include WithAlias
+      attr_reader type: _Schema[T]
 
-  attr_reader type: _Schema[T]
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> (T | nil)
+    end
 
-  def initialize: (_Schema[T]) -> untyped
-  def coerce: (untyped, ?path: ErrorPath) -> (T | nil)
-end
+    class Literal[T]
+      include Match
+      include WithAlias
 
-class StrongJSON::Type::Literal[T]
-  include Match
-  include WithAlias
+      attr_reader value: T
 
-  attr_reader value: T
+      def initialize: (T) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> T
+    end
 
-  def initialize: (T) -> untyped
-  def coerce: (untyped, ?path: ErrorPath) -> T
-end
+    class Array[T]
+      include Match
+      include WithAlias
 
-class StrongJSON::Type::Array[T]
-  include Match
-  include WithAlias
+      attr_reader type: _Schema[T]
 
-  attr_reader type: _Schema[T]
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> ::Array[T]
+    end
 
-  def initialize: (_Schema[T]) -> untyped
-  def coerce: (untyped, ?path: ErrorPath) -> ::Array[T]
-end
+    class Object[T]
+      include Match
+      include WithAlias
 
-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]
 
-  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
 
-  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 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]
 
-  # 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
 
-  def update_fields: [X] { (::Hash[Symbol, _Schema[untyped]]) -> void } -> Object[X]
-end
-
-type StrongJSON::Type::detector = ^(untyped) -> _Schema[untyped]?
+    type detector = ^(untyped) -> _Schema[untyped]?
 
-class StrongJSON::Type::Enum[T]
-  include Match
-  include WithAlias
+    class Enum[T]
+      include Match
+      include WithAlias
 
-  attr_reader types: ::Array[_Schema[untyped]]
-  attr_reader detector: detector?
+      attr_reader types: ::Array[_Schema[untyped]]
+      attr_reader detector: detector?
 
-  def initialize: (::Array[_Schema[untyped]], ?detector?) -> untyped
-  def coerce: (untyped, ?path: ErrorPath) -> T
-end
+      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]?
+    class 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 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
+      def self.root: (_Schema[untyped]) -> ErrorPath
+      def root?: -> bool
+    end
 
-class StrongJSON::Type::TypeError < StandardError
-  attr_reader path: ErrorPath
-  attr_reader value: untyped
+    class TypeError < StandardError
+      attr_reader path: ErrorPath
+      attr_reader value: untyped
 
-  def initialize: (path: ErrorPath, value: untyped) -> untyped
-  def type: -> _Schema[untyped]
-end
+      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
+    class UnexpectedAttributeError < StandardError
+      attr_reader path: ErrorPath
+      attr_reader attribute: Symbol
 
-  def initialize: (path: ErrorPath, attribute: Symbol) -> untyped
-  def type: -> _Schema[untyped]
-end
+      def initialize: (path: ErrorPath, attribute: Symbol) -> untyped
+      def type: -> _Schema[untyped]
+    end
 
-class StrongJSON::Type::Hash[T]
-  include Match
-  include WithAlias
+    class Hash[T]
+      include Match
+      include WithAlias
 
-  attr_reader type: _Schema[T]
+      attr_reader type: _Schema[T]
 
-  def initialize: (_Schema[T]) -> untyped
-  def coerce: (untyped, ?path: ErrorPath) -> ::Hash[Symbol, T]
+      def initialize: (_Schema[T]) -> untyped
+      def coerce: (untyped, ?path: ErrorPath) -> ::Hash[Symbol, T]
+    end
+  end
 end

data/spec/json_spec.rb

@@ -20,11 +20,11 @@ describe "StrongJSON.new" do
     end
 
     expect(
-      s.checkout.coerce(items: [{ name: "test", count: 1, price: "2.33", comment: "dummy" }], type: 1)
+      s.checkout.coerce({ items: [{ name: "test", count: 1, price: "2.33", comment: "dummy" }], type: 1 })
     ).to eq(items: [ { name: "test", count: 1, price: "2.33" }], type: 1, change: nil, customer: nil)
 
     expect {
-      s.checkout.coerce(items: [{ name: "test", count: 1, price: [], comment: "dummy" }], type: 1)
+      s.checkout.coerce({ items: [{ name: "test", count: 1, price: [], comment: "dummy" }], type: 1 })
     }.to raise_error(StrongJSON::Type::TypeError) {|e|
       expect(e.path.to_s).to eq("$.items[0].price")
       expect(e.type).to be_a(StrongJSON::Type::Base)
@@ -58,7 +58,7 @@ MSG
     }
 
     expect {
-      s.checkout.coerce(items: [], change: "", type: 1)
+      s.checkout.coerce({ items: [], change: "", type: 1 })
     }.to raise_error(StrongJSON::Type::TypeError) {|e|
       expect(e.path.to_s).to eq("$.change")
       expect(e.type).to be_a(StrongJSON::Type::Base)
@@ -94,14 +94,14 @@ MSG
       let :enum, object(e1: enum(boolean, number), e2: enum?(literal(1), literal(2)))
     end
 
-    expect(s.enum.coerce(e1: false)).to eq(e1: false, e2: nil)
-    expect(s.enum.coerce(e1: 0)).to eq(e1: 0, e2: nil)
-    expect(s.enum.coerce(e1: 0, e2: 1)).to eq(e1: 0, e2: 1)
-    expect(s.enum.coerce(e1: 0, e2: 2)).to eq(e1: 0, e2: 2)
-    expect{ s.enum.coerce(e1: "", e2: 3) }.to raise_error(StrongJSON::Type::TypeError) {|e|
+    expect(s.enum.coerce({ e1: false })).to eq(e1: false, e2: nil)
+    expect(s.enum.coerce({ e1: 0 })).to eq(e1: 0, e2: nil)
+    expect(s.enum.coerce({ e1: 0, e2: 1 })).to eq(e1: 0, e2: 1)
+    expect(s.enum.coerce({ e1: 0, e2: 2 })).to eq(e1: 0, e2: 2)
+    expect{ s.enum.coerce({ e1: "", e2: 3 }) }.to raise_error(StrongJSON::Type::TypeError) {|e|
       expect(e.path.to_s).to eq("$.e1")
     }
-    expect{ s.enum.coerce(e1: false, e2: "") }.to raise_error(StrongJSON::Type::TypeError) {|e|
+    expect{ s.enum.coerce({ e1: false, e2: ""} ) }.to raise_error(StrongJSON::Type::TypeError) {|e|
       expect(e.path.to_s).to eq("$.e2")
     }
   end

data/spec/object_spec.rb

@@ -12,7 +12,7 @@ describe StrongJSON::Type::Object do
         exceptions: Set.new
       )
 
-      expect(type.coerce(a: 123, b: "test")).to eq(a: 123, b: "test")
+      expect(type.coerce({ a: 123, b: "test" })).to eq(a: 123, b: "test")
     end
 
     it "rejects objects with missing fields" do
@@ -24,7 +24,7 @@ describe StrongJSON::Type::Object do
         exceptions: Set.new
       )
 
-      expect{ type.coerce(a: 123, b: "test") }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|e|
+      expect{ type.coerce({ a: 123, b: "test" }) }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|e|
         expect(e.path.to_s).to eq("$")
         expect(e.attribute).to eq(:b)
       }
@@ -42,12 +42,12 @@ describe StrongJSON::Type::Object do
       }
 
       it "ignores field with any value" do
-        expect(type.coerce(a: 123, b: true)).to eq(a: 123)
+        expect(type.coerce({ a: 123, b: true })).to eq(a: 123)
       end
 
       it "raises error on attributes listed in exceptions" do
         expect {
-          type.coerce(a: 123, x: false)
+          type.coerce({ a: 123, x: false })
         }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|error|
           expect(error.attribute).to eq(:x)
         }
@@ -67,14 +67,14 @@ describe StrongJSON::Type::Object do
 
       it "raises with unknown attribute" do
         expect {
-          type.coerce(a: 123, b: true)
+          type.coerce({ a: 123, b: true })
         }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|error|
           expect(error.attribute).to eq(:b)
         }
       end
 
       it "ignores attributes listed in exceptions" do
-        expect(type.coerce(a: 123, c: false)).to eq(a:123)
+        expect(type.coerce({ a: 123, c: false })).to eq(a:123)
       end
     end
   end

data/strong_json.gemspec

@@ -18,9 +18,4 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
   spec.metadata = { "steep_types" => "sig" }
-
-  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.15"
 end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-05-16 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: steep
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.15'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.15'
+date: 2020-10-09 00:00:00.000000000 Z
+dependencies: []
 description: Type check JSON objects
 email:
 - matsumoto@soutaro.com
@@ -73,6 +17,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".ruby-version"
 - ".travis.yml"
@@ -91,6 +36,7 @@ files:
 - lib/strong_json/types.rb
 - lib/strong_json/version.rb
 - pp.rb
+- sig/polyfill.rbs
 - sig/strong_json.rbs
 - sig/type.rbs
 - spec/array_spec.rb
@@ -109,7 +55,7 @@ licenses:
 - MIT
 metadata:
   steep_types: sig
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -124,8 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Type check JSON objects
 test_files: