data_broker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab94b51d25a3a4822f72e55571c65a91093a59db
+  data.tar.gz: 8b934b53c08ca0ef7679fd34cb7863edf425032f
+SHA512:
+  metadata.gz: 57adee8f7db28230cf4b9b1b3f8e7b49e6f2c5a4ea1a7cdb52799db9b12a8651c09fee1b33002008728ff2553265423ddf760e8906697e632c560828ab6f7b84
+  data.tar.gz: 3b67351d428611e9902165b78317023dd1c8c6aab6ccce3cc0efbdfb430eb7cdd8eb8127aa3109878e1e986b0600a71d41b71ac61244606a4ffbfa3fc30c6426

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "coveralls", :require => false
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 TeamSnap
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+# DataBroker
+
+[![Semaphore](https://semaphoreapp.com/api/v1/projects/20b511c80e766c8d5d897140b7f7d87df8e4da9b/118941/shields_badge.png)](https://semaphoreapp.com/minter/data_broker)
+[![Code Climate](https://codeclimate.com/github/teamsnap/data_broker.png)](https://codeclimate.com/github/teamsnap/data_broker)
+[![Coverage Status](https://coveralls.io/repos/teamsnap/data_broker/badge.png?branch=master)](https://coveralls.io/r/teamsnap/data_broker?branch=master)
+[![Dependency Status](https://gemnasium.com/teamsnap/data_broker.png)](https://gemnasium.com/teamsnap/data_broker)
+[![License](http://img.shields.io/license/MIT.png?color=green)](http://opensource.org/licenses/MIT)
+
+A simplified implementation of the data mapper pattern
+
+![Data Broker](http://i.imgur.com/p01gSKM.jpg)
+
+Tired of the Active Record pattern forcing your design decision? Working with a legacy database that doesn't conform to Rails golden path? Then perhaps you need the [data mapper pattern](http://martinfowler.com/eaaCatalog/dataMapper.html).
+
+This library implements an extremely simplified version of the data mapper pattern. It allows you to map POROs (backed by Virtus) to arbitrary tables via ActiveRecord. The DataMapper gem provides this functionality, but not for Ruby 2.x/Rails 4.x. and the alternatives such as datamappify (lots of magic inferances that don't work well with legacy systems) and Ruby Object Mapper (not yet available for production) don't fit our needs at TeamSnap.
+
+Currently DataBroker only allows for a 1-to-1 mapping of objects to tables. In the future we plan to add 1-to-many mappings of objects to tables.
+
+The interface for DataBroker is purposefully lightweight and similar to both datamappify and ruby object mapper so that you can migrate between them with ease.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'data_broker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install data_broker
+
+## Usage
+
+View specs for sample usage.
+
+## Roadmap
+
+- Allow 1-to-many mappings of objects to tables
+- Implement the Unit of Work pattern (i.e. transactions) around 1-to-many mappings
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/data_broker.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'data_broker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "data_broker"
+  spec.version       = DataBroker::VERSION
+  spec.authors       = ["Shane Emmons"]
+  spec.email         = ["oss@teamsnap.com"]
+  spec.description   = "A simplified implementation of the data mapper pattern"
+  spec.summary       = "A simplified implementation of the data mapper pattern"
+  spec.homepage      = "https://github.com/teamsnap/data_broker"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "virtus", "~> 1.0"
+  spec.add_dependency "activesupport", "~> 4.0"
+  spec.add_dependency "activerecord", "~> 4.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "database_cleaner", "~> 1.2"
+end

data/lib/data_broker.rb

@@ -0,0 +1,21 @@
+require_relative "data_broker/mapper"
+require_relative "data_broker/value_object"
+require_relative "data_broker/version"
+
+module DataBroker
+  def self.mapper
+    Module.new do
+      def self.included(descendant)
+        descendant.send(:include, ::DataBroker::Mapper)
+      end
+    end
+  end
+
+  def self.value_object
+    Module.new do
+      def self.included(descendant)
+        descendant.send(:include, ::DataBroker::ValueObject)
+      end
+    end
+  end
+end

data/lib/data_broker/mapper.rb

@@ -0,0 +1,112 @@
+require "active_record"
+
+module DataBroker
+  module Mapper
+    def self.included(descendant)
+      super
+      descendant.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :mapping, :relations
+
+      def relations
+        @relations || {}
+      end
+
+      [:record, :model].each do |attr|
+        ivar = :"@#{attr}"
+        define_method(:"#{attr}=") do |value|
+          instance_variable_set(ivar, value)
+        end
+
+        define_method(:"#{attr}") do
+          instance_variable_get(ivar) || infer(attr)
+        end
+      end
+
+      def all
+        record_to_object(self.record.all)
+      end
+
+      def find(id)
+        record = eager_record.find_by(:id => id)
+        record.nil? ? nil : record_to_object(record, :eager_load => true)
+      end
+
+      def where(conds)
+        conds = Hash[conds.map { |key, value| [self.mapping[key], value] }]
+        record_to_object(
+          eager_record.where(conds), :eager_load => true
+        )
+      end
+
+      def save(model)
+        record = self.record.find_by(:id => model.id) || self.record.new
+        attributes = Hash[self.mapping.map { |key, value| [value, model[key]] }]
+        attributes.delete(:id)
+        record.attributes = attributes
+
+        record.save!
+        record_to_object(record)
+      end
+
+      def destroy(model)
+        record = self.record.find_by(:id => model.id)
+        record.nil? ? nil : record_to_object(record.destroy)
+      end
+
+      def record_to_object(record, eager_load: false)
+        if record.respond_to?(:each)
+          record.compact.map { |rec| record_to_object(rec, :eager_load => eager_load) }
+        else
+          attributes = Hash[self.mapping.map { |key, value| [key, record[value]] }]
+          self.model.new(attributes).tap do |model|
+            eager_load_relations(model, record) if eager_load
+          end
+        end
+      end
+
+      private
+
+      def eager_load_relations(model, record)
+        self.relations.each do |model_ref, record_ref|
+          rec = record.send(record_ref)
+          if rec
+            ref_mapper = mapper_for(model_ref)
+            ref = ref_mapper.record_to_object(rec)
+            model.instance_variable_set(:"@#{model_ref}", ref)
+          end
+        end
+      end
+
+      def mapper_for(model_ref)
+        "#{model_ref.to_s.singularize}_mapper".camelize.safe_constantize
+      end
+
+      def inferred_basename
+        self.to_s.underscore.sub(/_mapper$/, "").singularize.camelize
+      end
+
+      def inferred_model
+        inferred_basename.safe_constantize
+      end
+
+      def infer(attr)
+        if attr == :model
+          inferred_model
+        else
+          "#{inferred_basename}#{attr.to_s.camelize}".safe_constantize
+        end
+      end
+
+      def eager_record
+        self.record.includes(record_relations)
+      end
+
+      def record_relations
+        self.relations.values
+      end
+    end
+  end
+end

data/lib/data_broker/value_object.rb

@@ -0,0 +1,59 @@
+require "virtus"
+require "active_support/inflector"
+require "active_support/core_ext/object/try"
+
+module DataBroker
+  module ValueObject
+    def self.included(descendant)
+      descendant.send(:include, Virtus.value_object)
+      descendant.send(:include, ActiveSupport::Inflector)
+      descendant.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      include ActiveSupport::Inflector
+
+      def belongs_to(method)
+        mapper = "#{camelize(method.to_s)}Mapper"
+        via = foreign_key(camelize(method.to_s))
+
+        define_method(method) do
+          ivar = "@#{method}"
+          instance_variable_get(ivar) || instance_variable_set(
+            ivar, constantize(mapper).find(self.send(via))
+          )
+        end
+      end
+
+      def has_many(method)
+        mapper = "#{classify(method.to_s)}Mapper"
+        via = foreign_key(self.to_s)
+        ids_method = pluralize(foreign_key(classify(method.to_s)))
+
+        define_method(method) do
+          ivar = "@#{method}"
+          instance_variable_get(ivar) || instance_variable_set(
+            ivar, constantize(mapper).where(via.to_sym => self.id)
+          )
+        end
+
+        define_method(ids_method) do
+          ivar = "@#{ids_method}"
+          instance_variable_get(ivar) || instance_variable_set(
+            ivar, send(method).map(&:id)
+          )
+        end
+      end
+
+      def delegate(method, to: nil)
+        delegated = "#{to}_#{method}"
+        define_method(delegated) do
+          ivar = "@#{delegated}"
+          instance_variable_get(ivar) || instance_variable_set(
+            ivar, send(to).try(method)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/data_broker/version.rb

@@ -0,0 +1,3 @@
+module DataBroker
+  VERSION = "0.0.1"
+end

data/spec/mapper_spec.rb

@@ -0,0 +1,213 @@
+require_relative "spec_helper"
+require "sqlite3"
+require_relative "../lib/data_broker"
+
+class Parent
+  include DataBroker.value_object
+
+  values do
+    attribute :id, Integer
+  end
+
+  has_many :children
+end
+
+class Child
+  include DataBroker.value_object
+
+  values do
+    attribute :id, Integer
+    attribute :name, String
+    attribute :parent_id, Integer
+  end
+
+  belongs_to :parent
+end
+
+class ParentRecord < ActiveRecord::Base
+  self.table_name = :parents
+  has_many :children, :class_name => "ChildRecord",
+    :foreign_key => :parent_id
+end
+
+class ChildRecord < ActiveRecord::Base
+  self.table_name = :children
+  belongs_to :parent, :class_name => "ParentRecord",
+    :foreign_key => :parent_id
+end
+
+class ParentMapper
+  include DataBroker.mapper
+
+  self.mapping = {
+    :id => :id
+  }
+
+  self.relations = {
+    :children => :children
+  }
+end
+
+class ChildMapper
+  include DataBroker.mapper
+
+  self.mapping = {
+    :id => :id,
+    :name => :child_name,
+    :parent_id => :parent_id
+  }
+
+  self.relations = {
+    :parent => :parent
+  }
+end
+
+describe DataBroker::Mapper do
+  let(:mapper) { ChildMapper }
+  let(:parent_mapper) { ParentMapper }
+
+  it "infers record if not given" do
+    expect(mapper.record).to eq(ChildRecord)
+  end
+
+  it "infers model if not given" do
+    expect(mapper.model).to eq(Child)
+  end
+
+  describe "#all" do
+    it "uses the record to fetch all entries" do
+      3.times { mapper.record.create }
+
+      objs = mapper.all
+      expect(objs.size).to eq(3)
+    end
+
+    it "returns objects cast as the model" do
+      mapper.record.create
+      obj = mapper.all.first
+
+      expect(obj).to be_a(mapper.model)
+    end
+  end
+
+  describe "#find" do
+    it "finds the record matching the given primary key" do
+      id = mapper.record.create(:child_name => "Team Jacob").id
+
+      obj = mapper.find(id)
+      expect(obj.id).to eq(id)
+      expect(obj.name).to eq("Team Jacob")
+    end
+
+    it "returns the object cast as the model" do
+      id = mapper.record.create.id
+
+      obj = mapper.find(id)
+      expect(obj).to be_a(mapper.model)
+    end
+
+    it "returns nil if the object isn't found" do
+      obj = mapper.find(0)
+      expect(obj).to be_nil
+    end
+
+    it "eager loads relations" do
+      parent_id = parent_mapper.record.create.id
+      id = mapper.record.create(:parent_id => parent_id)
+      obj = mapper.find(id)
+
+      parent = obj.instance_variable_get(:@parent)
+      expect(parent).to eq(parent_mapper.find(parent_id))
+    end
+  end
+
+  describe "#where" do
+    it "returns and empty array if conds yield no results" do
+      objs = mapper.where(:name => "Team Jacob")
+      expect(objs).to be_empty
+    end
+
+    it "returns the objects cast as the model" do
+      id = mapper.record.create.id
+      obj = mapper.where(:id => id).first
+
+      expect(obj).to be_a(mapper.model)
+    end
+
+    it "returns the objects matching the conds" do
+      id = mapper.record.create(:child_name => "Team Jacob").id
+      obj = mapper.where(:id => id).first
+
+      expect(obj.id).to eq(id)
+      expect(obj.name).to eq("Team Jacob")
+    end
+
+    it "uses the mappings to translate model attrs to db columns" do
+      id = mapper.record.create(:child_name => "Team Jacob").id
+      obj = mapper.where(:name => "Team Jacob").first
+
+      expect(obj.id).to eq(id)
+    end
+
+    it "returns all matches" do
+      3.times { |n| mapper.record.create(:child_name => "Team Jacob") }
+      objs = mapper.where(:name => "Team Jacob")
+
+      expect(objs.size).to eq(3)
+    end
+
+    it "eager loads relations" do
+      parent_id = parent_mapper.record.create.id
+      id = mapper.record.create(:parent_id => parent_id)
+      obj = mapper.where(:id => id).first
+
+      parent = obj.instance_variable_get(:@parent)
+      expect(parent).to eq(parent_mapper.find(parent_id))
+    end
+  end
+
+  describe "#save" do
+    it "translates a model and saves it as a record" do
+      mapper.save(mapper.model.new(:name => "Team Jacob"))
+      ds = mapper.record.where(:child_name => "Team Jacob")
+
+      expect(ds).to_not be_empty
+    end
+
+    it "returns the model" do
+      model = mapper.model.new(:name => "Team Jacob")
+      rt = mapper.save(model)
+
+      expect(rt.name).to eq(model.name)
+    end
+
+    it "updates an existing model" do
+      model = mapper.save(mapper.model.new)
+      model = model.with(:name => "Team Jacob")
+      rt = mapper.save(model)
+
+      expect(rt.id).to eq(model.id)
+    end
+  end
+
+  describe "#destroy" do
+    it "returns nil if the object doesn't exist" do
+      obj = mapper.destroy(mapper.model.new(:id => 0))
+      expect(obj).to be_nil
+    end
+
+    it "returns the destroyed object" do
+      model = mapper.save(mapper.model.new)
+      rt = mapper.destroy(model)
+
+      expect(model).to eq(rt)
+    end
+
+    it "destroys the object" do
+      model = mapper.save(mapper.model.new)
+      mapper.destroy(model)
+
+      expect(mapper.find(model.id)).to be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require "coveralls"
+Coveralls.wear!
+
+require "active_record"
+require "database_cleaner"
+
+ActiveRecord::Base.establish_connection(
+  :adapter => "sqlite3", :database => ":memory:"
+)
+
+ActiveRecord::Migration.create_table :parents
+ActiveRecord::Migration.create_table :children do |t|
+  t.string :child_name
+  t.references :parent
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.order = "random"
+end

data/spec/value_object_spec.rb

@@ -0,0 +1,169 @@
+require_relative "spec_helper"
+require_relative "../lib/data_broker"
+
+class TestValueObject
+  include DataBroker.value_object
+
+  values do
+    attribute :id, Integer
+    attribute :parent_id, Integer
+  end
+
+  belongs_to :parent
+
+  has_many :friends
+
+  delegate :name, :to => :parent
+end
+
+describe DataBroker::ValueObject do
+  describe ".new" do
+    it "creates a new object" do
+      obj = TestValueObject.new
+      expect(obj).to be_a(TestValueObject)
+    end
+
+    it "accepts attributes in the constructor" do
+      obj = TestValueObject.new(:id => 1, :parent_id => 2)
+      expect(obj.id).to eq(1)
+      expect(obj.parent_id).to eq(2)
+    end
+  end
+
+  describe "#with" do
+    it "creates a copy of the object with updated attributes" do
+      obj1 = TestValueObject.new(:id => 1, :parent_id => 2)
+      obj2 = obj1.with(:id => 2)
+
+      expect(obj1).to_not eq(obj2)
+      expect(obj2.id).to eq(2)
+      expect(obj2.parent_id).to eq(2)
+    end
+  end
+
+  describe ".belongs_to" do
+    it "adds a lookup method" do
+      obj = TestValueObject.new
+      expect(obj).to respond_to(:parent)
+    end
+
+    it "figures out what mapper and column to use, and uses them" do
+      obj = TestValueObject.new(:parent_id => 1)
+      mapper = double("ParentMapper")
+      allow(obj).to receive(:constantize).with("ParentMapper") { mapper }
+      expect(mapper).to receive(:find).with(1)
+
+      obj.parent
+    end
+
+    it "memoizes the results" do
+      obj = TestValueObject.new(:parent_id => 1)
+      mapper = double("ParentMapper", :find => :foo)
+      allow(obj).to receive(:constantize).with("ParentMapper") { mapper }
+
+      2.times { obj.parent }
+      expect(mapper).to have_received(:find).once
+    end
+  end
+
+  describe ".has_many" do
+    context "lookup method" do
+      it "adds a lookup method" do
+        obj = TestValueObject.new
+        expect(obj).to respond_to(:friends)
+      end
+
+      it "figures out what mapper and via to use, and uses them" do
+        obj = TestValueObject.new(:id => 1)
+        mapper = double("FriendMapper")
+        allow(obj).to receive(:constantize).with("FriendMapper") { mapper }
+        expect(mapper).to receive(:where).with(:test_value_object_id => 1)
+
+        obj.friends
+      end
+
+      it "memoizes results" do
+        obj = TestValueObject.new(:id => 1)
+        mapper = double("FriendMapper", :where => :foo)
+        allow(obj).to receive(:constantize).with("FriendMapper") { mapper }
+
+        2.times { obj.friends }
+        expect(mapper).to have_received(:where).once
+      end
+    end
+
+    context "id lookup method" do
+      it "add an id lookup method" do
+        obj = TestValueObject.new
+        expect(obj).to respond_to(:friend_ids)
+      end
+
+      it "gets the ids of objects found via the lookup method" do
+        obj = TestValueObject.new(:id => 1)
+        mapper = double("FriendMapper")
+        allow(obj).to receive(:constantize).with("FriendMapper") { mapper }
+        expect(mapper).to receive(:where).with(:test_value_object_id => 1) {
+          [double(:id => 1), double(:id => 2)]
+        }
+
+        expect(obj.friend_ids).to eq([1,2])
+      end
+
+      it "memoizes results" do
+        obj = TestValueObject.new(:id => 1)
+        results = [double(:id => 1), double(:id => 2)]
+        mapper = double("FriendMapper", :where => results)
+        allow(obj).to receive(:constantize).with("FriendMapper") { mapper }
+
+        2.times { obj.friend_ids }
+        expect(mapper).to have_received(:where).once
+      end
+    end
+  end
+
+  describe ".delegate" do
+    it "creates a delegated method" do
+      obj = TestValueObject.new
+      expect(obj).to respond_to(:parent_name)
+    end
+
+    it "sends the message to the delegated object" do
+      obj = TestValueObject.new
+      parent = double(:name => "Bobby")
+      allow(obj).to receive(:parent) { parent }
+
+      expect(obj.parent_name).to eq("Bobby")
+    end
+
+    it "returns nil if the delegated object is nil" do
+      obj = TestValueObject.new
+      allow(obj).to receive(:parent) { nil }
+
+      expect(obj.parent_name).to be_nil
+    end
+
+    it "memoizes the results" do
+      obj = TestValueObject.new
+      allow(obj).to receive(:parent) { double(:name => true) }
+
+      2.times { obj.parent_name }
+      expect(obj).to have_received(:parent).once
+    end
+  end
+
+  describe "#==" do
+    it "considers objects with the same attributes to be equivalent" do
+      obj1 = TestValueObject.new(:id => 1, :parent_id => 2)
+      obj2 = TestValueObject.new(:id => 1, :parent_id => 2)
+
+      expect(obj1).to eq(obj2)
+    end
+
+    it "considers objects with non-matching attributes to not be equivalent" do
+      obj1 = TestValueObject.new(:id => 1, :parent_id => 2)
+      obj2 = TestValueObject.new(:id => 2, :parent_id => 2)
+
+      expect(obj1).to_not eq(obj2)
+    end
+  end
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: data_broker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Shane Emmons
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: A simplified implementation of the data mapper pattern
+email:
+- oss@teamsnap.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- data_broker.gemspec
+- lib/data_broker.rb
+- lib/data_broker/mapper.rb
+- lib/data_broker/value_object.rb
+- lib/data_broker/version.rb
+- spec/mapper_spec.rb
+- spec/spec_helper.rb
+- spec/value_object_spec.rb
+homepage: https://github.com/teamsnap/data_broker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A simplified implementation of the data mapper pattern
+test_files:
+- spec/mapper_spec.rb
+- spec/spec_helper.rb
+- spec/value_object_spec.rb