betty_resource 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3419f4f10757834dfcdd7c5c5ff8be658f581812
-  data.tar.gz: e423740a5b9710b1bf01f056898c9671db454b93
+  metadata.gz: 8cfa318752fd70e7e5dca53b694b05ed3b0c69e3
+  data.tar.gz: f0a203d324f8d3b7900b7432c8d766446e84e4e0
 SHA512:
-  metadata.gz: 91d74a552ac48b8858061a7bd566a7c86a965a94c57381d98669c6b1ad5e87588666f4964f628360430379b6ce94d9b2c097c1335fae290c1de9af50c4c9b481
-  data.tar.gz: 094d06fde8b922c2d973b3f1adb2b4b1aaa3be9f04c2cb3ee6d292ef4c05ac65e71814b0ba4ac949f1fe746debd1fa84398056e7b3d3a95ec1d5b7e579f82e05
+  metadata.gz: 3cc1dd827a3f618b113cc77ad2740db50dc82474d7be02852507d41a414697fd02891ed329d631447e3ef33f929bf7916475da3cb633bfea04a2cc07d541ad11
+  data.tar.gz: 8cebce3fed61a1facf9b0fe3a70f5b59fd75606a0b05fd3b7de9f455a1078bc0db43b1240b3475389c2f24b84d6d5d35d5bad7fca9cc7cc324309dd1c908fc92

data/lib/betty_resource.rb

@@ -1,14 +1,17 @@
-require "active_support/core_ext/hash/indifferent_access" # See https://gist.github.com/1075643
+require 'active_support/core_ext/hash/indifferent_access' # See https://gist.github.com/1075643
+require 'active_support/inflector'
 
-require "httparty"
-require "crack/json"
-require "dirty_hashy"
+require 'httparty'
+require 'crack/json'
+require 'dirty_hashy'
+
+require 'betty_resource/kind_extendable'
 
 module BettyResource
-  autoload :Api, "betty_resource/api"
-  autoload :Configuration, "betty_resource/configuration"
-  autoload :MetaData, "betty_resource/meta_data"
-  autoload :Model, "betty_resource/model"
+  autoload :Api, 'betty_resource/api'
+  autoload :Configuration, 'betty_resource/configuration'
+  autoload :MetaData, 'betty_resource/meta_data'
+  autoload :Model, 'betty_resource/model'
 
   def self.const_missing(name)
     meta_data.model(name).tap do |model|
@@ -36,4 +39,4 @@ module BettyResource
     end
   end
 
-end
+end

data/lib/betty_resource/api.rb

@@ -5,8 +5,8 @@ module BettyResource
     base_uri "#{BettyResource.config.host}/api"
     format :json
     basic_auth BettyResource.config.user, BettyResource.config.password
-    query_string_normalizer proc{|query|
+    query_string_normalizer proc { |query|
       query.to_json
     }
   end
-end
+end

data/lib/betty_resource/configuration.rb

@@ -1,10 +1,10 @@
-require "singleton"
+require 'singleton'
 
 module BettyResource
   class Configuration
     def initialize(args = {})
       args.each do |key, value|
-        self.send("#{key}=", value) if [:host, :user, :password].include?(key.to_sym)
+        send("#{key}=", value) if [:host, :user, :password].include?(key.to_sym)
       end
     end
 
@@ -13,8 +13,8 @@ module BettyResource
     attr_accessor :host, :user, :password
 
     def validate!
-      raise InvalidError if [:host, :user, :password].any?{|option| send(option).to_s.strip.empty?}
+      raise InvalidError if [:host, :user, :password].any? { |option| send(option).to_s.strip.empty? }
     end
 
   end
-end
+end

data/lib/betty_resource/kind_extendable.rb

@@ -0,0 +1,35 @@
+module KindExtendable
+
+  def self.included(base)
+    base.send :include, InstanceMethods
+  end
+
+  module InstanceMethods
+
+    def extend_kind_methods
+      unless (m = kind_module).nil?
+        extend m
+      end
+    end
+
+    def kind=(value)
+      if defined?(super)
+        super
+      else
+        @kind = value
+      end
+      @kind_module = nil
+      extend_kind_methods
+    end
+
+    def kind_module
+      @kind_module ||= begin
+        if kind.is_a?(String) && !kind.empty?
+          m = kind.gsub(/(?:^|_)(.)/) { Regexp.last_match[1].upcase }
+          ActiveSupport::Inflector.constantize("#{self.class}::Types::#{m}")
+        end
+      end
+    end
+  end
+
+end

data/lib/betty_resource/meta_data.rb

@@ -2,7 +2,7 @@ module BettyResource
   class MetaData
 
     def models
-      @models ||= BettyResource::Model.parse(Api.get("/models").parsed_response)
+      @models ||= BettyResource::Model.parse(Api.get('/models').parsed_response)
     end
 
     def model(name)
@@ -10,4 +10,4 @@ module BettyResource
     end
 
   end
-end
+end

data/lib/betty_resource/model.rb

@@ -1,13 +1,13 @@
+require 'betty_resource/model/record'
+require 'betty_resource/model/property'
+
 module BettyResource
   class Model
-    autoload :Record, "betty_resource/model/record"
-    autoload :Property, "betty_resource/model/property"
-
     attr_accessor :id, :name, :properties
 
     def self.parse(input)
       input.inject({}) do |hash, row|
-        hash.merge(row["name"] => Model.new(row["id"], row["name"], Property.parse(row["properties"])))
+        hash.merge(row['name'] => Model.new(row['id'], row['name'], Property.parse(row['id'], row['properties'])))
       end
     end
 
@@ -16,7 +16,7 @@ module BettyResource
     end
 
     def property(name)
-      properties.detect{|p|p.name == name.to_s}
+      properties.find { |p|p.name == name.to_s }
     end
 
     def typecast(key, value)
@@ -25,14 +25,14 @@ module BettyResource
     end
 
     def attributes
-      properties.collect(&:name)
+      properties.map(&:name)
     end
 
     # TODO: Refactor this method in order to handle formatted view JSON correctly
     def all(options = {})
       begin
-        response = Api.get("/models/#{id}/records", :body => options).parsed_response
-        ((view_id = options.delete(:view_id) || options.delete("view_id")).nil? ? response : response["records"]).collect do |data|
+        response = Api.get("/models/#{id}/records", body: options).parsed_response
+        ((view_id = options.delete(:view_id) || options.delete('view_id')).nil? ? response : response['records']).map do |data|
           load data
         end
       rescue MultiJson::DecodeError
@@ -47,7 +47,7 @@ module BettyResource
     end
 
     def first(options = {})
-      all(options.merge(:limit => 1)).first
+      all(options.merge(limit: 1)).first
     end
 
     def new(attributes = {})
@@ -68,7 +68,7 @@ module BettyResource
 
     def load(data, record = nil)
       if data
-        id = data.delete "id"
+        id = data.delete 'id'
         (record || BettyResource::Model::Record.new(self)).tap do |record|
           record.instance_variable_set :@id, id
           record.attributes = data
@@ -78,4 +78,4 @@ module BettyResource
     end
 
   end
-end
+end

data/lib/betty_resource/model/property.rb

@@ -1,30 +1,39 @@
+require 'betty_resource/model/property/types/association'
+require 'betty_resource/model/property/types/belongs_to'
+require 'betty_resource/model/property/types/has_many'
+
 module BettyResource
   class Model
     class Property
-      attr_accessor :id, :name, :kind, :options
+      include KindExtendable
+      attr_reader :id, :name, :kind, :options
 
-      def self.parse(input)
-        input.collect do |row|
-          Property.new(row["id"], row["name"], row["kind"], row["options"])
+      def self.parse(model_id, input)
+        input.map do |row|
+          options = row['options']
+          inverse_association = row["inverse_association"]
+          options.merge!("inverse_association" => inverse_association) if inverse_association
+          Property.new(row['id'], model_id, row['name'], row['kind'], options)
         end
       end
 
-      def initialize(id, name, kind, options)
-        @id, @name, @kind, @options = id, name, kind, options
+      def initialize(id, model_id, name, kind, options)
+        @id, @model_id, @name, @kind, @options = id, model_id, name, kind, options
+        extend_kind_methods if %(belongs_to has_many).include?(kind)
+      end
+
+      def collection?
+        false
       end
 
       def typecast(value)
-        if kind == "belongs_to" && id = (value && value["id"])
-          model.get(id)
-        else
-          value
-        end
+        value
       end
 
       def model
-        BettyResource.meta_data.models.values.detect{|x| x.id == options["model"]} if kind == "belongs_to"
+        @model ||= BettyResource.meta_data.models.values.find { |x| x.id == @model_id }
       end
 
     end
   end
-end
+end

data/lib/betty_resource/model/property/types/association.rb

@@ -0,0 +1,21 @@
+module BettyResource
+  class Model
+    class Property
+      module Types
+        module Association
+
+        private
+
+          def target_model
+            BettyResource.meta_data.models.values.find { |x| x.id == options['model'] }
+          end
+
+          def inverse_property
+            @inverse_property ||= target_model.properties.find { |x| x.id == options['inverse_association'] }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/betty_resource/model/property/types/belongs_to.rb

@@ -0,0 +1,18 @@
+module BettyResource
+  class Model
+    class Property
+      module Types
+        module BelongsTo
+          include Association
+
+          def typecast(value)
+            if id = (value && value['id'])
+              target_model.get(id)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/betty_resource/model/property/types/has_many.rb

@@ -0,0 +1,29 @@
+module BettyResource
+  class Model
+    class Property
+      module Types
+        module HasMany
+          include Association
+
+          def collection?
+            true
+          end
+
+          def typecast(value)
+            filter = {
+              'operator' => 'and',
+              'conditions' => [
+                'path' => [inverse_property.id, model.property(:id).id],
+                'predicate' => 'eq',
+                'criteria' => 1
+              ]
+            }
+
+            target_model.all :filters => [filter]
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/betty_resource/model/record.rb

@@ -33,10 +33,10 @@ module BettyResource
 
       def initialize(model, attributes = {})
         @model = model
-        @id = attributes.delete(:id) || attributes.delete("id")
+        @id = attributes.delete(:id) || attributes.delete('id')
         @errors = {}
         super()
-        self.attributes = Hash[model.attributes.collect{|x| [x, nil]}].merge attributes
+        self.attributes = Hash[model.attributes.map { |x| [x, nil] }].merge attributes
         self.attributes.instance_variable_set(:@model, model)
       end
 
@@ -70,31 +70,31 @@ module BettyResource
           if success
             model.send :load, result.parsed_response, self
           else
-            @errors = result.parsed_response ? result.parsed_response["errors"] : {"" => ["Er is iets mis gegaan met het verwerken van het formulier. Probeer u het later nog eens. Onze excuses voor het ongemak"]}
+            @errors = result.parsed_response ? result.parsed_response['errors'] : { '' => ['Er is iets mis gegaan met het verwerken van het formulier. Probeer u het later nog eens. Onze excuses voor het ongemak'] }
           end
         end
       end
 
       def inspect
-        inspection = "id: #{id.inspect}, #{attributes.collect{|key, value| "#{key}: #{value.inspect}"}.join(", ")}"
+        inspection = "id: #{id.inspect}, #{attributes.map { |key, value| "#{key}: #{value.inspect}"}.join(", ")}"
         "#<#{model.name} #{inspection}>"
       end
       alias :to_s :inspect
 
       # TODO: Test this update
       def as_json(options = {})
-        attributes_as_json(options).merge! "id" => id
+        attributes_as_json(options).merge! 'id' => id
       end
 
     private
 
       def to_params
-        {:body => {:record => attributes_as_json}, :headers => {"Content-Type" => "application/json"}}
+        { body: { record: attributes_as_json }, headers: { 'Content-Type' => 'application/json' } }
       end
 
       # TODO: Test this update
       def attributes_as_json(options = {})
-        attributes.inject({}) do |h, (k, v)|
+        attributes.reduce({}) do |h, (k, v)|
           h.merge! k => (v.respond_to?(:as_json) ? v.as_json(options) : v) if v
           h
         end
@@ -102,4 +102,4 @@ module BettyResource
 
     end
   end
-end
+end

data/lib/betty_resource/version.rb

@@ -1,7 +1,7 @@
 module BettyResource
   MAJOR = 0
   MINOR = 0
-  TINY  = 13
+  TINY  = 14
 
-  VERSION = [MAJOR, MINOR, TINY].join(".")
+  VERSION = [MAJOR, MINOR, TINY].join('.')
 end

data/script/console

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
 Bundler.require :gem_default
 
@@ -8,4 +8,4 @@ BettyResource.configure(MultiJson.decode(File.read(File.expand_path('../../.cred
 
 puts "Loading BettyResource development environment (#{BettyResource::VERSION})"
 puts "Configured connection with #{BettyResource.config.host}".yellow
-Pry.start
+Pry.start

data/test/test_helper.rb

@@ -1,18 +1,19 @@
-ENV["RACK_ENV"] = "test"
-ENV["TESTOPTS"] = "-v"
+ENV['RACK_ENV'] = 'test'
+ENV['TESTOPTS'] = '-v'
 
-require "rubygems"
-require "bundler/setup"
+require 'rubygems'
+require 'bundler/setup'
 
-require "minitest/unit"
-require "minitest/autorun"
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'minitest/pride'
 
-require "simplecov"
+require 'simplecov'
 
 SimpleCov.start do
-  coverage_dir "coverage"
-  add_filter "/test/"
+  coverage_dir 'coverage'
+  add_filter '/test/'
 end
 
 Bundler.require :gem_default, :gem_test
-BettyResource.configure(MultiJson.decode(File.read(File.expand_path('../../.credentials', __FILE__))))
+BettyResource.configure(MultiJson.decode(File.read(File.expand_path('../../.credentials', __FILE__))))

data/test/unit/model/test_record.rb

@@ -1,147 +1,152 @@
-require_relative "../../test_helper"
+require_relative '../../test_helper'
 
 module Unit
   module Record
     class TestRecord < MiniTest::Unit::TestCase
 
       describe BettyResource::Model::Record do
-        it "should return its model" do
+        it 'should return its model' do
           assert_equal BettyResource::Relation, BettyResource::Relation.new.model
           assert_equal BettyResource::Relation, BettyResource::Relation.new.class
         end
 
-        it "should return its attributes" do
+        it 'should return its attributes' do
           relation = BettyResource::Relation.new
           assert_equal %w(first_name group id last_name), relation.attributes.keys.sort
         end
 
-        it "should create a method for writing each attribute" do
+        it 'should create a method for writing each attribute' do
           relation = BettyResource::Relation.new
-          assert relation.first_name = "my_first_name"
-          assert relation.last_name = "my_last_name"
+          assert relation.first_name = 'my_first_name'
+          assert relation.last_name = 'my_last_name'
         end
 
-        it "should create a method for reading each attribute" do
+        it 'should create a method for reading each attribute' do
           relation = BettyResource::Relation.new
-          relation.first_name = "my_first_name"
-          assert_equal "my_first_name", relation.first_name
+          relation.first_name = 'my_first_name'
+          assert_equal 'my_first_name', relation.first_name
         end
 
-        it "should store its values in the @attributes instance variable" do
+        it 'should store its values in the @attributes instance variable' do
           relation = BettyResource::Relation.new
-          relation.first_name = "my_first_name"
-          assert_equal "my_first_name", relation.attributes[:first_name]
+          relation.first_name = 'my_first_name'
+          assert_equal 'my_first_name', relation.attributes[:first_name]
         end
 
-        it "should allow mass-assignment when initializing" do
-          relation = BettyResource::Relation.new(:first_name => "my_first_name", :last_name => "my_last_name")
-          assert_equal "my_first_name", relation.first_name
-          assert_equal "my_last_name", relation.last_name
+        it 'should allow mass-assignment when initializing' do
+          relation = BettyResource::Relation.new(first_name: 'my_first_name', last_name: 'my_last_name')
+          assert_equal 'my_first_name', relation.first_name
+          assert_equal 'my_last_name', relation.last_name
         end
 
-        it "should allow mass-assignment when already initialized" do
+        it 'should allow mass-assignment when already initialized' do
           relation = BettyResource::Relation.new
-          relation.attributes = {:first_name => "my_first_name", :last_name => "my_last_name"}
-          assert_equal "my_first_name", relation.first_name
-          assert_equal "my_last_name", relation.last_name
+          relation.attributes = { first_name: 'my_first_name', last_name: 'my_last_name' }
+          assert_equal 'my_first_name', relation.first_name
+          assert_equal 'my_last_name', relation.last_name
         end
 
-        it "should not allow setting of id" do
+        it 'should not allow setting of id' do
           relation = BettyResource::Relation.get(1)
           assert_equal 1, relation.id
           assert relation.id = 2
           assert_equal 1, relation.id
         end
 
-        it "should be able to represent itself as JSON" do
-          relation = BettyResource::Relation.new(:first_name => "Paul", :last_name => "Engel")
-          assert_equal({"id" => nil, "first_name" => "Paul", "last_name" => "Engel"}, relation.as_json)
+        it 'should be able to represent itself as JSON' do
+          relation = BettyResource::Relation.new(first_name: 'Paul', last_name: 'Engel')
+          assert_equal({ 'id' => nil, 'first_name' => 'Paul', 'last_name' => 'Engel' }, relation.as_json)
 
           relation = BettyResource::Relation.get(1)
-          assert_equal({"id" => 1, "first_name" => "Daniel", "last_name" => "Willemse", "group"=>{"id"=>1, "name" => "group one"}}, relation.as_json)
-          assert_equal({"id" => 1, "name" => "group one"}, relation.group.as_json)
+          assert_equal({ 'id' => 1, 'first_name' => 'Daniel', 'last_name' => 'Willemse', 'group' => { 'id' => 1, 'name' => 'group one' } }, relation.as_json)
+          assert_equal({ 'id' => 1, 'name' => 'group one' }, relation.group.as_json)
         end
 
-        it "should save itself" do
-          relation = BettyResource::Relation.new(:first_name => "Stephan", :last_name => "Kaag")
+        it 'should save itself' do
+          relation = BettyResource::Relation.new(first_name: 'Stephan', last_name: 'Kaag')
           assert relation.save
           assert relation.id > 0
 
           relation = BettyResource::Relation.get(relation.id)
-          assert_equal "Stephan", relation.first_name
-          assert_equal "Kaag", relation.last_name
+          assert_equal 'Stephan', relation.first_name
+          assert_equal 'Kaag', relation.last_name
         end
 
-        it "should save itself when an %-character is used" do
-          relation = BettyResource::Relation.new(:first_name => "Stephan%")
+        it 'should save itself when an %-character is used' do
+          relation = BettyResource::Relation.new(first_name: 'Stephan%')
           assert relation.save
           assert relation.id > 0
 
           relation = BettyResource::Relation.get(relation.id)
-          assert_equal "Stephan%", relation.first_name
+          assert_equal 'Stephan%', relation.first_name
         end
 
-        it "should not save itself when invalid (first_name is required)" do
+        it 'should not save itself when invalid (first_name is required)' do
           relation = BettyResource::Relation.new
           assert !relation.save
-          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+          assert_equal({ 'first_name' => ['is_required'] }, relation.errors)
 
-          relation.first_name = "Stephan"
+          relation.first_name = 'Stephan'
           assert relation.save
         end
 
-        it "should have read-only errors messages" do
+        it 'should have read-only errors messages' do
           relation = BettyResource::Relation.create
-          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+          assert_equal({ 'first_name' => ['is_required'] }, relation.errors)
 
           relation.errors.clear
-          assert_equal({"first_name"=>["is_required"]}, relation.errors)
+          assert_equal({ 'first_name' => ['is_required'] }, relation.errors)
         end
 
-        it "should not resave itself when invalid" do
-          relation = BettyResource::Relation.new :first_name => "Piet"
+        it 'should not resave itself when invalid' do
+          relation = BettyResource::Relation.new first_name: 'Piet'
           assert relation.save
 
-          relation.first_name = ""
+          relation.first_name = ''
           assert !relation.save
           assert relation.id > 0
 
-          assert_equal "Piet", BettyResource::Relation.get(relation.id).first_name
+          assert_equal 'Piet', BettyResource::Relation.get(relation.id).first_name
         end
 
-        it "should update itself" do
-          relation = BettyResource::Relation.new(:first_name => "Stefan", :last_name => "Kaag")
+        it 'should update itself' do
+          relation = BettyResource::Relation.new(first_name: 'Stefan', last_name: 'Kaag')
           relation.save
 
-          relation.first_name = "Stephan"
+          relation.first_name = 'Stephan'
           relation.save
 
           relation = BettyResource::Relation.get(relation.id)
-          assert_equal "Stephan", relation.first_name
+          assert_equal 'Stephan', relation.first_name
         end
 
-        it "should be able to fetch a belongs-to value" do
+        it 'should be able to fetch a belongs-to value' do
           relation = BettyResource::Relation.get(1)
           assert_equal 1, relation.group.id
 
           filter = {
-            "operator" => "and",
-            "conditions" => [
-              "path" => [BettyResource::Relation.property(:id).id],
-              "predicate" => "eq",
-              "criteria" => 1
+            'operator' => 'and',
+            'conditions' => [
+              'path' => [BettyResource::Relation.property(:id).id],
+              'predicate' => 'eq',
+              'criteria' => 1
             ]
           }
 
-          relations = BettyResource::Relation.all(:filters => [filter])
+          relations = BettyResource::Relation.all(filters: [filter])
           assert_equal 1, relations.size
           assert_equal 1, relations[0].group.id
           assert relations[0].group.object_id == relations[0].group.object_id
 
           assert_nil BettyResource::Relation.new.group
         end
+
+        it 'should be able to fetch a has-many value' do
+          group = BettyResource::Group.get(1)
+          assert_equal %w(Chris Daniel), group.relations.map(&:first_name).sort
+        end
       end
 
     end
   end
-end
+end

data/test/unit/test_base.rb

@@ -1,10 +1,10 @@
-require_relative "../test_helper"
+require_relative '../test_helper'
 
 module Unit
   class TestBase < MiniTest::Unit::TestCase
 
     describe BettyResource do
-      it "should validate its config" do
+      it 'should validate its config' do
         assert config = BettyResource.config
 
         config.expects(:host).returns(nil)
@@ -12,25 +12,25 @@ module Unit
           BettyResource.config
         end
 
-        config.expects(:host).returns("")
+        config.expects(:host).returns('')
         assert_raises(BettyResource::Configuration::InvalidError) do
           BettyResource.config
         end
 
-        config.expects(:host).returns(" ")
+        config.expects(:host).returns(' ')
         assert_raises(BettyResource::Configuration::InvalidError) do
           BettyResource.config
         end
 
-        config.expects(:host).returns("localhost")
+        config.expects(:host).returns('localhost')
         assert BettyResource.config
       end
 
-      it "should return a model instance" do
+      it 'should return a model instance' do
         assert BettyResource::Relation.is_a?(BettyResource::Model)
       end
 
-      it "should raise NameError when an unknown model is requested" do
+      it 'should raise NameError when an unknown model is requested' do
         assert_raises(NameError) do
           assert BettyResource::DoesNotExist
         end
@@ -38,4 +38,4 @@ module Unit
     end
 
   end
-end
+end

data/test/unit/test_configuration.rb

@@ -1,26 +1,26 @@
-require_relative "../test_helper"
+require_relative '../test_helper'
 
 module Unit
   class TestBase < MiniTest::Unit::TestCase
 
     describe BettyResource::Configuration do
-      it "should be able to validate itself" do
+      it 'should be able to validate itself' do
         config = BettyResource::Configuration.new
         assert_raises(BettyResource::Configuration::InvalidError) do
           config.validate!
         end
 
-        config.host = "localhost"
+        config.host = 'localhost'
         assert_raises(BettyResource::Configuration::InvalidError) do
           config.validate!
         end
 
-        config.host = "localhost"
-        config.user = "foo"
-        config.password = "bar"
+        config.host = 'localhost'
+        config.user = 'foo'
+        config.password = 'bar'
         assert_nil config.validate!
       end
     end
 
   end
-end
+end

data/test/unit/test_model.rb

@@ -1,67 +1,67 @@
-require_relative "../test_helper"
+require_relative '../test_helper'
 
 module Unit
   class TestModel < MiniTest::Unit::TestCase
 
     describe BettyResource::Model do
-      it "should know its properties" do
+      it 'should know its properties' do
         assert BettyResource::Relation.properties.is_a?(Array)
         assert BettyResource::Relation.properties.any?
         assert BettyResource::Relation.properties[0].is_a?(BettyResource::Model::Property)
       end
 
-      it "should know its attributes" do
+      it 'should know its attributes' do
         assert_equal %w(first_name group id last_name), BettyResource::Relation.attributes.sort
       end
 
-      it "should return a new record instance" do
+      it 'should return a new record instance' do
         assert BettyResource::Relation.new.is_a?(BettyResource::Model::Record)
       end
 
-      it "should not load unexisting records" do
+      it 'should not load unexisting records' do
         assert_nil BettyResource::Relation.get(-1)
       end
 
-      it "should fetch a record" do
+      it 'should fetch a record' do
         relation = BettyResource::Relation.get(1)
         assert_equal 1, relation.id
-        assert_equal "Daniel", relation.first_name
-        assert_equal "Willemse", relation.last_name
+        assert_equal 'Daniel', relation.first_name
+        assert_equal 'Willemse', relation.last_name
       end
 
-      it "should fetch a first record" do
+      it 'should fetch a first record' do
         relation = BettyResource::Relation.first
         assert_equal 1, relation.id
-        assert_equal "Daniel", relation.first_name
-        assert_equal "Willemse", relation.last_name
+        assert_equal 'Daniel', relation.first_name
+        assert_equal 'Willemse', relation.last_name
 
-        relation = BettyResource::Relation.first :filters => {:path => BettyResource::Relation.property(:last_name).id, :predicate => "eq", :criteria => "Piet"}
+        relation = BettyResource::Relation.first filters: { path: BettyResource::Relation.property(:last_name).id, predicate: 'eq', criteria: 'Piet' }
         assert_nil relation
 
-        relation = BettyResource::Relation.first :filters => {:path => BettyResource::Relation.property(:last_name).id, :predicate => "eq", :criteria => "Willemse"}
+        relation = BettyResource::Relation.first filters: { path: BettyResource::Relation.property(:last_name).id, predicate: 'eq', criteria: 'Willemse' }
         assert_equal 1, relation.id
       end
 
-      it "should fetch multiple records" do
+      it 'should fetch multiple records' do
         relations = BettyResource::Relation.all
         assert_equal 100, relations.size
         assert relations.first.is_a?(BettyResource::Model::Record)
 
-        relations = BettyResource::Relation.all :limit => 10
+        relations = BettyResource::Relation.all limit: 10
         assert_equal 10, relations.size
         assert relations.first.is_a?(BettyResource::Model::Record)
       end
 
-      it "should directly create a record" do
-        relation = BettyResource::Relation.create(:first_name => "Stephan", :last_name => "Kaag")
+      it 'should directly create a record' do
+        relation = BettyResource::Relation.create(first_name: 'Stephan', last_name: 'Kaag')
         assert relation
         assert relation.id > 0
 
         relation = BettyResource::Relation.get(relation.id)
-        assert_equal "Stephan", relation.first_name
-        assert_equal "Kaag", relation.last_name
+        assert_equal 'Stephan', relation.first_name
+        assert_equal 'Kaag', relation.last_name
       end
     end
 
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: betty_resource
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Chiel Wester
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-02 00:00:00.000000000 Z
+date: 2013-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -117,9 +117,13 @@ files:
 - lib/betty_resource.rb
 - lib/betty_resource/api.rb
 - lib/betty_resource/configuration.rb
+- lib/betty_resource/kind_extendable.rb
 - lib/betty_resource/meta_data.rb
 - lib/betty_resource/model.rb
 - lib/betty_resource/model/property.rb
+- lib/betty_resource/model/property/types/association.rb
+- lib/betty_resource/model/property/types/belongs_to.rb
+- lib/betty_resource/model/property/types/has_many.rb
 - lib/betty_resource/model/record.rb
 - lib/betty_resource/version.rb
 - script/console
@@ -158,4 +162,3 @@ test_files:
 - test/unit/test_base.rb
 - test/unit/test_configuration.rb
 - test/unit/test_model.rb
-has_rdoc: