minimapper 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1 @@
+rvm ruby-1.9.3-p0-patched@minimapper --create

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  # 1.9 rubies
+  - 1.9.3
+  - 1.9.2
+  - rbx-19mode
+  - jruby-19mode
+
+  # 1.8 rubies
+  - ree
+  - 1.8.7
+  - jruby-18mode
+  - rbx-18mode
+script: "script/ci"

data/Gemfile

@@ -0,0 +1,21 @@
+source 'https://rubygems.org'
+
+# We don't require active_record to use minimapper, only to
+# use minimapper/ar. We do require it for the tests though :)
+gem "activerecord"
+gem "rspec"
+
+platforms :ruby do
+  gem "sqlite3"
+  gem "pg"
+  gem "mysql2"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbcsqlite3-adapter"
+  gem "activerecord-jdbcpostgresql-adapter"
+  gem "activerecord-jdbcmysql-adapter"
+end
+
+# Specify your gem's dependencies in minimapper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Joakim Kolsjö
+
+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,133 @@
+![Build status](https://secure.travis-ci.org/joakimk/minimapper.png) | [builds](https://travis-ci.org/#!/joakimk/minimapper/builds)
+
+# Minimapper
+
+A minimalistic way of separating your models from ORMs like ActiveRecord that allows you to swap out your persistance layer for an in-memory implementation in tests or use different persistance for different models.
+
+If you're following good style you're probably already pushing all knowledge of your ORM down into your models or model-layer classes. This takes it a step further and let's you work with your models without depending on heavy frameworks like rails or needing a database.
+
+Minimapper is a partial [repository-pattern](http://martinfowler.com/eaaCatalog/repository.html) implementation (it implements repositories and data mappers but not critera builders).
+
+## Only the most basic API
+
+This library only implements the most basic persistance API (mostly just CRUD). Any significant additions will be made into separate gems (with names like "minimapper-FOO").
+
+The reasons for this are:
+* You should be able to feel secure about depending on the API
+* It should be possible to learn all it does in a short time
+* It should be simple to add an adapter for a new database
+* It should be simple to maintain minimapper
+
+## Compatibility
+
+This gem is tested against all major rubies in both 1.8 and 1.9, see [.travis.yml](https://github.com/joakimk/minimapper/blob/master/.travis.yml). For each ruby version, the SQL mappers are tested against SQLite3, PostgreSQL and MySQL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'minimapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install minimapper
+
+Please avoid installing directly from the github repository. Code will be pushed there that might fail in [CI](https://travis-ci.org/#!/joakimk/minimapper/builds) (because testing all permutations of ruby versions and databases locally isn't practical). Gem releases are only done when CI is green.
+
+## Usage
+
+You can use the mappers directly like this:
+
+``` ruby
+class User < Minimapper::Entity
+  attributes :name, :email
+  validates :name, presence: true
+end
+
+class UserMapper < Minimapper::Memory
+end
+
+# Creating
+user = User.new(name: "Joe")
+mapper = UserMapper.new
+mapper.create(user)
+
+# Finding
+user = mapper.find(1)
+
+# Updating
+user.name = "Joey"
+mapper.update(user)
+
+# Deleting
+mapper.delete(user)
+
+# Deleting all
+mapper.delete_all
+```
+
+Or though a repository:
+
+``` ruby
+repository = Minimapper::Repository.build({
+  users:    UserMapper.new,
+  projects: ProjectMapper.new
+})
+
+repository.users.find(1)
+```
+
+## Using the ActiveRecord mapper
+
+``` ruby
+module AR
+  class UserMapper < Minimapper::AR
+  end
+
+  class User < ActiveRecord::Base
+    attr_accessible :name, :email
+  end
+end
+
+user = User.new(name: "Joe")
+mapper = AR::UserMapper.new
+mapper.create(user)
+```
+
+## Implementing custom queries
+
+*todo* show how, talk about shared examples.
+
+## Implementing another mapper
+
+*todo*: how to use the shared examples
+
+## Inspiration
+
+Jason Roelofs:
+* [Designing a Rails App](http://jasonroelofs.com/2012/05/29/designing-a-rails-app-part-1/) (find the whole series of posts)
+
+Robert "Uncle Bob" Martin:
+* [Architecture: The Lost Years](http://www.confreaks.com/videos/759-rubymidwest2011-keynote-architecture-the-lost-years)
+* [The Clean Architecture](http://blog.8thlight.com/uncle-bob/2012/08/13/the-clean-architecture.html)
+
+## Running the tests
+
+You need mysql and postgres installed (but they do not have to be running) to be able to run bundle. The sql-mapper tests use sqlite3 by default.
+
+    bundle
+    rake
+
+## Contributing
+
+0. Read "Only the most basic API" above
+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. Don't forget to write test
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+namespace :spec do
+  task :unit do
+    puts "Running unit tests."
+    spec_helper_path = File.expand_path("unit/spec_helper.rb")
+    system("rspec", "-r#{spec_helper_path}", *Dir["unit/**/*_spec.rb"]) || exit(1)
+  end
+
+  task :integrated do
+    puts "Running integrated tests."
+    integrated_helper_path = File.expand_path("spec/spec_helper.rb")
+    system("rspec", "-r#{integrated_helper_path}", *Dir["spec/**/*_spec.rb"]) || exit(1)
+  end
+end
+
+task :spacer do
+  puts
+end
+
+task :spec => [ :"spec:unit", :spacer, :"spec:integrated" ]
+task :default => :spec

data/lib/minimapper/ar.rb

@@ -0,0 +1,95 @@
+require "minimapper/common"
+
+module Minimapper
+  class AR
+    # Create
+    def create(entity)
+      if entity.valid?
+        entity.id = record_klass.create!(entity.attributes).id
+      else
+        false
+      end
+    end
+
+    # Read
+    def find(id)
+      entity_for(find_record(id))
+    end
+
+    def all
+      record_klass.all.map { |record| entity_klass.new(record.attributes) }
+    end
+
+    def first
+      entity_for(record_klass.order("id ASC").first)
+    end
+
+    def last
+      entity_for(record_klass.order("id ASC").last)
+    end
+
+    def count
+      record_klass.count
+    end
+
+    # Update
+    def update(entity)
+      if entity.valid?
+        record_for(entity).update_attributes!(entity.attributes)
+        true
+      else
+        false
+      end
+    end
+
+    # Delete
+    def delete(entity)
+      delete_by_id(entity.id)
+    end
+
+    def delete_by_id(id)
+      find_record(id).delete
+    end
+
+    def delete_all
+      record_klass.delete_all
+    end
+
+    private
+
+    # TODO: write tests for these, they are indirectly tested by the fact
+    # that the test suite runs, but there could be bugs and I'll extract minimapper soon.
+
+    # Will attempt to use AR:Project as the record class
+    # when the mapper class name is AR::ProjectMapper
+    def record_klass
+      @record_klass ||= self.class.name.gsub(/Mapper/, '').constantize
+      @record_klass
+    end
+
+    # Will attempt to use Project as the enity class when
+    # the mapper class name is AR::ProjectMapper
+    def entity_klass
+      @entity_klass ||= ("::" + self.class.name.split('::').last.gsub(/Mapper/, '')).constantize
+      @entity_klass
+    end
+
+    def find_record(id)
+      (id && record_klass.find_by_id(id)) ||
+        raise(Common::CanNotFindEntity, :id => id)
+    end
+
+    def record_for(entity)
+      (entity.id && record_klass.find_by_id(entity.id)) ||
+        raise(Common::CanNotFindEntity, entity.inspect)
+    end
+
+    def entity_for(record)
+      if record
+        entity_klass.new(record.attributes)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/minimapper/common.rb

@@ -0,0 +1,5 @@
+module Minimapper
+  module Common
+    CanNotFindEntity            = Class.new(StandardError)
+  end
+end

data/lib/minimapper/entity.rb

@@ -0,0 +1,44 @@
+# Minimapper does not require you to use this entity base class. It requires a
+# few methods to be present, like valid?, attributes, attributes=.
+#
+# I plan to convert this to a module and add shared examples that cover
+# the API which minimapper depends upon.
+#
+# This class also does some things needed for it to work well with rails.
+require 'informal'
+
+module Minimapper
+  class Entity
+    include Informal::Model
+
+    def self.attributes(*list)
+      list.each do |attribute|
+        define_method(attribute) do
+          instance_variable_get("@#{attribute}")
+        end
+
+        define_method("#{attribute}=") do |value|
+          instance_variable_set("@#{attribute}", value)
+          @attributes[attribute] = value
+        end
+      end
+    end
+
+    def initialize(*opts)
+      @attributes = {}
+      super(*opts)
+    end
+
+    def to_param
+      id
+    end
+
+    def persisted?
+      id
+    end
+
+    attributes :id, :created_at, :updated_at
+
+    attr_reader :attributes
+  end
+end

data/lib/minimapper/memory.rb

@@ -0,0 +1,78 @@
+module Minimapper
+  class Memory
+    def initialize
+      @store = []
+      @last_id = 0
+    end
+
+    # Create
+    def create(entity)
+      if entity.valid?
+        entity.id = next_id
+        store.push(entity.dup)
+        last_id
+      else
+        false
+      end
+    end
+
+    # Read
+    def find(id)
+      find_internal(id).dup
+    end
+
+    def all
+      store.map { |entity| entity.dup }
+    end
+
+    def first
+      store.first && store.first.dup
+    end
+
+    def last
+      store.last && store.last.dup
+    end
+
+    def count
+      all.size
+    end
+
+    # Update
+    def update(entity)
+      if entity.valid?
+        known_entity = find_internal(entity.id)
+        known_entity.attributes = entity.attributes
+        true
+      else
+        false
+      end
+    end
+
+    # Delete
+    def delete(entity)
+      delete_by_id(entity.id)
+    end
+
+    def delete_by_id(id)
+      entity = find_internal(id)
+      store.delete(entity)
+    end
+
+    def delete_all
+      store.clear
+    end
+
+    private
+
+    def find_internal(id)
+      (id && store.find { |e| e.id == id.to_i }) ||
+        raise(Common::CanNotFindEntity, :id => id)
+    end
+
+    def next_id
+      @last_id += 1
+    end
+
+    attr_reader :store, :last_id
+  end
+end

data/lib/minimapper/repository.rb

@@ -0,0 +1,29 @@
+module Minimapper
+  class Repository
+    def self.build(mappers)
+      new(mappers)
+    end
+
+    def initialize(mappers)
+      @mappers = mappers
+      define_mapper_methods
+    end
+
+    def delete_all!
+      mappers.each { |name, instance| instance.delete_all }
+    end
+
+    private
+
+    def define_mapper_methods
+      mappers.each do |name, instance|
+        singleton = (class << self; self end)
+        singleton.send(:define_method, name) do # def mapper_name
+          instance                              #   instance
+        end                                     # end
+      end
+    end
+
+    attr_reader :mappers
+  end
+end

data/lib/minimapper/version.rb

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

data/lib/minimapper.rb

@@ -0,0 +1,7 @@
+require "minimapper/version"
+#require "minimapper/repository"
+#require "minimapper/memory"
+#require "minimapper/ar"
+
+module Minimapper
+end

data/minimapper.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minimapper/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "minimapper"
+  gem.version       = Minimapper::VERSION
+  gem.authors       = ["Joakim Kolsjö"]
+  gem.email         = ["joakim.kolsjo@gmail.com"]
+  gem.description   = %q{A minimalistic way of separating your models from ORMs like ActiveRecord (by implementing the repository pattern)}
+  gem.summary       = %q{A minimalistic way of separating your models from ORMs like ActiveRecord (by implementing the repository pattern)}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "informal"
+  gem.add_dependency "rake"
+end

data/script/ci

@@ -0,0 +1,16 @@
+#!/bin/bash
+set -e
+export CI=true
+bundle exec rake spec:unit
+
+echo
+echo "Using sqlite3:"
+bundle exec rake spec:integrated
+
+echo
+echo "Using postgres:"
+bundle exec rake spec:integrated DB=postgres
+
+echo
+echo "Using mysql:"
+bundle exec rake spec:integrated DB=mysql

data/script/turbux_rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+#
+# Command to run the specs the correct way when triggered from the turbux vim plugin.
+
+rails_spec = ARGV.first.start_with?("spec/") || ARGV.first.include?('/spec/')
+
+if rails_spec
+  command = "rspec"
+else
+  spec_helper_path = File.expand_path("unit/spec_helper.rb")
+
+  # Don't load bundler for non-rails unit tests
+  command = "RUBYOPT='' rspec -r#{spec_helper_path} --color --tty"
+end
+
+command += " #{ARGV.first}"
+exit(1) unless system(command)

data/spec/ar_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "minimapper/entity"
+require "minimapper/ar"
+
+class TestEntity < Minimapper::Entity
+  attributes :name, :github_url
+  validates :name, :presence => true
+end
+
+class TestMapper < Minimapper::AR
+  private
+
+  def entity_klass
+    TestEntity
+  end
+
+  def record_klass
+    Record
+  end
+
+  class Record < ActiveRecord::Base
+    attr_accessible :name
+    self.table_name = :projects
+  end
+end
+
+describe Minimapper::AR do
+  let(:repository) { TestMapper.new }
+  let(:entity_klass) { TestEntity }
+
+  include_examples :mapper
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require "active_record"
+require "minimapper"
+
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), "..")) unless defined?(ROOT)
+Dir[File.join(ROOT, "spec/support/shared_examples/*.rb")].each { |f| require f }
+
+require File.join(ROOT, "spec/support/database_setup")
+
+RSpec.configure do |config|
+  config.before(:each) do
+    ActiveRecord::Base.connection.execute "DELETE FROM projects;"
+  end
+end

data/spec/support/database_setup.rb

@@ -0,0 +1,51 @@
+class DB
+  POSTGRES_USERNAME = ENV['CI'] ? 'postgres' : ENV['USER']
+
+  def use_sqlite3
+    if jruby?
+      connect :adapter => "jdbcsqlite3", :database => ":memory:"
+    else
+      connect :adapter => "sqlite3", :database => ":memory:"
+    end
+  end
+
+  def use_postgres
+    system "psql -c 'create database minimapper_test;' -d postgres -U #{POSTGRES_USERNAME} 2> /dev/null"
+    connect :adapter => "postgresql", :database => "minimapper_test",
+            :username => POSTGRES_USERNAME
+  end
+
+  def use_mysql
+    system "mysql -e 'create database minimapper_test;' 2> /dev/null"
+    adapter = jruby? ? "jdbcmysql" : "mysql2"
+    connect :adapter => adapter, :database => "minimapper_test",
+            :username => "root"
+  end
+
+  private
+
+  def jruby?
+    RUBY_PLATFORM == "java"
+  end
+
+  def connect(opts)
+    ActiveRecord::Base.establish_connection(opts)
+  end
+end
+
+case ENV['DB']
+when 'postgres'
+  DB.new.use_postgres
+when 'mysql'
+  DB.new.use_mysql
+else
+  DB.new.use_sqlite3
+end
+
+silence_stream(STDOUT) do
+  ActiveRecord::Schema.define(:version => 0) do
+    create_table :projects, :force => true do |t|
+      t.string :name
+    end
+  end
+end

data/spec/support/shared_examples/mapper.rb

@@ -0,0 +1,223 @@
+shared_examples :mapper do
+  # expects repository and entity_klass to be defined
+
+  describe "create" do
+    it "sets an id on the entity" do
+      entity1 = build_valid_entity
+      entity1.id.should be_nil
+      repository.create(entity1)
+      entity1.id.should > 0
+
+      entity2 = build_valid_entity
+      repository.create(entity2)
+      entity2.id.should == entity1.id + 1
+    end
+
+    it "returns the id" do
+      id = repository.create(build_valid_entity)
+      id.should be_kind_of(Fixnum)
+      id.should > 0
+    end
+
+    it "does not store by reference" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.last.object_id.should_not == entity.object_id
+      repository.last.name.should == "test"
+    end
+
+    it "validates the record before saving" do
+      entity = entity_klass.new
+      repository.create(entity).should be_false
+    end
+  end
+
+  describe "find" do
+    it "returns an entity matching the id" do
+      entity = build_valid_entity
+      repository.create(entity)
+      found_entity = repository.find(entity.id)
+      found_entity.name.should == "test"
+      found_entity.id.should == entity.id
+      found_entity.should be_kind_of(Minimapper::Entity)
+    end
+
+    it "supports string ids" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.find(entity.id.to_s)
+    end
+
+    it "does not return the same instance" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.find(entity.id).object_id.should_not == entity.object_id
+      repository.find(entity.id).object_id.should_not == repository.find(entity.id).object_id
+    end
+
+    it "fails when the an entity can not be found" do
+      lambda { repository.find(-1) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+  end
+
+  describe "all" do
+    it "returns all entities in undefined order" do
+      first_created_entity = build_valid_entity
+      second_created_entity = build_valid_entity
+      repository.create(first_created_entity)
+      repository.create(second_created_entity)
+      all_entities = repository.all
+      all_entities.map(&:id).should include(first_created_entity.id)
+      all_entities.map(&:id).should include(second_created_entity.id)
+      all_entities.first.should be_kind_of(Minimapper::Entity)
+    end
+
+    it "does not return the same instances" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.all.first.object_id.should_not == entity.object_id
+      repository.all.first.object_id.should_not == repository.all.first.object_id
+    end
+  end
+
+  describe "first" do
+    it "returns the first entity" do
+      first_created_entity = build_valid_entity
+      repository.create(first_created_entity)
+      repository.create(build_valid_entity)
+      repository.first.id.should == first_created_entity.id
+      repository.first.should be_kind_of(entity_klass)
+    end
+
+    it "does not return the same instance" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.first.object_id.should_not == entity.object_id
+      repository.first.object_id.should_not == repository.first.object_id
+    end
+
+    it "returns nil when there is no entity" do
+      repository.first.should be_nil
+    end
+  end
+
+  describe "last" do
+    it "returns the last entity" do
+      last_created_entity = build_valid_entity
+      repository.create(build_valid_entity)
+      repository.create(last_created_entity)
+      repository.last.id.should == last_created_entity.id
+      repository.last.should be_kind_of(entity_klass)
+    end
+
+    it "does not return the same instance" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.last.object_id.should_not == entity.object_id
+      repository.last.object_id.should_not == repository.last.object_id
+    end
+
+    it "returns nil when there is no entity" do
+      repository.last.should be_nil
+    end
+  end
+
+  describe "count" do
+    it "returns the number of entities" do
+      repository.create(build_valid_entity)
+      repository.create(build_valid_entity)
+      repository.count.should == 2
+    end
+  end
+
+  describe "update" do
+    it "updates" do
+      entity = build_valid_entity
+      repository.create(entity)
+
+      entity.name = "Updated"
+      repository.last.name.should == "test"
+
+      repository.update(entity)
+      repository.last.id.should == entity.id
+      repository.last.name.should == "Updated"
+    end
+
+    it "does not update and returns false when the entity isn't valid" do
+      entity = build_valid_entity
+      repository.create(entity)
+      entity.name = nil
+
+      repository.update(entity).should be_false
+      repository.last.name.should == "test"
+    end
+
+    it "returns true" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.update(entity).should == true
+    end
+
+    it "fails when the entity does not have an id" do
+      entity = build_valid_entity
+      lambda { repository.update(entity) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+
+    it "fails when the entity no longer exists" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.delete_all
+      lambda { repository.update(entity) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+  end
+
+  describe "delete" do
+    it "removes the entity" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.create(build_valid_entity)
+      repository.delete(entity)
+      repository.all.size.should == 1
+      repository.first.id.should_not == entity.id
+    end
+
+    it "fails when the entity does not have an id" do
+      entity = entity_klass.new
+      lambda { repository.delete(entity) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+
+    it "fails when the entity can not be found" do
+      entity = entity_klass.new(:id => -1)
+      lambda { repository.delete(entity) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+  end
+
+  describe "delete_by_id" do
+    it "removes the entity" do
+      entity = build_valid_entity
+      repository.create(entity)
+      repository.create(build_valid_entity)
+      repository.delete_by_id(entity.id)
+      repository.all.size.should == 1
+      repository.first.id.should_not == entity.id
+    end
+
+    it "fails when the an entity can not be found" do
+      lambda { repository.delete_by_id(-1) }.should raise_error(Minimapper::Common::CanNotFindEntity)
+    end
+  end
+
+  describe "delete_all" do
+    it "empties the repository" do
+      repository.create(build_valid_entity)
+      repository.delete_all
+      repository.all.should == []
+    end
+  end
+
+  private
+
+  def build_valid_entity
+    entity_klass.new(:name => 'test')
+  end
+end

data/unit/entity_spec.rb

@@ -0,0 +1,41 @@
+require 'minimapper/entity'
+
+describe Minimapper::Entity do
+  it "handles base attributes" do
+    base = described_class.new
+    base.id = 5
+    base.id.should == 5
+
+    time = Time.now
+    base.created_at = time
+    base.created_at.should == time
+
+    base.updated_at = time
+    base.updated_at.should == time
+  end
+end
+
+describe Minimapper::Entity, "attributes" do
+  it "returns the attributes" do
+    base = described_class.new(:id => 5)
+    time = Time.now
+    base.created_at = time
+    base.attributes.should == { :id => 5, :created_at => time }
+  end
+end
+
+describe Minimapper::Entity, "to_param" do
+  it "responds with the id to be compatible with rails link helpers" do
+    base = described_class.new(:id => 5)
+    base.to_param.should == 5
+  end
+end
+
+describe Minimapper::Entity, "persisted?" do
+  it "responds true when there is an id (to be compatible with rails form helpers)" do
+    base = described_class.new
+    base.should_not be_persisted
+    base.id = 5
+    base.should be_persisted
+  end
+end

data/unit/memory_spec.rb

@@ -0,0 +1,15 @@
+require 'minimapper/memory'
+require 'minimapper/common'
+require 'minimapper/entity'
+
+class TestEntity < Minimapper::Entity
+  attributes :name
+  validates :name, :presence => true
+end
+
+describe Minimapper::Memory do
+  let(:repository) { described_class.new }
+  let(:entity_klass) { TestEntity }
+
+  include_examples :mapper
+end

data/unit/repository_spec.rb

@@ -0,0 +1,40 @@
+require 'minimapper/repository'
+require 'minimapper/memory'
+
+module Test
+  class ProjectMapper < Minimapper::Memory
+  end
+end
+
+describe Minimapper::Repository, "self.build" do
+  it "builds a repository" do
+    repository = described_class.build(:projects => Test::ProjectMapper.new)
+    repository.should be_instance_of(Minimapper::Repository)
+    repository.projects.should be_instance_of(Test::ProjectMapper)
+  end
+
+  it "memoizes the mappers" do
+    repository = described_class.build(:projects => Test::ProjectMapper.new)
+    repository.projects.object_id.should == repository.projects.object_id
+  end
+
+  it "does not leak between instances" do
+    repository1 = described_class.build(:projects => :foo)
+    repository2 = described_class.build(:projects => :bar)
+    repository1.projects.should == :foo
+    repository2.projects.should == :bar
+  end
+end
+
+describe Minimapper::Repository, "#delete_all!" do
+  it "removes all records by calling delete_all on all mappers" do
+    project_mapper = mock
+    user_mapper = mock
+
+    project_mapper.should_receive(:delete_all)
+    user_mapper.should_receive(:delete_all)
+
+    repository2 = described_class.build(:projects => project_mapper, :users => user_mapper)
+    repository2.delete_all!
+  end
+end

data/unit/spec_helper.rb

@@ -0,0 +1,10 @@
+ROOT = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+$: << File.join(ROOT, "lib")
+$: << File.join(ROOT, "unit")
+
+require "minimapper"
+
+Dir[File.join(ROOT, "spec/support/shared_examples/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: minimapper
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- "Joakim Kolsj\xC3\xB6"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-14 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: informal
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A minimalistic way of separating your models from ORMs like ActiveRecord (by implementing the repository pattern)
+email: 
+- joakim.kolsjo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/minimapper.rb
+- lib/minimapper/ar.rb
+- lib/minimapper/common.rb
+- lib/minimapper/entity.rb
+- lib/minimapper/memory.rb
+- lib/minimapper/repository.rb
+- lib/minimapper/version.rb
+- minimapper.gemspec
+- script/ci
+- script/turbux_rspec
+- spec/ar_spec.rb
+- spec/spec_helper.rb
+- spec/support/database_setup.rb
+- spec/support/shared_examples/mapper.rb
+- unit/entity_spec.rb
+- unit/memory_spec.rb
+- unit/repository_spec.rb
+- unit/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: A minimalistic way of separating your models from ORMs like ActiveRecord (by implementing the repository pattern)
+test_files: 
+- spec/ar_spec.rb
+- spec/spec_helper.rb
+- spec/support/database_setup.rb
+- spec/support/shared_examples/mapper.rb