guacamole 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2522fab030888fc0ee9601790aabd2134c6f32dc
-  data.tar.gz: 400562752f398045f858bbe9edf3c40d621fcc4c
+  metadata.gz: da19a1adc7e260053f9749aaaa5af277e706fbda
+  data.tar.gz: 08392381e86a454d91a3da30efac6b86599234be
 SHA512:
-  metadata.gz: 8c1b397cab789fee57a5a98eb76e46f9c422b466747cd9be272591cc66aee47829253c484ffd500e9fe0755fc255d43df55742546404ecf618a536f27538ab18
-  data.tar.gz: 19f830e89f65c7c4c8404a4ce49559920a6a3eac6e0bbe0eab34671f944a49bc0412d530aaad984fb0fd5cba7bd77ffbbd5c6dc8d1bc3e1248a5605972e0e8c3
+  metadata.gz: 40ec254c0113a1f8ee0bc2dbdb8624c2d5f3c0ea55cb1e981e45d91b38eb4167f590896cce392d9c5a8419ddea208ce29600f116b24fbf7f2108aa0181c54b47
+  data.tar.gz: b7b301e8c84692d620316a29e02ee654b6358427e5e92016957a7f66aeb9b249268eacffffe9d715bb28f7508f9ec3ca8746ef92f043326c56ecc7a0f4cab708

data/.hound.yml

@@ -55,3 +55,6 @@ TrivialAccessors:
 
 RegexpLiteral:
   Enabled: false
+
+StringLiterals:
+  EnforcedStyle: single_quotes

data/{config/reek.yml → .reek.yml}

@@ -22,6 +22,8 @@ DuplicateMethodCall:
   exclude:
   - Guacamole::DocumentModelMapper#document_to_model
   - Guacamole::DocumentModelMapper#model_to_document
+  - Guacamole::Configuration#create_database_connection
+  - Guacamole::Callbacks::CallbackProxy#run_callbacks
   max_calls: 1
   allow_calls: []
 FeatureEnvy:
@@ -59,6 +61,7 @@ TooManyInstanceVariables:
   enabled: true
   exclude:
   - Guacamole::DocumentModelMapper
+  - Guacamole::Configuration::ConfigStruct
   max_instance_variables: 3
 TooManyMethods:
   enabled: true
@@ -72,6 +75,8 @@ TooManyStatements:
   - Guacamole::DocumentModelMapper#model_to_document
   - Guacamole::Collection::ClassMethods#create_document_from
   - Guacamole::Collection::ClassMethods#create_referenced_by_models_of
+  - Guacamole::Configuration#create_database_connection
+  - Guacamole::Configuration::ConfigStruct#init_from_uri_string
   max_statements: 5
 UncommunicativeMethodName:
   enabled: true

data/.travis.yml

@@ -19,3 +19,6 @@ matrix:
     - rvm: jruby-head
     - rvm: rbx-19mode
 script: "bundle exec rake ci"
+addons:
+  code_climate:
+    repo_token: cd5dd119d022e5b0d4fda98d25aa93473ed5b580c3f621475c3e605a858f5790

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## Version 0.3.0
+
+**Codename: Spread your Wings**
+
+This release improved the configurability of Guacamole, updated Ashikawa::Core, enhanced the README and added callbacks.
+
+Notable changes are:
+
+  * Implemented external callbacks
+  * Added support for `DATABASE_URL`
+  * Parse `guacamole.yml` with ERB
+  * Updated Ashikawa::Core to 0.12.0
+  * Improved README
+  * Fixed generators with `test_unit`
+  * Internal changes
+    * Removed `debugger` in favor of `pry`
+    * Removed `devtools`
+
+
 ## Version 0.2.0
 
 **Codename: Into the Storm**

data/GOALS.md

