strong_json 1.0.1 → 2.1.2

data/spec/object_spec.rb

@@ -8,26 +8,11 @@ describe StrongJSON::Type::Object do
           a: StrongJSON::Type::Base.new(:numeric),
           b: StrongJSON::Type::Base.new(:string)
         },
-        ignored_attributes: nil,
-        prohibited_attributes: Set.new
+        on_unknown: :reject,
+        exceptions: Set.new
       )
 
-      expect(type.coerce(a: 123, b: "test")).to eq(a: 123, b: "test")
-    end
-
-    it "rejects unspecified fields" do
-      type = StrongJSON::Type::Object.new(
-        {
-          a: StrongJSON::Type::Base.new(:numeric)
-        },
-        ignored_attributes: nil,
-        prohibited_attributes: Set.new
-      )
-
-      expect { type.coerce(a:123, b:true) }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|e|
-        expect(e.path.to_s).to eq("$")
-        expect(e.attribute).to eq(:b)
-      }
+      expect(type.coerce({ a: 123, b: "test" })).to eq(a: 123, b: "test")
     end
 
     it "rejects objects with missing fields" do
@@ -35,87 +20,61 @@ describe StrongJSON::Type::Object do
         {
           a: StrongJSON::Type::Base.new(:numeric)
         },
-        ignored_attributes: nil,
-        prohibited_attributes: Set.new
+        on_unknown: :reject,
+        exceptions: Set.new
       )
 
-      expect{ type.coerce(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)
       }
     end
 
-    describe "ignored_attributes" do
-      context "when ignored_attributes are given as Set" do
-        let(:type) {
-          StrongJSON::Type::Object.new(
-            {
-              a: StrongJSON::Type::Base.new(:numeric)
-            },
-            ignored_attributes: Set.new([:b]),
-            prohibited_attributes: Set.new
-          )
-        }
-
-        it "ignores field with any value" do
-          expect(type.coerce(a: 123, b: true)).to eq(a: 123)
-        end
-
-        it "accepts if it does not contains the field" do
-          expect(type.coerce(a: 123)).to eq(a: 123)
-        end
-      end
-
-      context "when ignored_attributes is nil" do
-        let(:type) {
-          StrongJSON::Type::Object.new(
-            {
-              a: StrongJSON::Type::Base.new(:numeric)
-            },
-            ignored_attributes: nil,
-            prohibited_attributes: Set.new
-          )
-        }
+    context "when on_unknown is :ignore" do
+      let(:type) {
+        StrongJSON::Type::Object.new(
+          {
+            a: StrongJSON::Type::Base.new(:numeric)
+          },
+          on_unknown: :ignore,
+          exceptions: Set[:x]
+        )
+      }
 
-        it "ignores field with any value" do
-          expect {
-            type.coerce(a: 123, b: true)
-          }.to raise_error(StrongJSON::Type::UnexpectedAttributeError)
-        end
+      it "ignores field with any value" do
+        expect(type.coerce({ a: 123, b: true })).to eq(a: 123)
       end
 
-      context "when ignored_attributes is :any" do
-        let(:type) {
-          StrongJSON::Type::Object.new(
-            {
-              a: StrongJSON::Type::Base.new(:numeric)
-            },
-            ignored_attributes: :any,
-            prohibited_attributes: Set.new
-          )
+      it "raises error on attributes listed in exceptions" do
+        expect {
+          type.coerce({ a: 123, x: false })
+        }.to raise_error(StrongJSON::Type::UnexpectedAttributeError) {|error|
+          expect(error.attribute).to eq(:x)
         }
-
-        it "ignores field with any value" do
-          expect(type.coerce(a: 123, b: true)).to eq(a: 123)
-        end
       end
     end
 
-    describe "prohibited_attributes" do
+    context "when on_unknown is :reject" do
       let(:type) {
         StrongJSON::Type::Object.new(
           {
             a: StrongJSON::Type::Base.new(:numeric)
           },
-          ignored_attributes: :any,
-          prohibited_attributes: Set.new([:x])
+          on_unknown: :reject,
+          exceptions: Set[:c]
         )
       }
 
-      it "raises error if the attribute is given" do
+      it "raises with unknown attribute" do
         expect {
-          type.coerce(a:123, b:true, x: [])
-        }.to raise_error(StrongJSON::Type::UnexpectedAttributeError)
+          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)
       end
     end
   end
@@ -126,8 +85,8 @@ describe StrongJSON::Type::Object do
         {
           a: StrongJSON::Type::Optional.new(StrongJSON::Type::Base.new(:numeric))
         },
-        ignored_attributes: nil,
-        prohibited_attributes: Set.new
+        on_unknown: :reject,
+        exceptions: Set[]
       )
     }
 
@@ -151,8 +110,8 @@ describe StrongJSON::Type::Object do
           a: StrongJSON::Type::Base.new(:numeric),
           b: StrongJSON::Type::Base.new(:string)
         },
-        ignored_attributes: nil,
-        prohibited_attributes: Set.new
+        on_unknown: :reject,
+        exceptions: Set[]
       )
     }
 
@@ -164,4 +123,73 @@ describe StrongJSON::Type::Object do
       expect(type =~ {}).to be_falsey
     end
   end
+
+  describe "#ignore" do
+    let (:type) {
+      StrongJSON::Type::Object.new(
+        { a: StrongJSON::Type::Base.new(:numeric) },
+        on_unknown: :reject,
+        exceptions: Set[]
+      )
+    }
+
+    context "if no argument is given" do
+      it "ignores all unknown attributes" do
+        updated_type = type.ignore()
+        expect(updated_type.on_unknown).to eq(:ignore)
+        expect(updated_type.exceptions).to eq(Set[])
+      end
+    end
+
+
+    context "if list of Symbol is given" do
+      it "ignores specified attributes but raises unknowns" do
+        updated_type = type.ignore(:x, :y)
+        expect(updated_type.on_unknown).to eq(:reject)
+        expect(updated_type.exceptions).to eq(Set[:x, :y])
+      end
+    end
+
+    context "if except keyword is specified" do
+      it "raises unknowns but ignores specified attributes" do
+        updated_type = type.ignore(except: Set[:x, :y])
+        expect(updated_type.on_unknown).to eq(:ignore)
+        expect(updated_type.exceptions).to eq(Set[:x, :y])
+      end
+    end
+  end
+
+  describe "#reject" do
+    let (:type) {
+      StrongJSON::Type::Object.new(
+        { a: StrongJSON::Type::Base.new(:numeric) },
+        on_unknown: :reject,
+        exceptions: Set[]
+      )
+    }
+
+    context "if no argument is given" do
+      it "raises on any unknown attribute" do
+        updated_type = type.reject()
+        expect(updated_type.on_unknown).to eq(:reject)
+        expect(updated_type.exceptions).to eq(Set[])
+      end
+    end
+
+    context "if list of Symbol is given" do
+      it "raises unknowns but ignores specified attributes" do
+        updated_type = type.reject(:x, :y)
+        expect(updated_type.on_unknown).to eq(:ignore)
+        expect(updated_type.exceptions).to eq(Set[:x, :y])
+      end
+    end
+
+    context "if except keyword is specified" do
+      it "ignores specified attributes but raises unknowns" do
+        updated_type = type.reject(except: Set[:x, :y])
+        expect(updated_type.on_unknown).to eq(:reject)
+        expect(updated_type.exceptions).to eq(Set[:x, :y])
+      end
+    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.10"
 end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.1.2
 platform: ruby
 authors:
 - Soutaro Matsumoto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-28 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.10'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.10'
+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"
@@ -81,20 +26,25 @@ 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/polyfill.rbs
+- sig/strong_json.rbs
+- sig/type.rbs
 - spec/array_spec.rb
 - spec/basetype_spec.rb
 - spec/case_subsumption_operator_spec.rb
 - spec/enum_spec.rb
 - spec/error_spec.rb
+- spec/hash_spec.rb
 - spec/json_spec.rb
 - spec/literal_spec.rb
 - spec/object_spec.rb
@@ -105,7 +55,7 @@ licenses:
 - MIT
 metadata:
   steep_types: sig
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -120,9 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Type check JSON objects
 test_files:
@@ -131,6 +80,7 @@ test_files:
 - spec/case_subsumption_operator_spec.rb
 - spec/enum_spec.rb
 - spec/error_spec.rb
+- spec/hash_spec.rb
 - spec/json_spec.rb
 - spec/literal_spec.rb
 - spec/object_spec.rb

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,64 +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 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>
-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