strong_json 1.0.1 → 2.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0035c9edc36454dc79ce83f91e948c91c7a10935cc4c7dc1ab3c50113c209100
-  data.tar.gz: b77289a1d16f20e2f29875e5156917f984587ad70f6d9bddd4aa4d7a62f40cb9
+  metadata.gz: 3024051238c907ceb915ad211936b82d0c4422f6980f2abeff76a667017f6a0a
+  data.tar.gz: 9f9d1efa03cb0d35155837928577062ae696066841d50a6495c33f40f7fee6ec
 SHA512:
-  metadata.gz: d230d14df235f9831ea73287abd9aa6018053ead823a7816bb73516adfc3599e29d727295055ab2439c6342592ebe1331e91a74df775adff8f550524b5be2d41
-  data.tar.gz: ac439273a3b6ef148f2f135b3f3c9820caf25831f8bfaae554971830b1c009d42242a6a614b7786eb2669c551e356eb66823375f2bbecf9f2a372bb9b3154228
+  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/.gitignore

@@ -1,4 +1,5 @@
 /.bundle/
+/vendor/bundle/
 /.yardoc
 /Gemfile.lock
 /_yardoc/

data/.ruby-version

@@ -1 +1 @@
-2.5.1
+2.6.6

data/.travis.yml

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

data/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 ## master
 
+## 2.1.2
+
+* Update Steep
+
+## 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
+
+## 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
+
 ## 1.0.1 (2019-05-29)
 
 * Improve enum error reporting

data/Gemfile

@@ -2,3 +2,7 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in strong_json.gemspec
 gemspec
+
+gem "rake"
+gem "rspec"
+gem "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
 
@@ -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)
@@ -86,6 +80,11 @@ object(attrs).prohibit!(Set.new([:created_at, :updated_at]))  # Destructive vers
 * The value must be an array
 * All elements in the array must be value of given `type`
 
+### hash(type)
+
+* The value must be an object
+* All values in the object must be value of given `type`
+
 ### optional(type)
 
 * The value can be `nil` (or not contained in an object)
@@ -118,6 +117,7 @@ enum(person,
 ### Base types
 
 * `number` The value must be an instance of `Numeric`
+* `integer` The value must be an instance of `Integer`
 * `string` The value must be an instance of `String`
 * `boolean` The value must be `true` or `false`
 * `numeric` The value must be an instance of `Numeric` or a string which represents a number
@@ -133,6 +133,7 @@ enum(person,
 There are some alias for `optional(base)`, where base is base types, as the following:
 
 * `number?`
+* `integer?`
 * `string?`
 * `boolean?`
 * `numeric?`

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

@@ -8,7 +8,7 @@ class StrongJSON
     end
 
     def to_s
-      format() unless @string
+      format() unless defined?(@string)
       @string
     end
 
@@ -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,6 @@ class StrongJSON
     end
 
     def format_single_alias(name, type)
-      # @type const PrettyPrint: any
       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: any
       PrettyPrint.singleline_format do |pp|
         pretty(type, pp, expand_alias: expand_alias)
       end

data/lib/strong_json/type.rb

@@ -15,12 +15,12 @@ class StrongJSON
 
     module WithAlias
       def alias
-        @alias
+        defined?(@alias) ? @alias : nil
       end
 
       def with_alias(name)
         _ = dup.tap do |copy|
-          copy.instance_eval do
+          copy.instance_eval do |x|
             @alias = name
           end
         end
@@ -44,6 +44,8 @@ class StrongJSON
           true
         when :number
           value.is_a?(Numeric)
+        when :integer
+          value.is_a?(Integer)
         when :string
           value.is_a?(String)
         when :boolean
@@ -74,7 +76,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Base)
-          # @type var other: Base<any>
           other.type == type
         end
       end
@@ -109,7 +110,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Optional)
-          # @type var other: Optional<any>
           other.type == type
         end
       end
@@ -141,7 +141,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Literal)
-          # @type var other: Literal<any>
           other.value == value
         end
       end
@@ -178,7 +177,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Array)
-          # @type var other: Array<any>
           other.type == type
         end
       end
@@ -192,47 +190,45 @@ 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))
-        unless object.is_a?(Hash)
+        unless object.is_a?(::Hash)
           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
-
-        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)
+        object = object.dup
+        unknown_attributes = Set.new(object.keys) - fields.keys
+
+        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>
+        # @type var result: ::Hash[Symbol, untyped]
         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 +236,35 @@ 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)
+      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
+      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
 
@@ -276,10 +278,9 @@ class StrongJSON
 
       def ==(other)
         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
 
@@ -325,7 +326,6 @@ class StrongJSON
 
       def ==(other)
         if other.is_a?(Enum)
-          # @type var other: Enum<any>
           other.types == types &&
             other.detector == detector
         end
@@ -336,6 +336,36 @@ class StrongJSON
       end
     end
 
+    class Hash
+      include Match
+      include WithAlias
+
+      # @dynamic type
+      attr_reader :type
+
+      def initialize(type)
+        @type = type
+      end
+
+      def coerce(value, path: ErrorPath.root(self))
+        if value.is_a?(::Hash)
+          (_ = {}).tap do |result|
+            value.each do |k, v|
+              result[k] = type.coerce(v, path: path.dig(key: k, type: type))
+            end
+          end
+        else
+          raise TypeError.new(path: path, value: value)
+        end
+      end
+
+      def ==(other)
+        if other.is_a?(Hash)
+          other.type == type
+        end
+      end
+    end
+
     class UnexpectedAttributeError < StandardError
       # @dynamic path, attribute
       attr_reader :path, :attribute