strong_json 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd9a6dd9efbb0ccca7cd5dfc14a415b4f408138724e5c4a4fe58d7fcc8fccafe
-  data.tar.gz: 02a451a69abca02dfdb418b13302b3bb6545cf23b0ec302698b65d2127d6f6d4
+  metadata.gz: 4b06583a5049ceb64b418d9dbfa9d9b024487c116a2b84cda2effc8f20f47dfc
+  data.tar.gz: 3998a14cfa6c87822c9d8da3d510c64cdb3ec8ca49762e104564c2109711ca8e
 SHA512:
-  metadata.gz: 4026edd18f863953d03652c5ea691a5ad6a88ba1db2ca8f5181da60974ebd70d10cf6cb09bc0d836583e285a9279d70b1dda43178881a3da37093e40ffd793b3
-  data.tar.gz: e2ca4033fe34c2f9b433c6a92f8b44484b7f30dfb89ca10fb5b0bed8a21370eb463e8444f5d28c3575c133bb879868c762fba36620a78f27b0886df59f1f970a
+  metadata.gz: 3eea214df1267ca23eb4ca45150c8a967c2f928738a225ccc1b42d2a5dbace87593d1ae8184554e47e40012f3e694b5c8f333a58dcb90fb680e73401b5dd49b6
+  data.tar.gz: 5e974fe31499668b39a8dd953267f2a7ef2ea0b070dcc1c48dfa14b7c1ac33df5a57d7dd20a039bfe1cd16dfa52de0a91c8c8a1bc3445fd48b092b007437d827

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## master
 
+## 2.0.0 (2019-06-28)
+
+* [17](https://github.com/soutaro/strong_json/pull/17): Revise `Object` type _ignore_/_reject_ API
+
 ## 1.1.0 (2019-06-09)
 
 * [#15](https://github.com/soutaro/strong_json/pull/15): Add `hash` type

data/README.md

@@ -59,26 +59,20 @@ If an attribute has a value which does not match with given type, the `coerce` m
 
 #### Ignoring unknown attributes
 
-`Object` type ignores unknown attributes by default.
-You can reject the unknown attributes.
+You can use `ignore` method to ignore unknown attributes.
 
 ```
-object(attrs).ignore(Set.new)       # Ignores nothing (== raise an error)
-object(attrs).ignore!(Set.new)      # Destructive version
+object(attrs).ignore()                     # Ignores all unknown attributes.
+object(attrs).ignore(:x, :y)               # Ignores :x and :y, but rejects other unknown attributes.
+object(attrs).ignore(except: Set[:x, :y])  # Rejects :x and :y, but ignores other unknown attributes.
 ```
 
-You can selectively ignore attributes:
+`Object` also provides `reject` method to do the opposite.
 
 ```
-object(attrs).ignore(Set.new([:a, :b, :c]))   # Ignores only :a, :b, and :c
-object(attrs).ignore(:any)                    # Ignores everything (default)
-```
-
-`Object` also has `prohibit` method to specify attributes to make the type check failed.
-
-```
-object(attrs).prohibit(Set.new([:created_at, :updated_at]))   # Make type check failed if :created_at or :updated_at included
-object(attrs).prohibit!(Set.new([:created_at, :updated_at]))  # Destructive version
+object(attrs).reject()                     # Rejects all unknown attributes. (default)
+object(attrs).reject(:x, :y)               # Rejects :x and :y, but ignores other unknown attributes.
+object(attrs).reject(except: Set[:x, :y])  # Ignores :x and :y, but rejects other unknown attributes.
 ```
 
 ### array(type)

data/lib/strong_json/type.rb

@@ -192,13 +192,13 @@ class StrongJSON
       include Match
       include WithAlias
 
-      # @dynamic fields, ignored_attributes, prohibited_attributes
-      attr_reader :fields, :ignored_attributes, :prohibited_attributes
+      # @dynamic fields, on_unknown, exceptions
+      attr_reader :fields, :on_unknown, :exceptions
 
-      def initialize(fields, ignored_attributes:, prohibited_attributes:)
+      def initialize(fields, on_unknown:, exceptions:)
         @fields = fields
-        @ignored_attributes = ignored_attributes
-        @prohibited_attributes = prohibited_attributes
+        @on_unknown = on_unknown
+        @exceptions = exceptions
       end
 
       def coerce(object, path: ErrorPath.root(self))
@@ -206,33 +206,31 @@ class StrongJSON
           raise TypeError.new(path: path, value: object)
         end
 
-        unless (intersection = Set.new(object.keys).intersection(prohibited_attributes)).empty?
-          raise UnexpectedAttributeError.new(path: path, attribute: intersection.to_a.first)
-        end
+        object = object.dup
+        unknown_attributes = Set.new(object.keys) - fields.keys
 
-        case attrs = ignored_attributes
-        when :any
-          object = object.dup
-          extra_keys = Set.new(object.keys) - Set.new(fields.keys)
-          extra_keys.each do |key|
-            object.delete(key)
+        case on_unknown
+        when :reject
+          unknown_attributes.each do |attr|
+            if exceptions.member?(attr)
+              object.delete(attr)
+            else
+              raise UnexpectedAttributeError.new(path: path, attribute: attr)
+            end
           end
-        when Set
-          object = object.dup
-          attrs.each do |key|
-            object.delete(key)
+        when :ignore
+          unknown_attributes.each do |attr|
+            if exceptions.member?(attr)
+              raise UnexpectedAttributeError.new(path: path, attribute: attr)
+            else
+              object.delete(attr)
+            end
           end
         end
 
         # @type var result: ::Hash<Symbol, any>
         result = {}
 
-        object.each do |key, _|
-          unless fields.key?(key)
-            raise UnexpectedAttributeError.new(path: path, attribute: key)
-          end
-        end
-
         fields.each do |key, type|
           result[key] = type.coerce(object[key], path: path.dig(key: key, type: type))
         end
@@ -240,29 +238,37 @@ class StrongJSON
         _ = result
       end
 
-      def ignore(attrs)
-        Object.new(fields, ignored_attributes: attrs, prohibited_attributes: prohibited_attributes)
-      end
-
-      def ignore!(attrs)
-        @ignored_attributes = attrs
-        self
-      end
-
-      def prohibit(attrs)
-        Object.new(fields, ignored_attributes: ignored_attributes, prohibited_attributes: attrs)
+      # @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[])
+        else
+          if except
+            Object.new(fields, on_unknown: :ignore, exceptions: except)
+          else
+            Object.new(fields, on_unknown: :reject, exceptions: Set.new(ignores))
+          end
+        end
       end
 
-      def prohibit!(attrs)
-        @prohibited_attributes = attrs
-        self
+      # @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[])
+        else
+          if except
+            Object.new(fields, on_unknown: :reject, exceptions: except)
+          else
+            Object.new(fields, on_unknown: :ignore, exceptions: Set.new(rejecteds))
+          end
+        end
       end
 
       def update_fields
         fields.dup.yield_self do |fields|
           yield fields
 
-          Object.new(fields, ignored_attributes: ignored_attributes, prohibited_attributes: prohibited_attributes)
+          Object.new(fields, on_unknown: on_unknown, exceptions: exceptions)
         end
       end
 
@@ -278,8 +284,8 @@ class StrongJSON
         if other.is_a?(Object)
           # @type var other: Object<any>
           other.fields == fields &&
-            other.ignored_attributes == ignored_attributes &&
-            other.prohibited_attributes == prohibited_attributes
+            other.on_unknown == on_unknown &&
+            other.exceptions == exceptions
         end
       end
 

data/lib/strong_json/types.rb

@@ -3,9 +3,9 @@ class StrongJSON
     # @type method object: (?Hash<Symbol, ty>) -> Type::Object<any>
     def object(fields = {})
       if fields.empty?
-        Type::Object.new(fields, ignored_attributes: nil, prohibited_attributes: Set.new)
+        Type::Object.new(fields, on_unknown: :ignore, exceptions: Set.new)
       else
-        Type::Object.new(fields, ignored_attributes: :any, prohibited_attributes: Set.new)
+        Type::Object.new(fields, on_unknown: :reject, exceptions: Set.new)
       end
     end
 

data/lib/strong_json/version.rb

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

data/sig/type.rbi

@@ -60,16 +60,26 @@ class StrongJSON::Type::Object<'t>
   include WithAlias
 
   attr_reader fields: ::Hash<Symbol, _Schema<any>>
-  attr_reader ignored_attributes: :any | Set<Symbol> | nil
-  attr_reader prohibited_attributes: Set<Symbol>
+  attr_reader on_unknown: :ignore | :reject
+  attr_reader exceptions: Set<Symbol>
 
-  def initialize: (::Hash<Symbol, _Schema<'t>>, ignored_attributes: :any | Set<Symbol> | nil, prohibited_attributes: Set<Symbol>) -> any
+  def initialize: (::Hash<Symbol, _Schema<'t>>, on_unknown: :ignore | :reject, exceptions: Set<Symbol>) -> any
   def coerce: (any, ?path: ErrorPath) -> 't
 
-  def ignore: (:any | Set<Symbol> | nil) -> self
-  def ignore!: (:any | Set<Symbol> | nil) -> self
-  def prohibit: (Set<Symbol>) -> self
-  def prohibit!: (Set<Symbol>) -> self
+  # 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
 

data/spec/enum_spec.rb

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

data/spec/json_spec.rb

@@ -3,7 +3,7 @@ require "strong_json"
 describe "StrongJSON.new" do
   it "tests the structure of a JSON object" do
     s = StrongJSON.new do
-      let :item, object(name: string, count: numeric, price: numeric).ignore(Set.new([:comment]))
+      let :item, object(name: string, count: numeric, price: numeric).ignore(:comment)
       let :items, array(item)
       let :checkout,
           object(items: items,

data/spec/object_spec.rb

@@ -8,114 +8,73 @@ 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: :raise,
+        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)
-      }
-    end
-
     it "rejects objects with missing fields" do
       type = StrongJSON::Type::Object.new(
         {
           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: :raise,
+        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: :raise,
+        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: :raise,
+        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: :raise,
+        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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strong_json
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Soutaro Matsumoto
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-09 00:00:00.000000000 Z
+date: 2019-06-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler