requisite 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 50d02a760bbc8b06f7add5b13fa19f6b3e6d6e84
-  data.tar.gz: ff9ab4dfe47ce3ebf3972bb71f3baf8b29341dd8
+  metadata.gz: fdf15247190df240348bbf154bac1485d5e93b6a
+  data.tar.gz: 32d1748aff1b074f8b5f9b9639249697176c7c58
 SHA512:
-  metadata.gz: f23920831c22a63ecb735413e0277e67111bfbfbb4b6ddf25e187c6f4163a3150b11b5e5cdaada1da94f9e59c0b8e77b9b0ac53ef63696c129d332f604920448
-  data.tar.gz: 79d2835433fde444c7329a1bbc05847a980fa7d9a93087296fec6ba47574ed9d4a6ff169b825db59028cd5e05036a6811be2be28a10de0d65722e0817f379c7b
+  metadata.gz: 569dae2fbad28fae97b4c5013f34290f24702494eddbfb560f3279f07387e3df679d74bd1a8ee3c52c5531e193d240008a12454c8f70d20304fe58f064de8a5d
+  data.tar.gz: c66308ee9e74ec995613b5c7d35202c76e645725d77d72bbbc406e0380cc43c78d34b3519adbec9da9c82d45e7662d558671c2676a03058ce2d627a34a1a6786

data/CHANGES.md

@@ -0,0 +1,5 @@
+### 0.2.0 (17th November 2014):
+  - Add inheritance of serialized attributes
+
+### 0.1.0:
+  - Initial commit

data/lib/requisite/api_model.rb

@@ -31,7 +31,7 @@ module Requisite
     def to_hash
       preprocess_model
       {}.tap do |result|
-        self.class.attribute_keys.each do |meth|
+        self.class.attribute_keys_with_inheritance.each do |meth|
           value = self.send(meth)
           result.merge!({meth => value}) unless value.nil?
         end

data/lib/requisite/boundary_object.rb

@@ -36,7 +36,11 @@ module Requisite
       end
 
       def attribute_keys
-        @attribute_keys
+        @attribute_keys || []
+      end
+
+      def attribute_keys_with_inheritance
+        superclass.respond_to?(:attribute_keys_with_inheritance) ? superclass.attribute_keys_with_inheritance.concat(attribute_keys) : attribute_keys || []
       end
     end
 

data/lib/requisite/version.rb

@@ -1,3 +1,3 @@
 module Requisite
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/test/requisite/api_model_test.rb

@@ -1,10 +1,14 @@
 require 'test_helper'
+# require_relative '../dummy_api_model'
 
 module Requisite
+  class DummyApiModel < Requisite::ApiModel
+  end
+  
   describe ApiModel do
     it 'creates methods from serialized_attributes block' do
-      ApiModel.serialized_attributes { attribute :a; attribute :b }
-      response = ApiModel.new
+      DummyApiModel.serialized_attributes { attribute :a; attribute :b }
+      response = DummyApiModel.new
       def response.a; 'A'; end
       def response.b; 2; end
       response.to_hash.must_equal( :a => 'A', :b => 2 )
@@ -13,119 +17,119 @@ module Requisite
     end
     
     it 'attribute provides a default implementation of calling a hash model' do
-      ApiModel.serialized_attributes { attribute :c }
+      DummyApiModel.serialized_attributes { attribute :c }
       mock = {:c => 'C'}
-      response = ApiModel.new(mock)
+      response = DummyApiModel.new(mock)
       response.to_hash.must_equal( :c => 'C' )
     end
 
     let(:params_hash) { {:c => 'C', :num => 12} }
     
     it 'attribute provides a default implementation of calling a model' do
-      ApiModel.serialized_attributes { attribute :c }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :c }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:c => 'C')
     end
 
     it 'attribute can work with a default' do
-      ApiModel.serialized_attributes { attribute :c, default: 'see' }
-      response = ApiModel.new
+      DummyApiModel.serialized_attributes { attribute :c, default: 'see' }
+      response = DummyApiModel.new
       response.to_hash.must_equal(:c => 'see')
     end
     
     it 'ignores default if value given' do
-      ApiModel.serialized_attributes { attribute :num, default: 0 }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :num, default: 0 }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => 12)
     end
     
     it 'attribute can be set to stringify fields' do
-      ApiModel.serialized_attributes { attribute :num, stringify: true }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :num, stringify: true }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => '12')
     end
     
     it 'attribute can be set to rename fields' do
-      ApiModel.serialized_attributes { attribute :my_num, rename: :num }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :my_num, rename: :num }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:my_num => 12)
     end
     
     it 'attribute can assert type of a field' do
-      ApiModel.serialized_attributes { attribute :num, type: String }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :num, type: String }
+      response = DummyApiModel.new(params_hash)
       proc { response.to_hash }.must_raise(BadTypeError)
     end
     
     it 'with_type! helper raises on mismatched type' do
-      model = ApiModel.new()
+      model = DummyApiModel.new()
       proc { model.with_type!(String) { 1 + 2 }}.must_raise(Requisite::BadTypeError)
     end
     
     it 'first_attribute_from_model helper finds first matching attriubute' do
-      model = ApiModel.new(:oh => 12, :a => nil, :b => 'B', :c => 'C')
+      model = DummyApiModel.new(:oh => 12, :a => nil, :b => 'B', :c => 'C')
       model.first_attribute_from_model(:a, :b, :c).must_equal('B')
     end
     
     it 'attribute can assert type of a boolean field' do
-      ApiModel.serialized_attributes { attribute :truthy_val, type: Requisite::Boolean }
-      response = ApiModel.new(:truthy_val => false)
+      DummyApiModel.serialized_attributes { attribute :truthy_val, type: Requisite::Boolean }
+      response = DummyApiModel.new(:truthy_val => false)
       response.to_hash.must_equal(:truthy_val => false)
     end
     
     it 'attribute does not include values of nil' do
-      ApiModel.serialized_attributes { attribute :num, type: String }
-      response = ApiModel.new({:num => nil})
+      DummyApiModel.serialized_attributes { attribute :num, type: String }
+      response = DummyApiModel.new({:num => nil})
       response.to_hash.must_equal({})
     end
     
     it 'attribute can be stringified and renamed with default fields' do
-      ApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22 }
-      response = ApiModel.new
+      DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22 }
+      response = DummyApiModel.new
       response.to_hash.must_equal(:my_num => '22')
     end
     
     it 'attribute can be stringified after type check' do
-      ApiModel.serialized_attributes { attribute :num, stringify: true, type: Fixnum }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :num, stringify: true, type: Fixnum }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => '12')
     end
     
     it 'attribute type checks after rename' do
-      ApiModel.serialized_attributes { attribute :my_num, rename: :num, type: String }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, type: String }
+      response = DummyApiModel.new(params_hash)
       proc { response.to_hash }.must_raise(BadTypeError)
     end
     
     it 'attribute can be stringified, renamed, defaulted and have type checking on a field' do
-      ApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22, type: String }
-      response = ApiModel.new
+      DummyApiModel.serialized_attributes { attribute :my_num, rename: :num, stringify: true, default: 22, type: String }
+      response = DummyApiModel.new
       proc { response.to_hash }.must_raise(BadTypeError)
     end
     
     let(:invalid_params_hash) { {:d => nil} }
 
     it "attribute! raises an error if not found on model" do
-      ApiModel.serialized_attributes { attribute! :d }
-      response = ApiModel.new(invalid_params_hash)
+      DummyApiModel.serialized_attributes { attribute! :d }
+      response = DummyApiModel.new(invalid_params_hash)
       proc { response.to_hash }.must_raise(NotImplementedError, "'d' not found on model")
     end
         
     it 'attribute! can be set to stringify fields' do
-      ApiModel.serialized_attributes { attribute! :num, stringify: true }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute! :num, stringify: true }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => '12')
     end
     
     it 'attribute! can be set to rename fields' do
-      ApiModel.serialized_attributes { attribute! :my_num, rename: :num }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { attribute! :my_num, rename: :num }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:my_num => 12)
     end
 
     it 'sets the model from a hash' do
-      ApiModel.serialized_attributes { }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { }
+      response = DummyApiModel.new(params_hash)
       response.model.must_equal(params_hash)
     end
     
@@ -133,33 +137,33 @@ module Requisite
       mc = MockClass.new
       mc.a = 'a'
       mc.b = 2
-      ApiModel.serialized_attributes { attribute :a }
-      response = ApiModel.new(mc)
+      DummyApiModel.serialized_attributes { attribute :a }
+      response = DummyApiModel.new(mc)
       response.model.must_equal(mc)
       response.to_hash.must_equal(:a => 'a')
     end
     
     it 'has alias a for attribute' do
-      ApiModel.serialized_attributes { a :num }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { a :num }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => 12)
     end
     
     it 'has alias a! for attribute!' do
-      ApiModel.serialized_attributes { a! :num }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { a! :num }
+      response = DummyApiModel.new(params_hash)
       response.to_hash.must_equal(:num => 12)
     end
     
     it 'can convert to json' do
-      ApiModel.serialized_attributes { a! :num }
-      response = ApiModel.new(params_hash)
+      DummyApiModel.serialized_attributes { a! :num }
+      response = DummyApiModel.new(params_hash)
       response.to_json.must_equal("{\"num\":12}")
     end
     
     it 'drops non-listed parameters' do
-      ApiModel.serialized_attributes { attribute :num }
-      response = ApiModel.new({num: 12, other: 'value'})
+      DummyApiModel.serialized_attributes { attribute :num }
+      response = DummyApiModel.new({num: 12, other: 'value'})
       response.to_hash.must_equal(:num => 12)
     end
     
@@ -167,77 +171,77 @@ module Requisite
       
       describe 'with typed arrays' do
         it 'allows arrays of one type' do
-          ApiModel.serialized_attributes { attribute :ids, typed_array: Fixnum }
-          response = ApiModel.new({ids: [1, 2, 3]})
+          DummyApiModel.serialized_attributes { attribute :ids, typed_array: Fixnum }
+          response = DummyApiModel.new({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
-          ApiModel.serialized_attributes { attribute :ids, typed_array: Requisite::Boolean }
-          response = ApiModel.new({ids: [true, 'value', false]})
+          DummyApiModel.serialized_attributes { attribute :ids, typed_array: Requisite::Boolean }
+          response = DummyApiModel.new({ids: [true, 'value', false]})
           Proc.new {response.to_hash}.must_raise(BadTypeError)
         end
       end
       
       describe 'with typed nested hashes' do
         it 'drops non listed parameters in nested hashes' do
-          ApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric, bool: Requisite::Boolean } }
-          response = ApiModel.new({data: { num: 12, value: 'x', bool: true }})
+          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 })
         end
         
         it 'can stringify nested hashes' do
-          ApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric }, stringify: true }
-          response = ApiModel.new({data: { num: 12, value: 'x' }})
+          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}")
         end
         
         it 'raises an error when nested hash values of the wrong type' do
-          ApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric } }
-          Proc.new {ApiModel.new({data: { num: '12'}}).to_hash}.must_raise(BadTypeError)
+          DummyApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric } }
+          Proc.new {DummyApiModel.new({data: { num: '12'}}).to_hash}.must_raise(BadTypeError)
         end
               
         it 'can rename param and work with nested hashes' do
-          ApiModel.serialized_attributes { attribute :my_data, typed_hash: { num: Numeric }, rename: :data }
-          response = ApiModel.new({data: { num: 12, value: 'x' }})
+          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 })
         end
         
         it 'can set a default value for a nested hash' do
-          ApiModel.serialized_attributes { attribute :data, typed_hash: { num: Numeric }, default: { num: 4 } }
-          response = ApiModel.new({data: { value: 'x' }})
+          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 })
         end
         
         it 'drops non listed fields with attribute!' do
-          ApiModel.serialized_attributes { attribute! :data, typed_hash: { num: Numeric } }
-          response = ApiModel.new({data: { num: 12, value: 'x' }})
+          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 })
         end
         
         it 'attribute! does not raise an error with missing values in hash' do
-          ApiModel.serialized_attributes { attribute! :data, typed_hash: { num: Numeric } }
-          response = ApiModel.new({data: { value: 'x' }})
+          DummyApiModel.serialized_attributes { attribute! :data, typed_hash: { num: Numeric } }
+          response = DummyApiModel.new({data: { value: 'x' }})
           response.to_hash.must_equal(:data => { })
         end
       end
       
       describe 'with scalar only nested hashes' do
         it 'should parse scalar hashes permitting anything scalar' do
-          ApiModel.serialized_attributes { attribute :data, scalar_hash: true }
-          response = ApiModel.new({data: { num: 12, value: 'x', :truthy => false }})
+          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 })
         end
         
         it 'should parse a renamed scalar hash' do
-          ApiModel.serialized_attributes { attribute :my_data, scalar_hash: true, rename: :data }
-          response = ApiModel.new({data: { num: 12, value: 'x' }})
+          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' })
         end
         
         it 'should stringify a scalar hash' do
-          ApiModel.serialized_attributes { attribute :data, scalar_hash: true, stringify: true }
-          response = ApiModel.new({data: { num: 12, value: 'x' }})
+          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\"}")
         end
         
@@ -245,41 +249,41 @@ module Requisite
           mc = MockClass.new
           mc.a = 'a'
           mc.b = { num: 12, value: 'x' }
-          ApiModel.serialized_attributes { attribute :b, scalar_hash: true }
-          response = ApiModel.new(mc)
+          DummyApiModel.serialized_attributes { attribute :b, scalar_hash: true }
+          response = DummyApiModel.new(mc)
           response.to_hash.must_equal(:b => { :num => 12, :value => 'x' })
         end
         
         it 'should fail to parse scalar hashes when non scalar values present' do
-          ApiModel.serialized_attributes { attribute :data, scalar_hash: true }
-          Proc.new { ApiModel.new({data: { num: 12, value: { nested: 'value' } }}).to_hash}.must_raise(BadTypeError)
-          Proc.new { ApiModel.new({data: { num: 12, value: ['array value'] }}).to_hash}.must_raise(BadTypeError)
+          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)
         end
         
         it 'should fail to parse scalar hashes permitting anything scalar with object' do
           mc = MockClass.new
           mc.a = 'a'
           mc.b = { value: { nested: 'value' } }
-          ApiModel.serialized_attributes { attribute :b, scalar_hash: true }
-          response = ApiModel.new(mc)
+          DummyApiModel.serialized_attributes { attribute :b, scalar_hash: true }
+          response = DummyApiModel.new(mc)
           Proc.new { response.to_hash }.must_raise(BadTypeError)
         end
         
         it 'can set a default value for a scalar hash' do
-          ApiModel.serialized_attributes { attribute :data, scalar_hash: true, default: { num: 9, value: 'y' } }
-          response = ApiModel.new({data: { }})
+          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' })
         end
         
         it 'doesnt raise with attribute! when an empty hash passed' do
-          ApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
-          response = ApiModel.new({data: {}})
+          DummyApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
+          response = DummyApiModel.new({data: {}})
           response.to_hash.must_equal(:data => {})
         end
         
         it 'raises with attribute! when nil is passed' do
-          ApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
-          response = ApiModel.new({data: nil})
+          DummyApiModel.serialized_attributes { attribute! :data, scalar_hash: true }
+          response = DummyApiModel.new({data: nil})
           Proc.new {response.to_hash}.must_raise(NotImplementedError)
         end
       end

data/test/requisite/api_user_test.rb

@@ -32,6 +32,13 @@ class ApiUser < Requisite::ApiModel
   end
 end
 
+class InheritedApiUser < ApiUser
+  serialized_attributes do
+    attribute :new_attribute, type: String
+    attribute :custom_data
+  end
+end
+
 module Requisite
   describe ApiUser do
     it 'accepts a user' do
@@ -71,5 +78,38 @@ module Requisite
       user = ApiUser.new(user_request_params)
       proc { user.to_hash }.must_raise(Requisite::BadTypeError)
     end
+
+    it "can resolve an inherited set of attributes" do
+      user_request_params = {
+        :user_id => 'abcdef',
+        :name => 'Bob',
+        :created => 1414173164,
+        :new_session => true,
+        :custom_attributes => {
+          :is_cool => true,
+          :logins => 77
+        },
+        :custom_data => {
+          :different => true
+        },
+        :new_attribute => 'hi',
+        :junk => 'data'
+      }
+      user = InheritedApiUser.new(user_request_params)
+      user.new_attribute.must_equal 'hi'
+      user.name.must_equal 'Bob'
+      user.custom_data.must_equal({ :different => true })
+      InheritedApiUser.attribute_keys.must_equal([:new_attribute, :custom_data])
+      user.to_hash.must_equal({
+        :user_id => 'abcdef',
+        :name => 'Bob',
+        :created_at => 1414173164,
+        :new_session => true,
+        :custom_data => {
+          :different => true
+        },
+        :new_attribute => 'hi'
+      })
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: requisite
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - James Osler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-06 00:00:00.000000000 Z
+date: 2014-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -33,6 +33,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- CHANGES.md
 - Gemfile
 - LICENCE.txt
 - README.md