@@ -0,0 +1,20 @@
+# Goals of this project
+
+* Support building web applications with Ruby on Rails or other Rack-based frameworks
+    * Support for Rails Views for example
+    * Allow Rails developers to get into Guacamole as easy as possible
+* Reflect the nature of NoSQL in general and ArangoDB in particular
+    * Use the Datamapper pattern, because it allows us to leverage ArangoDB features like nesting in a really nice way
+    * Support ArangoDB features like transactions, the query language and graphs
+
+*The two main goals may conflict from time to time.*
+
+## Features of Guacamole 1.0
+
+**This is definitely a moving target and up to discussion. For non-moving targets refer to our [milestones](https://github.com/triAGENS/guacamole/issues/milestones).**
+
+* **Embrace the Multi Model nature of ArangoDB:** It will be possible to connect entities with edges. These edges will have custom classes. It will be possible to do graph queries using these connections. There is already a [discussion about how to do this](https://github.com/triAGENS/guacamole/issues/74).
+* **Support for the ArangoDB Query Language:** ArangoDB has a powerful querying language. We want to provide support for it in the most Ruby-way possible. There is already a [discussion about how to do this](https://github.com/moonglum/brazil/issues/8).
+* **Support for Transactions:** ArangoDB has support for transactions, we want to make it as easy as possible to use them.
+* **Support for Migrations:** Migrations work differently in a database with flexible schema. Some migrations are possible on the fly, but there will still be migrations that need to be executed explicitly. We want to support Rails-like migrations for these types of queries.
+* **Support for flexible mapping:** Right now the mapping is very strict, we will allow more flexibility here including renaming or excluding certain attributes.

data/Gemfile

@@ -3,14 +3,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-# Devtools
-group :development, :test do
-  gem 'devtools', git: 'https://github.com/rom-rb/devtools.git'
-  gem 'guard-yard'
-end
-eval_gemfile 'Gemfile.devtools'
-
-# Local debugging
-group :debug do
-  gem 'debugger'
-end
+gem 'rspec-its', git: 'https://github.com/rspec/rspec-its.git'

data/Guardfile

@@ -7,7 +7,3 @@ guard 'rspec', spec_paths: ['spec/unit'] do
   watch(%r{spec/.+\.rb})
   watch(%r{lib/guacamole/(.+)\.rb$}) { |m| "spec/unit/#{m[1]}_spec.rb" }
 end
-
-guard 'yard', port: '8808' do
-  watch(%r{lib/.+\.rb})
-end

data/README.md

@@ -1,6 +1,7 @@
 [![RubyDoc](http://img.shields.io/badge/📄-RubyDoc-be1d77.svg)](http://rubydoc.info/gems/guacamole/frames)
 [![Build Status](http://img.shields.io/travis/triAGENS/guacamole.svg)](https://travis-ci.org/triAGENS/guacamole)
 [![Code Climate](http://img.shields.io/codeclimate/github/triAGENS/guacamole.svg)](https://codeclimate.com/github/triAGENS/guacamole)
+[![Inline docs](http://inch-ci.org/github/triAGENS/guacamole.svg)](http://inch-ci.org/github/triAGENS/guacamole)
 [![Gem Version](http://img.shields.io/gem/v/guacamole.svg)](https://rubygems.org/gems/guacamole)
 
 # Guacamole
@@ -24,7 +25,7 @@ Since Guacamole is in an alpha state we suggest you to create a new Rails applic
 First of all create your shiny new application, without ActiveRecord of course:
 
 ```shell
-rails new -O $my_awesome_app
+rails new --skip-active-record $my_awesome_app
 ```
 
 Add this line to your application's Gemfile:
@@ -39,6 +40,24 @@ And then install the new dependencies:
 bundle install
 ```
 
+### Adding Guacamole to an existing Rails application
+
+Maybe you're bold and want to add Guacamole to an existing Rails application. In this case some things are different, because you already have an ORM configured. Throughout the remaining README you will find examples of using generators and rake tasks to support you. All the generators must be invoked with the `--orm guacamole` flag. Without this you will generate both, ActiveRecord and Guacamole files:
+
+```shell
+bundle exec rails generate model pony name:string birthday:date color:string --orm guacamole
+```
+
+Guacamole will not overwrite existing rake tasks and thus you need to invoke them with under the guacamole namespace:
+
+```shell
+rake db:guacamole:create
+rake db:guacamole:purge
+rake db:guacamole:drop
+```
+
+Everything else should work as described in the README. If you encounter any errors while working with an existing Rails application, please let us know.
+
 ### Configuration
 
 After you created the application and installed the dependencies the first thing you need is a configuration file. The database connection is pretty much configured as expected: With a YAML file. Luckily you don't have to create this file by yourself but you can use a generator to do it for you:
@@ -59,6 +78,8 @@ development:
   database: 'pony_blog_development'
 ```
 
+**Note**: If you use something like [dotenv](https://github.com/bkeepers/dotenv) we will process the config file with ERB before loading the YAML. Another way to configure the database connection is to provide a connection URI like this: `http://user:pass@localhost:8529/_db/pony_ville_db`. If you don't use authentication, just skip the user/password part. The connection URI must be provided as the environment variable `DATABASE_URL` and has precedence over the config file.
+
 After you created a configuration file you can create the database as in any other Rails project:
 
 ```shell
@@ -154,7 +175,7 @@ As the model doesn't know anything about the database you cannot define database
 
 ### Collections
 
-Collections are your gateway to the database. They persist your models and offer querying for them. They will translate the raw data from the database to your domain models and vice versa. By convention they are the pluralized version of the model with the suffix `Collection`. So given the model from above, this could be the according collection:
+Collections are your gateway to the database. They persist your models and offer querying for them. They will translate the raw data from the database to your domain models and vice versa. By convention they are the pluralized version of the model with the suffix `Collection`. So given the model from above, this could be the following collection:
 
 ```ruby
 class PoniesCollection
@@ -309,13 +330,13 @@ As you can see, from the model perspective there is nothing special about an emb
 
 ```json
 {
-  "_id": [...],
-  "_rev": [...],
-  "_key": [...],
+  "_id": "...",
+  "_rev": "...",
+  "_key": "...",
   "title": "The grand blog post",
   "body": "Lorem ipsum [...]",
   "create_at": "2014-05-03T16:55:43+02:00",
-  "updated_at": "2014-05-03T16:55:43+02:00"
+  "updated_at": "2014-05-03T16:55:43+02:00",
   "comments": [
     {
       "text": "This was really a grand blog post",
@@ -328,6 +349,7 @@ As you can see, from the model perspective there is nothing special about an emb
       "updated_at": "2014-05-04T16:55:43+02:00"
     }
   ]
+}
 ```
 
 **Note**: Again this will only work if you stick with the convention. So far there is no support to configure this more fine grained.
@@ -371,7 +393,7 @@ class PostsCollection
   include Guacamole::Collection
 
   map do
-    references :user
+    references :author
   end
 end
 ```
@@ -394,6 +416,120 @@ AuthorsCollection.save author
 # => Will save both the author and the post
 ```
 
+### Callbacks
+
+Guacamole allows you to define callbacks for various actions performed on a model. Those callbacks need to be defined in a dedicate class per model. For example to hash the password of a user prior creating the document in the database you would write something like the following:
+
+```ruby
+class UserCallbacks
+  include Guacamole::Callbacks
+
+  before_create :encrypt_password
+
+  def encrypt_password
+    object.encrypted_password = BCrypt::Password.create(object.password)
+  end
+end
+```
+
+Whenever callbacks needs to be executed for a model we create an instance of the specified callback with that model. You have access to the model via the `object` method. To specify a callback for a model you must use the `callbacks` method in that model:
+
+```ruby
+class User
+  include Guacamole::Model
+
+  callbacks :user_callbacks
+end
+``` 
+
+You can define define callbacks for the following actions:
+
+ * `before_validate`
+ * `around_validate`
+ * `after_validate`
+ * `before_save`
+ * `around_save`
+ * `after_save`
+ * `before_create`
+ * `around_create`
+ * `after_create`
+ * `before_update`
+ * `around_update`
+ * `after_update`
+ * `before_delete`
+ * `around_delete`
+ * `after_delete`
+
+The order of the callback execution is as follows:
+
+**Creating an object**
+
+ * `before_validation`
+ * `after_validation`
+ * `before_save`
+ * `around_save`
+ * `before_create`
+ * `around_create`
+ * `after_create`
+ * `after_save`
+
+**Updating an object**
+
+ * `before_validation`
+ * `after_validation`
+ * `before_save`
+ * `around_save`
+ * `before_update`
+ * `around_update`
+ * `after_update`
+ * `after_save`
+
+**Destroying an object**
+
+ * `before_delete`
+ * `around_delete`
+ * `after_delete`
+
+The order of the callback execution is as follows:
+
+**Creating an object**
+
+ 1. `before_validation`
+ 2. `after_validation`
+ 3. `before_save`
+ 4. `around_save`
+ 5. `before_create`
+ 6. `around_create`
+ 7. `after_create`
+ 8. `after_save`
+
+**Updating an object**
+
+ 1. `before_validation`
+ 2. `after_validation`
+ 3. `before_save`
+ 4. `around_save`
+ 5. `before_update`
+ 6. `around_update`
+ 7. `after_update`
+ 8. `after_save`
+
+**Destroying an object**
+
+ 1. `before_delete`
+ 2. `around_delete`
+ 3. `after_delete`
+
+#### Generator Support
+
+Of course we provide a generator to help you setting the required files up:
+
+```shell
+rails generate guacamole:callbacks pony
+```
+
+This will create the callback file, a test template and adds the appropriate register call to the model file.
+
 ## Integration into the Rails Ecosystem™
 
 Guacamole is a very young project. A lot of stuff is missing but still, if you want to get started with ArangoDB and are using Ruby/Rails it will give you a nice head start. Besides a long TODO list we want to hint to some points to help you integrate Guacamole with the rest of the Rails ecosystem:
@@ -402,17 +538,17 @@ Guacamole is a very young project. A lot of stuff is missing but still, if you w
 
 Currently we're not providing any testing helper, thus you need to make sure to cleanup the database yourself before each run. You can look at the [`spec/acceptance/spec_helper.rb`](https://github.com/triAGENS/guacamole/blob/master/spec/acceptance/spec_helper.rb) of Guacamole for inspiration of how to do that.
 
-For test data generation we're using the awesome [Fabrication gem](http://www.fabricationgem.org/). Again you find some usage examples in Guacamole's own acceptance tests. We didn't tested Factory Girl yet, but it eventually will work, too.
+For test data generation we're using the awesome [Fabrication gem](http://www.fabricationgem.org/). Again you find some usage examples in Guacamole's own acceptance tests. We haven't tested Factory Girl yet but it eventually will work too.
 
 ### Authentication
 
-Any integration into an authentication framework need to be done by you. At this time we have nothing to share with you about this topic.
+Any integration into an authentication framework needs to be done by you. At this time we have nothing to share with you about this topic.
 
 ### Forms
 
-While we not tested them they should probably work due to the ActiveModel compliance. But again, this not confirmed and you need to try it out by yourself.
+While we haven't tested them, they should probably work due to the ActiveModel compliance. But again, this is not confirmed and you need to try it out yourself.
 
-If you give Guacamole a try, please feel free to ask us any question or give us feedback to anything on your mind. This is really crucial for us and we would be more than happy to hear back from you.
+If you give Guacamole a try, please feel free to ask us any question or give us feedback about anything on your mind. This is really crucial for us and we would be more than happy to hear back from you.
 
 ## Todos
 

data/Rakefile

@@ -1,10 +1,37 @@
 # -*- encoding : utf-8 -*-
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'yard/rake/yardoc_task'
+require 'inch/rake'
+require 'reek/rake/task'
 
-require 'devtools'
-Devtools.init_rake_tasks
+desc 'Run all specs'
+task spec: ['spec:unit', 'spec:acceptance']
 
-import('./tasks/adjustments.rake')
+namespace :spec do
+  desc 'Run unit specs'
+  RSpec::Core::RakeTask.new(:unit) do |task|
+    task.pattern = 'spec/unit/**/*_spec.rb'
+  end
+
+  desc 'Run acceptance specs – requires running instance of ArangoDB'
+  RSpec::Core::RakeTask.new(:acceptance) do |task|
+    task.pattern = 'spec/acceptance/**/*_spec.rb'
+  end
+end
+
+YARD::Rake::YardocTask.new(:doc)
+
+namespace :metrics do
+  Inch::Rake::Suggest.new do |t|
+    t.args << '--pedantic'
+  end
+
+  Reek::Rake::Task.new do |t|
+    t.fail_on_error = true
+    t.config_files = '.reek.yml'
+  end
+end
 
 desc 'Start a REPL with guacamole loaded (not the Rails part)'
 task :console do
@@ -15,3 +42,6 @@ task :console do
   ARGV.clear
   Pry.start
 end
+
+task default: :spec
+task ci: ['spec', 'metrics:reek']

data/guacamole.gemspec

@@ -18,14 +18,25 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(spec)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'ashikawa-core', '~> 0.11.0'
+  spec.add_dependency 'ashikawa-core', '~> 0.12.0'
   spec.add_dependency 'virtus', '~> 1.0.1'
   spec.add_dependency 'activesupport', '>= 4.0.0'
   spec.add_dependency 'activemodel', '>= 4.0.0'
   spec.add_dependency 'hamster', '~> 1.0.1.pre.rc.1'
 
+  spec.add_development_dependency 'bcrypt', '3.1.7'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 0.3.0'
   spec.add_development_dependency 'fabrication', '~> 2.8.1'
   spec.add_development_dependency 'faker', '~> 1.2.0'
+  spec.add_development_dependency 'guard', '~> 2.6.1'
+  spec.add_development_dependency 'guard-bundler', '~> 2.0.0'
+  spec.add_development_dependency 'guard-rspec', '~> 4.2.10'
+  spec.add_development_dependency 'inch', '~> 0.4.6'
   spec.add_development_dependency 'logging', '~> 1.8.1'
   spec.add_development_dependency 'pry', '~> 0.9.12'
+  spec.add_development_dependency 'rake', '~> 10.3.2'
+  spec.add_development_dependency 'reek', '~> 1.3.7'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+  spec.add_development_dependency 'timecop', '~> 0.7.1'
+  spec.add_development_dependency 'yard', '~> 0.8.7.4'
 end

data/lib/guacamole.rb

@@ -5,6 +5,7 @@ require 'guacamole/exceptions'
 require 'guacamole/configuration'
 require 'guacamole/model'
 require 'guacamole/collection'
+require 'guacamole/callbacks'
 require 'guacamole/document_model_mapper'
 require 'guacamole/identity_map'
 

data/lib/guacamole/callbacks.rb

@@ -0,0 +1,259 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/string/inflections'
+require 'active_model' # Cherry Pick not possible
+
+module Guacamole
+  # Define callbacks for different life cycle events of a model
+  #
+  # Callbacks in Guacamole are defined in dedicated classes only. There will be no interface to implement them
+  # in the model or the collection context. This was done due to the nature of the data mapper pattern:
+  #
+  #  * The model doesn't know anything about the database thus defining persistence related callbacks (i.e. `before_create`)
+  #    would weaken this separation.
+  #  * Validation happens in the context of the model and thus defining all callbacks in the collection would still
+  #    be somewhat awkward.
+  #
+  # Due to those reasons Guacamole employs the concept of **external callbacks**. Just define a class and include
+  # the `Guacamole::Callbacks` module and you can define all kinds of callbacks. Under the hood `ActiveModel::Callbacks`
+  # is used to provide the callback execution functionality.
+  #
+  # @note Wether you define a callback class for your model or not, internally there always will be a callback.
+  #
+  # Since maintaining the time stamp attributes of your models are implemented as callbacks as well your callback
+  # class will have those methods included.
+  #
+  # Binding a callback class to a model will happen in the `Model.callbacks` method.
+  #
+  # Each callback class will be instantiated with the appropriate model instance. That instance is accessible through
+  # the `object` method.
+  #
+  # @example Define a callback to hash the password prior creation
+  #   class UserCallbacks
+  #     include Guacamole::Callbacks
+  #
+  #     before_create :encrypt_password
+  #
+  #     def encrypt_password
+  #       object.encrypted_password = BCrypt::Password.create(object.password)
+  #     end
+  #   end
+  #
+  # @!method self.before_validate(method_name)
+  #   Registers a method to be run before the validation will happen
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.around_validate(method_name)
+  #   Registers a method to be run before and after the validation will happen.
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #   @note You must `yield` at some point in the method.
+  #
+  # @!method self.after_validate(method_name)
+  #   Registers a method to be run after the validation happened
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.before_save(method_name)
+  #   Registers a method to be run before the collection class saves the model
+  #
+  #   Saving a model will always happen, no matter if the model will be created or
+  #   updated.
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.around_save(method_name)
+  #   Registers a method to be run before and after saving the model
+  #
+  #   Saving a model will always happen, no matter if the model will be created or
+  #   updated.
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #   @note You must `yield` at some point in the method.
+  #
+  # @!method self.after_save(method_name)
+  #   Registers a method to be run after the collection class has saved the model
+  #
+  #   Saving a model will always happen, no matter if the model will be created or
+  #   updated.
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.before_create(method_name)
+  #   Registers a method to be run before initially creating the model in the database
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.around_create(method_name)
+  #   Registers a method to be run before and after creating the model
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #   @note You must `yield` at some point in the method.
+  #
+  # @!method self.after_create(method_name)
+  #   Registers a method to be run after the creation of the model
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.before_update(method_name)
+  #   Registers a method to be run before updating the model
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.around_update(method_name)
+  #   Registers a method to be run before and after updating the model
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #   @note You must `yield` at some point in the method.
+  #
+  # @!method self.after_update(method_name)
+  #   Registers a method to be run after the model has been updated
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.before_delete(method_name)
+  #   Registers a method to be run before deleting the model
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #
+  # @!method self.around_delete(method_name)
+  #   Registers a method to be run before and after the deletion
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  #   @note You must `yield` at some point in the method.
+  #
+  # @!method self.after_delete(method_name)
+  #   Registers a method to be run after the deletion of the model has happened
+  #
+  #   @param [Symbol] method_name The name of the method to be executed
+  #   @api public
+  module Callbacks
+    extend ActiveSupport::Concern
+    # @!parse extend ActiveModel:Callbacks
+
+    included do
+      extend ActiveModel::Callbacks
+
+      define_model_callbacks :validate, :save, :create, :update, :delete
+
+      before_create :add_create_timestamps
+      before_update :update_updated_at_timestamp
+    end
+
+    # The default callback to be used if no custom callback was defined. This is done because it simplifies
+    # the callback invocation code and allows us to use callbacks for adding time stamps to the models.
+    class DefaultCallback
+      include Guacamole::Callbacks
+    end
+
+    # A proxy class around the callback class itself.
+    #
+    # The sole reason for its existence is to specify multiple callback runs at once. The alternative
+    # would have been to nest the `run_callbacks` calls within the caller. It was decided to have bit
+    # more complex proxy class to hide those details from the caller.
+    #
+    # @example
+    #   callbacks = Callbacks.callbacks_for(model)
+    #   callbacks.run_callbacks :save, :create do
+    #     CakeCollection.create model
+    #   end
+    # @private
+    class CallbackProxy
+      attr_reader :callbacks
+
+      # Create a new proxy with the original callbacks class as input
+      #
+      # @param [Callbacks] callbacks The original callback class to be executed
+      def initialize(callbacks)
+        @callbacks = callbacks
+      end
+
+      # Runs the given kinds of callbacks
+      #
+      # @param [Array<Symbol>] callbacks_to_run One or more kinds of callbacks to be run
+      # @yield Will call the code block wrapped by the given callbacks
+      def run_callbacks(*callbacks_to_run, &block)
+        outer = callbacks_to_run.pop
+
+        if callbacks_to_run.empty?
+          @callbacks.run_callbacks(outer, &block)
+        else
+          @callbacks = run_callbacks(*callbacks_to_run) do
+            @callbacks.run_callbacks(outer, &block)
+          end
+        end
+      end
+    end
+
+    class << self
+      # Register a callback class to be used with the model
+      #
+      # @api private
+      # @param [Model] model_class The class of a model
+      # @param [Callbacks] callback_class The class of the callbacks
+      def register_callback(model_class, callback_class)
+        registry[model_class] = callback_class
+      end
+
+      # Retrieve the callback instance for the given model
+      #
+      # @api private
+      # @params [Model] model The model instance for which callbacks must be executed
+      # @return [Callbacks] A callback instance with the given model accessible via `object`
+      def callbacks_for(model)
+        CallbackProxy.new registry[model.class].new(model)
+      end
+
+      # The internal storage of the callback-model pairs
+      #
+      # @api private
+      # @return [Hash] A hash with the default set to the `DefaultCallback`
+      def registry
+        @registry ||= Hash.new(DefaultCallback)
+      end
+    end
+
+    # Create a new callback instance with the given model instance
+    #
+    # @param [Model] model_instance The model instance the callbacks should be executed for
+    def initialize(model_instance)
+      @object = model_instance
+    end
+
+    # Provides access to the model instance.
+    #
+    # @retun [Model] A model instance
+    # @api public
+    def object
+      @object
+    end
+
+    # Sets `created_at` and `updated_at` to `Time.now`
+    def add_create_timestamps
+      object.created_at = Time.now
+      update_updated_at_timestamp
+    end
+
+    # Sets `updated_at` to `Time.now`
+    def update_updated_at_timestamp
+      object.updated_at = Time.now
+    end
+  end
+end