requisite 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fefe3a8b4f675162d0bf7ac4b8302d84845fd9437e1e358493acf1960d677207
-  data.tar.gz: 307e2a0d91ba1be12292e58da0dd89ad5deeed52b469e7c7c0b28b4ec4ff2b55
+  metadata.gz: 22ae33af68416be1beb8abf9c3384934e4c93f1a46ab089c05436956a7391e3a
+  data.tar.gz: ef8a85a1fb0af0aedee42f635283590306016e0101adef510365f065ae6cb908
 SHA512:
-  metadata.gz: 341d9dcc25d67f708964dce7807b2b69e90fc11426f1190d4664506d2bf08451afabeace89adef613efba625f3c3fb6f842cc8cf3e5aa554d422db5cc8696032
-  data.tar.gz: '03853411c5332125af440424210f55fe067d23ba4308aca4de8a8bc1a2f2d899fa246542543b00f75ef6e61d80db780f15d638d21c25081a0f01fa853549fe14'
+  metadata.gz: 35f9ebfbf4ff91f05067c422e27b13caed813d926093f0c5bf792375be57cdb03a5451e8690a999417826334d762484e63eb58025c0eafda6bade2db210d5615
+  data.tar.gz: 362d50d708a1d1f80002dc751fa41cf5baf8ed1dea3cd66725e80472df2fd1dcb9d9224964699cd06a3deecfccd8e7c10466dc852a89731b8b55169f65c0fceb

data/.gitignore

@@ -1 +1,2 @@
-*.gem
+*.gem
+Gemfile.lock

data/lib/requisite/boundary_object.rb

@@ -9,7 +9,7 @@ module Requisite
           result = self.send(:parse_typed_hash, resolved_name, options[:typed_hash]) if options[:typed_hash]
           result = self.send(:parse_scalar_hash, resolved_name) if options[:scalar_hash]
           result = self.send(:parse_typed_array, resolved_name, options[:typed_array]) if options[:typed_array]
-          result = options[:default] if (options[:default] && empty_result?(result))
+          result = options[:default] if (options.key?(:default) && empty_result?(result))
           raise_bad_type_if_type_mismatch(result, options[:type]) if options[:type] && result
           result = result.to_s if options[:stringify]
           result
@@ -50,7 +50,7 @@ module Requisite
     self.singleton_class.send(:alias_method, :a!, :attribute!)
 
     def raise_bad_type_if_type_mismatch(value, desired_type)
-      raise BadTypeError.new(value, desired_type) unless (value.kind_of?(desired_type)) || ((value.kind_of?(TrueClass) || value.kind_of?(TrueClass)) && desired_type == Requisite::Boolean)
+      raise BadTypeError.new(value, desired_type) unless (value.kind_of?(desired_type)) || ((value.kind_of?(TrueClass) || value.kind_of?(FalseClass)) && desired_type == Requisite::Boolean)
     end
 
     def raise_not_implemented_for_attribute(name)

data/lib/requisite/version.rb

@@ -1,3 +1,3 @@
 module Requisite
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/test/requisite/api_model_test.rb

@@ -1,5 +1,4 @@
 require 'test_helper'
-# require_relative '../dummy_api_model'
 
 module Requisite
   class DummyApiModel < Requisite::ApiModel
@@ -11,16 +10,16 @@ module Requisite
       response = DummyApiModel.new
       def response.a; 'A'; end
       def response.b; 2; end
-      response.to_hash.must_equal( :a => 'A', :b => 2 )
-      response.must_respond_to :a
-      response.must_respond_to :b
+      _(response.to_hash).must_equal( :a => 'A', :b => 2 )
+      _(response).must_respond_to :a
+      _(response).must_respond_to :b
     end
 
     it 'attribute provides a default implementation of calling a hash model' do
       DummyApiModel.serialized_attributes { attribute :c }
       mock = {:c => 'C'}
       response = DummyApiModel.new(mock)
-      response.to_hash.must_equal( :c => 'C' )
+      _(response.to_hash).must_equal( :c => 'C' )
     end
 
     let(:params_hash) { {:c => 'C', :num => 12} }
@@ -28,89 +27,101 @@ module Requisite
     it 'attribute provides a default implementation of calling a model' do
       DummyApiModel.serialized_attributes { attribute :c }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:c => 'C')
+      _(response.to_hash).must_equal(:c => 'C')
     end
 
     it 'attribute can work with a default' do
       DummyApiModel.serialized_attributes { attribute :c, default: 'see' }
       response = DummyApiModel.new
-      response.to_hash.must_equal(:c => 'see')
+      _(response.to_hash).must_equal(:c => 'see')
     end
 
     it 'ignores default if value given' do
       DummyApiModel.serialized_attributes { attribute :num, default: 0 }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => 12)
+      _(response.to_hash).must_equal(:num => 12)
+    end
+
+    it 'can set a default value of true for a boolean attribute' do
+      DummyApiModel.serialized_attributes { attribute :truthy_val, type: Requisite::Boolean, default: true }
+      response = DummyApiModel.new
+      _(response.to_hash).must_equal(:truthy_val => true)
+    end
+
+    it 'can set a default value of false for a boolean attribute' do
+      DummyApiModel.serialized_attributes { attribute :truthy_val, type: Requisite::Boolean, default: false }
+      response = DummyApiModel.new
+      _(response.to_hash).must_equal(:truthy_val => false)
     end
 
     it 'attribute can be set to stringify fields' do
       DummyApiModel.serialized_attributes { attribute :num, stringify: true }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => '12')
+      _(response.to_hash).must_equal(:num => '12')
     end
 
     it 'attribute can be set to rename fields' do
       DummyApiModel.serialized_attributes { attribute :my_num, rename: :num }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:my_num => 12)
+      _(response.to_hash).must_equal(:my_num => 12)
     end
 
     it 'attribute can assert type of a field' do
       DummyApiModel.serialized_attributes { attribute :num, type: String }
       response = DummyApiModel.new(params_hash)
-      proc { response.to_hash }.must_raise(BadTypeError)
+      _(proc { response.to_hash }).must_raise(BadTypeError)
     end
 
     it 'with_type! helper raises on mismatched type' do
       model = DummyApiModel.new()
-      proc { model.send(:with_type!, String) { 1 + 2 }}.must_raise(Requisite::BadTypeError)
+      _(proc { model.send(:with_type!, String) { 1 + 2 }}).must_raise(Requisite::BadTypeError)
     end
 
     it 'first_attribute_from_model helper finds first matching attriubute' do
       model = DummyApiModel.new(:oh => 12, :a => nil, :b => 'B', :c => 'C')
-      model.send(:first_attribute_from_model, :a, :b, :c).must_equal('B')
+      _(model.send(:first_attribute_from_model, :a, :b, :c)).must_equal('B')
     end
 
     it 'attribute can assert type of a boolean field' do
       DummyApiModel.serialized_attributes { attribute :truthy_val, type: Requisite::Boolean }
       response = DummyApiModel.new(:truthy_val => false)
-      response.to_hash.must_equal(:truthy_val => false)
+      _(response.to_hash).must_equal(:truthy_val => false)
     end
 
     it 'attribute does not include values of nil' do
       DummyApiModel.serialized_attributes { attribute :num, type: String }
       response = DummyApiModel.new({:num => nil})
-      response.to_hash.must_equal({})
+      _(response.to_hash).must_equal({})
     end
 
     it 'attribute includes values of nil if permitted' do
       DummyApiModel.serialized_attributes { attribute :num, type: String }
       response = DummyApiModel.new({:num => nil})
-      response.to_hash(show_nil: true).must_equal({:num => nil})
+      _(response.to_hash(show_nil: true)).must_equal({:num => nil})
     end
 
     it 'attribute can be stringified and renamed with default fields' do
       DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22 }
       response = DummyApiModel.new
-      response.to_hash.must_equal(:my_num => '22')
+      _(response.to_hash).must_equal(:my_num => '22')
     end
 
     it 'attribute can be stringified after type check' do
       DummyApiModel.serialized_attributes { attribute :num, stringify: true, type: Fixnum }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => '12')
+      _(response.to_hash).must_equal(:num => '12')
     end
 
     it 'attribute type checks after rename' do
       DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, type: String }
       response = DummyApiModel.new(params_hash)
-      proc { response.to_hash }.must_raise(BadTypeError)
+      _(proc { response.to_hash }).must_raise(BadTypeError)
     end
 
     it 'attribute can be stringified, renamed, defaulted and have type checking on a field' do
       DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22, type: String }
       response = DummyApiModel.new
-      proc { response.to_hash }.must_raise(BadTypeError)
+      _(proc { response.to_hash }).must_raise(BadTypeError)
     end
 
     let(:invalid_params_hash) { {:d => nil} }
@@ -118,32 +129,32 @@ module Requisite
     it "attribute! raises an error if not found on model" do
       DummyApiModel.serialized_attributes { attribute! :d }
       response = DummyApiModel.new(invalid_params_hash)
-      proc { response.to_hash }.must_raise(NotImplementedError, "'d' not found on model")
+      _(proc { response.to_hash }).must_raise(NotImplementedError, "'d' not found on model")
     end
 
     it 'attribute! does not raise an error if value on model is false' do
       params_hash = {:d => false}
       DummyApiModel.serialized_attributes { attribute! :d }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal({d: false})
+      _(response.to_hash).must_equal({d: false})
     end
 
     it 'attribute! can be set to stringify fields' do
       DummyApiModel.serialized_attributes { attribute! :num, stringify: true }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => '12')
+      _(response.to_hash).must_equal(:num => '12')
     end
 
     it 'attribute! can be set to rename fields' do
       DummyApiModel.serialized_attributes { attribute! :my_num, rename: :num }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:my_num => 12)
+      _(response.to_hash).must_equal(:my_num => 12)
     end
 
     it 'sets the model from a hash' do
       DummyApiModel.serialized_attributes { }
       response = DummyApiModel.new(params_hash)
-      response.model.must_equal(params_hash)
+      _(response.model).must_equal(params_hash)
     end
 
     it 'sets the model from an object' do
@@ -152,39 +163,39 @@ module Requisite
       mc.b = 2
       DummyApiModel.serialized_attributes { attribute :a }
       response = DummyApiModel.new(mc)
-      response.model.must_equal(mc)
-      response.to_hash.must_equal(:a => 'a')
+      _(response.model).must_equal(mc)
+      _(response.to_hash).must_equal(:a => 'a')
     end
 
     it 'has alias a for attribute' do
       DummyApiModel.serialized_attributes { a :num }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => 12)
+      _(response.to_hash).must_equal(:num => 12)
     end
 
     it 'has alias a! for attribute!' do
       DummyApiModel.serialized_attributes { a! :num }
       response = DummyApiModel.new(params_hash)
-      response.to_hash.must_equal(:num => 12)
+      _(response.to_hash).must_equal(:num => 12)
     end
 
     it 'can convert to json' do
       DummyApiModel.serialized_attributes { a! :num }
       response = DummyApiModel.new(params_hash)
-      response.to_json.must_equal("{\"num\":12}")
+      _(response.to_json).must_equal("{\"num\":12}")
     end
 
     it 'drops non-listed parameters' do
       DummyApiModel.serialized_attributes { attribute :num }
       response = DummyApiModel.new({num: 12, other: 'value'})
-      response.to_hash.must_equal(:num => 12)
+      _(response.to_hash).must_equal(:num => 12)
     end
 
     it 'works with ActionController::Parameters' do
       DummyApiModel.serialized_attributes { attribute :num }
       params = ActionController::Parameters.new(num: 12)
       response = DummyApiModel.new(params)
-      response.to_hash.must_equal(:num => 12)
+      _(response.to_hash).must_equal(:num => 12)
     end
 
     describe 'with nested structures' do
@@ -193,13 +204,13 @@ module Requisite
         it 'allows arrays of one type' do
           DummyApiModel.serialized_attributes { attribute :ids, typed_array: Fixnum }
           response = DummyApiModel.new({ids: [1, 2, 3]})
-          response.to_hash.must_equal(:ids => [1, 2, 3])
+          _(response.to_hash).must_equal(:ids => [1, 2, 3])
         end
 
         it 'raises errors when array has a wrongly typed value' do
           DummyApiModel.serialized_attributes { attribute :ids, typed_array: Requisite::Boolean }
           response = DummyApiModel.new({ids: [true, 'value', false]})
-          Proc.new {response.to_hash}.must_raise(BadTypeError)
+          _(Proc.new {response.to_hash}).must_raise(BadTypeError)
         end
       end
 
@@ -207,42 +218,42 @@ module Requisite
         it 'drops non listed parameters in nested hashes' do
           DummyApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric, bool: Requisite::Boolean } }
           response = DummyApiModel.new({data: { num: 12, value: 'x', bool: true }})
-          response.to_hash.must_equal(:data => { :num => 12, :bool => true })
+          _(response.to_hash).must_equal(:data => { :num => 12, :bool => true })
         end
 
         it 'can stringify nested hashes' do
           DummyApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric }, stringify: true }
           response = DummyApiModel.new({data: { num: 12, value: 'x' }})
-          response.to_hash.must_equal(:data => "{:num=>12}")
+          _(response.to_hash).must_equal(:data => "{:num=>12}")
         end
 
         it 'raises an error when nested hash values of the wrong type' do
           DummyApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric } }
-          Proc.new {DummyApiModel.new({data: { num: '12'}}).to_hash}.must_raise(BadTypeError)
+          _(Proc.new {DummyApiModel.new({data: { num: '12'}}).to_hash}).must_raise(BadTypeError)
         end
 
         it 'can rename param and work with nested hashes' do
           DummyApiModel.serialized_attributes { attribute :my_data, typed_hash: { num: Numeric }, rename: :data }
           response = DummyApiModel.new({data: { num: 12, value: 'x' }})
-          response.to_hash.must_equal(:my_data => { :num => 12 })
+          _(response.to_hash).must_equal(:my_data => { :num => 12 })
         end
 
         it 'can set a default value for a nested hash' do
           DummyApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric }, default: { num: 4 } }
           response = DummyApiModel.new({data: { value: 'x' }})
-          response.to_hash.must_equal(:data => { :num => 4 })
+          _(response.to_hash).must_equal(:data => { :num => 4 })
         end
 
         it 'drops non listed fields with attribute!' do
           DummyApiModel.serialized_attributes { attribute! :data, typed_hash: { num: Numeric } }
           response = DummyApiModel.new({data: { num: 12, value: 'x' }})
-          response.to_hash.must_equal(:data => { :num => 12 })
+          _(response.to_hash).must_equal(:data => { :num => 12 })
         end
 
         it 'attribute! does not raise an error with missing values in hash' do
           DummyApiModel.serialized_attributes { attribute! :data, typed_hash: { num: Numeric } }
           response = DummyApiModel.new({data: { value: 'x' }})
-          response.to_hash.must_equal(:data => { })
+          _(response.to_hash).must_equal(:data => { })
         end
       end
 
@@ -250,19 +261,19 @@ module Requisite
         it 'should parse scalar hashes permitting anything scalar' do
           DummyApiModel.serialized_attributes { attribute :data, scalar_hash: true }
           response = DummyApiModel.new({data: { num: 12, value: 'x', :truthy => false }})
-          response.to_hash.must_equal(:data => { :num => 12, :value => 'x', :truthy => false })
+          _(response.to_hash).must_equal(:data => { :num => 12, :value => 'x', :truthy => false })
         end
 
         it 'should parse a renamed scalar hash' do
           DummyApiModel.serialized_attributes { attribute :my_data, scalar_hash: true, rename: :data }
           response = DummyApiModel.new({data: { num: 12, value: 'x' }})
-          response.to_hash.must_equal(:my_data => { :num => 12, :value => 'x' })
+          _(response.to_hash).must_equal(:my_data => { :num => 12, :value => 'x' })
         end
 
         it 'should stringify a scalar hash' do
           DummyApiModel.serialized_attributes { attribute :data, scalar_hash: true, stringify: true }
           response = DummyApiModel.new({data: { num: 12, value: 'x' }})
-          response.to_hash.must_equal(:data => "{:num=>12, :value=>\"x\"}")
+          _(response.to_hash).must_equal(:data => "{:num=>12, :value=>\"x\"}")
         end
 
         it 'should parse scalar hashes permitting anything scalar with object' do
@@ -271,13 +282,13 @@ module Requisite
           mc.b = { num: 12, value: 'x' }
           DummyApiModel.serialized_attributes { attribute :b, scalar_hash: true }
           response = DummyApiModel.new(mc)
-          response.to_hash.must_equal(:b => { :num => 12, :value => 'x' })
+          _(response.to_hash).must_equal(:b => { :num => 12, :value => 'x' })
         end
 
         it 'should fail to parse scalar hashes when non scalar values present' do
           DummyApiModel.serialized_attributes { attribute :data, scalar_hash: true }
-          Proc.new { DummyApiModel.new({data: { num: 12, value: { nested: 'value' } }}).to_hash}.must_raise(BadTypeError)
-          Proc.new { DummyApiModel.new({data: { num: 12, value: ['array value'] }}).to_hash}.must_raise(BadTypeError)
+          _(Proc.new { DummyApiModel.new({data: { num: 12, value: { nested: 'value' } }}).to_hash}).must_raise(BadTypeError)
+          _(Proc.new { DummyApiModel.new({data: { num: 12, value: ['array value'] }}).to_hash}).must_raise(BadTypeError)
         end
 
         it 'should fail to parse scalar hashes permitting anything scalar with object' do
@@ -286,25 +297,25 @@ module Requisite
           mc.b = { value: { nested: 'value' } }
           DummyApiModel.serialized_attributes { attribute :b, scalar_hash: true }
           response = DummyApiModel.new(mc)
-          Proc.new { response.to_hash }.must_raise(BadTypeError)
+          _(Proc.new { response.to_hash }).must_raise(BadTypeError)
         end
 
         it 'can set a default value for a scalar hash' do
           DummyApiModel.serialized_attributes { attribute :data, scalar_hash: true, default: { num: 9, value: 'y' } }
           response = DummyApiModel.new({data: { }})
-          response.to_hash.must_equal(:data => { :num => 9, :value => 'y' })
+          _(response.to_hash).must_equal(:data => { :num => 9, :value => 'y' })
         end
 
         it 'doesnt raise with attribute! when an empty hash passed' do
           DummyApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
           response = DummyApiModel.new({data: {}})
-          response.to_hash.must_equal(:data => {})
+          _(response.to_hash).must_equal(:data => {})
         end
 
         it 'raises with attribute! when nil is passed' do
           DummyApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
           response = DummyApiModel.new({data: nil})
-          Proc.new {response.to_hash}.must_raise(NotImplementedError)
+          _(Proc.new {response.to_hash}).must_raise(NotImplementedError)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: requisite
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - James Osler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-06 00:00:00.000000000 Z
+date: 2022-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -98,7 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Strongly defined models for HTTP APIs