requisite 0.4.1 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fefe3a8b4f675162d0bf7ac4b8302d84845fd9437e1e358493acf1960d677207
-  data.tar.gz: 307e2a0d91ba1be12292e58da0dd89ad5deeed52b469e7c7c0b28b4ec4ff2b55
+  metadata.gz: 828a5465ab9ec59c47bda9e6ab72c34e9bdbab05536ab99ad45c3cdaec933f16
+  data.tar.gz: b1c387023439e720d6600310604828d672abd8dd4eabb25d0412bcec423c4529
 SHA512:
-  metadata.gz: 341d9dcc25d67f708964dce7807b2b69e90fc11426f1190d4664506d2bf08451afabeace89adef613efba625f3c3fb6f842cc8cf3e5aa554d422db5cc8696032
-  data.tar.gz: '03853411c5332125af440424210f55fe067d23ba4308aca4de8a8bc1a2f2d899fa246542543b00f75ef6e61d80db780f15d638d21c25081a0f01fa853549fe14'
+  metadata.gz: eb0c6e6e4cc10fb351e01334754196f2a65ced999a32980f416a2c226b4ea1a76a77b0a1b0523e408de9b372fc40676ab7e9482290f28d13d983947ae750a9f9
+  data.tar.gz: 3269605161e8264e04dc0640637a107d4db5ef079f635e31c674cc35cb409eb32ccb991a3f17bcebe4f31bedcd6616fbfb09856829a86f5a802f67f998df9ac1

data/.gitignore

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

data/README.md

@@ -38,7 +38,7 @@ class UserApiModel < Requisite::ApiModel
     attribute! :username
     attribute :real_name
   end
-  
+
   # method with the name of of an attribute will be called to calculate the mapped value
   def real_name
     "#{attribute_from_model(:first_name)} #{attribute_from_model(:last_name)}"
@@ -88,10 +88,10 @@ Example:
 class UserApiModel < Requisite::ApiModel
   serialized_attributes do
     attribute :id, stringify: true
-    attribute :custom_attributes, rename: :custom_data 
+    attribute :custom_attributes, rename: :custom_data
     attribute :is_awesome, default: true
     attribute :awesome_score, rename: :score, stringify: true, default: 9001
-    attribute :age, type: Fixnum,
+    attribute :age, type: Integer,
     attribute :tired, type: Requisite::Boolean
   end
 end
@@ -131,7 +131,7 @@ With typed hashes, only values specified with a type are permitted:
 ```ruby
 class UserApiModel < Requisite::ApiModel
   serialized_attributes do
-    attribute :data, typed_hash: { is_awesome: Requisite::Boolean, score: Fixnum, name: String  }
+    attribute :data, typed_hash: { is_awesome: Requisite::Boolean, score: Integer, name: String  }
   end
 end
 
@@ -198,7 +198,27 @@ class ApiUser < Requisite::ApiModel
     raise IdentifierNotFoundError unless identifier
   end
 end
-```  
+```
+
+#### Around each attribute
+
+An `around_each_attribute` method can be defined to wrap each attribute fetch in a block. This can be useful for instrumenting processing on a per attribute basis.
+
+```ruby
+class ApiUser < Requisite::ApiModel
+  serialized_attributes do
+    attribute :id, type: String
+    attribute :email, type: String
+  end
+
+  def around_each_attribute(name, &block)
+    start = Time.now
+    yield
+    end = Time.now
+    puts "Fetching #{name} took #{end - start}"
+  end
+end
+```
 
 #### Thanks
 

data/lib/requisite/boundary_object.rb

@@ -4,14 +4,17 @@ module Requisite
       def attribute(name, options={})
         attribute_keys << name
         define_method(name) do
-          resolved_name = options[:rename] || name
-          result = self.send(:convert, resolved_name)
-          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))
-          raise_bad_type_if_type_mismatch(result, options[:type]) if options[:type] && result
-          result = result.to_s if options[:stringify]
+          result = nil
+          self.send(:around_each_attribute, name) do
+            resolved_name = options[:rename] || name
+            result = self.send(:convert, resolved_name)
+            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.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]
+          end
           result
         end
       end
@@ -19,13 +22,16 @@ module Requisite
       def attribute!(name, options={})
         attribute_keys << name
         define_method(name) do
-          resolved_name = options[:rename] || name
-          result = self.send(:convert!, resolved_name)
-          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 = result.to_s if options[:stringify]
-          raise_bad_type_if_type_mismatch(result, options[:type]) if options[:type]
+          result = nil
+          self.send(:around_each_attribute, name) do
+            resolved_name = options[:rename] || name
+            result = self.send(:convert!, resolved_name)
+            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 = result.to_s if options[:stringify]
+            raise_bad_type_if_type_mismatch(result, options[:type]) if options[:type]
+          end
           result
         end
       end
@@ -46,11 +52,15 @@ module Requisite
 
     private
 
+    def around_each_attribute(name)
+      yield
+    end
+
     self.singleton_class.send(:alias_method, :a, :attribute)
     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.3'
 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 }
+      DummyApiModel.serialized_attributes { attribute :num, stringify: true, type: Integer }
       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,54 +163,54 @@ 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
 
       describe 'with typed arrays' do
         it 'allows arrays of one type' do
-          DummyApiModel.serialized_attributes { attribute :ids, typed_array: Fixnum }
+          DummyApiModel.serialized_attributes { attribute :ids, typed_array: Integer }
           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

data/test/requisite/api_user_test.rb

@@ -1,15 +1,17 @@
 require 'test_helper'
+require 'benchmark'
 
 # Example Object
 class ApiUser < Requisite::ApiModel
+
   serialized_attributes do
     attribute :id, type: String
     attribute :user_id
     attribute :email, type: String
     attribute :name, type: String
-    attribute :created_at, type: Fixnum
+    attribute :created_at, type: Integer
     attribute :last_seen_user_agent, type: String
-    attribute :last_request_at, type: Fixnum
+    attribute :last_request_at, type: Integer
     attribute :unsubscribed_from_emails, type: Requisite::Boolean
     attribute :update_last_request_at, type: Requisite::Boolean
     attribute :new_session, type: Requisite::Boolean
@@ -17,7 +19,7 @@ class ApiUser < Requisite::ApiModel
     attribute :company
     attribute :companies
   end
-  
+
   # Ensure that at least one identifier is passed
   def preprocess_model
     identifier = attribute_from_model(:id)
@@ -25,10 +27,30 @@ class ApiUser < Requisite::ApiModel
     identifier ||= attribute_from_model(:email)
     raise StandardError unless identifier
   end
-  
+
+  def last_attribute_fetch_time
+    @last_attribute_fetch_time
+  end
+
+  def attribute_names
+    @attribute_names
+  end
+
+  def around_each_attribute(name)
+    @last_attribute_fetch_time = nil
+    @attribute_names ||= []
+
+    result = nil
+
+    @last_attribute_fetch_time = Benchmark.measure do
+      result = yield
+    end.total
+    @attribute_names << name
+  end
+
   # We want to accept someone sending `created_at` or `created` as parameters
   def created_at
-    with_type!(Fixnum) { attribute_from_model(:created_at) || attribute_from_model(:created) }
+    with_type!(Integer) { attribute_from_model(:created_at) || attribute_from_model(:created) }
   end
 end
 
@@ -71,13 +93,13 @@ module Requisite
       })
       user.name.must_equal('Bob')
     end
-    
+
     it 'raises an error without an identifier' do
       user_request_params = { :name => 'Bob' }
       user = ApiUser.new(user_request_params)
       proc { user.to_hash }.must_raise(StandardError)
     end
-    
+
     it 'raises an error when created or created_at is not of the right type' do
       user_request_params = { :user_id => 'abcdef', :created => 'Thursday' }
       user = ApiUser.new(user_request_params)
@@ -116,7 +138,7 @@ module Requisite
         :new_attribute => 'hi'
       })
     end
-    
+
     it 'accepts a user model' do
       user_model = UserModel.new
       user_model.user_id = 'abcdef'
@@ -129,7 +151,7 @@ module Requisite
       })
       user.name.must_equal('Bob')
     end
-    
+
     it 'accepts a user model and renders nils if asked' do
       user_model = UserModel.new
       user_model.user_id = 'abcdef'
@@ -152,5 +174,16 @@ module Requisite
       })
       user.name.must_equal('Bob')
     end
+
+    it 'calls around_each_attribute for each attribute' do
+      user_model = UserModel.new
+      user_model.user_id = 'abcdef'
+      user = ApiUser.new(user_model)
+
+      user.to_hash(show_nil: true)
+
+      user.attribute_names.must_equal [:id, :user_id, :email, :name, :last_seen_user_agent, :last_request_at, :unsubscribed_from_emails, :update_last_request_at, :new_session, :custom_data, :company, :companies]
+      user.last_attribute_fetch_time.must_be :>, 0
+    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.3
 platform: ruby
 authors:
 - James Osler
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-02-06 00:00:00.000000000 Z
+date: 2025-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -82,7 +82,7 @@ homepage: https://www.intercom.io
 licenses:
 - Apache License Version 2.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,9 +97,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.5.22
+signing_key:
 specification_version: 4
 summary: Strongly defined models for HTTP APIs
 test_files: