minimapper 0.6.2 → 0.7.0

data/README.md

@@ -7,28 +7,30 @@
 
 ### Introduction
 
-Minimapper is a minimalistic way of separating models from ORMs like ActiveRecord. It enables you to test your models (and code using your models) within a [sub-second unit test suite](https://github.com/joakimk/fast_unit_tests_example) and makes it simpler to have a modular design as described in [Matt Wynne's Hexagonal Rails posts](http://blog.mattwynne.net/2012/04/09/hexagonal-rails-introduction/).
+Minimapper is a minimalistic way of [separating models](http://martinfowler.com/eaaCatalog/dataMapper.html) from ActiveRecord. It enables you to test your models (and code using your models) within a [sub-second unit test suite](https://github.com/joakimk/fast_unit_tests_example) and makes it simpler to have a modular design as described in [Matt Wynne's Hexagonal Rails posts](http://blog.mattwynne.net/2012/04/09/hexagonal-rails-introduction/).
 
-Minimapper comes with an in-memory implementation of common CRUD operations. You can use this in tests to not hit the database where it isn't nessesary to do so. You can also develop new features without having to think about migrations until you need to persist data.
-
-Minimapper is not an ORM, instead it's a tool to make it simpler to handle persistence in existing applications using ORMs like ActiveRecord. It may also be an attractive alternative to using DataMapper 2 (when it's done) for new apps if you already know ActiveRecord well (most of the rails developers I know have many years of experience with ActiveRecord).
+Minimapper follows many Rails conventions but it does not require Rails.
 
 ### Early days
 
 The API may not be entirely stable yet and there are probably edge cases that aren't covered. However... it's most likely better to use this than to roll your own project specific solution. We need good tools for this kind of thing in the rails community, but to make that possible we need to gather around a few of them and make them good.
 
+### Important resources
+
+- [minimapper-extras](https://github.com/barsoom/minimapper-extras) (useful tools for projects using minimapper)
+- [Gist of yet to be extracted mapper code](https://gist.github.com/joakimk/5656945) from a project using minimapper.
+
 ### Compatibility
 
-This gem is tested against all major rubies in 1.8, 1.9 and 2.0, 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.
+This gem is tested against all major rubies in 1.8, 1.9 and 2.0, see [.travis.yml](https://github.com/joakimk/minimapper/blob/master/.travis.yml). For each ruby version, the mapper is tested against SQLite3, PostgreSQL and MySQL.
 
 ### Only the most basic API
 
 This library only implements the most basic persistence API (mostly just CRUD). Any significant additions will be made into separate gems (like [minimapper-extras](https://github.com/barsoom/minimapper-extras)). The reasons for this are:
 
-* It should have a stable 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
+* It should be possible to learn all it does in a short time
+* It should have a stable API
 
 ## Installation
 
@@ -52,15 +54,15 @@ Please avoid installing directly from the github repository. Code will be pushed
 
 ### Basics
 
-You can use the mappers like this (<strong>it's runnable, try copy and pasting it into a ruby file</strong> or [use this gist](https://gist.github.com/3904952)):
+Basics and how we use minimapper in practice.
 
 ``` ruby
-# minimapper_example.rb
 require "rubygems"
 require "minimapper"
 require "minimapper/entity"
-require "minimapper/mapper/memory"
+require "minimapper/mapper"
 
+# app/models/user.rb
 class User
   include Minimapper::Entity
 
@@ -68,7 +70,11 @@ class User
   validates :name, :presence => true
 end
 
-class UserMapper < Minimapper::Mapper::Memory
+# app/mappers/user_mapper.rb
+class UserMapper < Minimapper::Mapper
+  class Record < ActiveRecord::Base
+    self.table_name = "users"
+  end
 end
 
 ## Creating
@@ -83,6 +89,7 @@ p user_mapper.first.name # => Joe
 
 ## Updating
 user.name = "Joey"
+# user.attributes = params[:user]
 user_mapper.update(user)
 p user_mapper.first.name # => Joey
 
@@ -98,51 +105,33 @@ p user_mapper.find_by_id(old_id) # => nil
 ## Using a repository
 require "minimapper/repository"
 
-repository = Minimapper::Repository.build({
+# config/initializers/repository.rb
+Repository = Minimapper::Repository.build({
   :users    => UserMapper.new
   # :projects => ProjectMapper.new
 })
 
 user = User.new(:name => "Joe")
-repository.users.create(user)
+Repository.users.create(user)
 p repository.users.find(user.id).name # => Joe
-repository.users.delete_all
+Repository.users.delete_all
 
 ## Using ActiveModel validations
 user = User.new
-repository.users.create(user)
-p repository.users.count    # => 0
+Repository.users.create(user)
+p Repository.users.count    # => 0
 p user.errors.full_messages # Name can't be blank
 ```
 
-### ActiveRecord
+### Loading all the data you need before acting on it
 
-This is not directly runnable like the previous example, it requires ActiveRecord, a database and a users table. Isn't it interesting how much you could do without those things in the previous example? :)
-
-When you do need to use an ORM like ActiveRecord however, it now has the same API as your in-memory persistence (thanks to the [shared tests](https://github.com/joakimk/minimapper/blob/master/spec/support/shared_examples/mapper.rb) which define how a mapper is supposed to behave).
-
-``` ruby
-require "minimapper/mapper/ar"
-
-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)
-```
+When using minimapper you generally want to load all data you need upfront whenever possible as you don't have lazy loading. We haven't gotten around to adding the inclusion syntax yet, but [it's quite simple to implement](https://gist.github.com/joakimk/5656945).
 
 ### Uniqueness validations and other DB validations
 
 Validations on uniqueness can't be implemented on the entity, because they need to access the database.
 
-Therefore, the ActiveRecord mapper will copy over any record errors to the entity when attempting to create or update.
+Therefore, the mapper will copy over any record errors to the entity when attempting to create or update.
 
 Add these validations to the record itself, like:
 
@@ -161,21 +150,9 @@ So an entity that wouldn't be unique in the database will be `valid?` before you
 You can write custom queries like this:
 
 ``` ruby
-# Memory implementation
-module Memory
-  class ProjectMapper < Minimapper::Mapper::Memory
-    def waiting_for_review
-      all.find_all { |p| p.waiting_for_review }.sort_by(&:id).reverse
-    end
-  end
-end
-
-# ActiveRecord implementation
-module AR
-  class ProjectMapper < Minimapper::AR
-    def waiting_for_review
-      entities_for record_class.where(waiting_for_review: true).order("id DESC")
-    end
+class ProjectMapper < Minimapper::AR
+  def waiting_for_review
+    entities_for record_class.where(waiting_for_review: true).order("id DESC")
   end
 end
 ```
@@ -183,14 +160,12 @@ end
 And then use it like this:
 
 ``` ruby
-# repository = Minimapper::Repository.build(...)
-repository.projects.waiting_for_review.each do |project|
+# Repository = Minimapper::Repository.build(...)
+Repository.projects.waiting_for_review.each do |project|
   p project.name
 end
 ```
 
-It gets simpler to maintain if you use shared tests to test both implementations. For inspiration, see the [shared tests](https://github.com/joakimk/minimapper/blob/master/spec/support/shared_examples/mapper.rb) used to test minimapper.
-
 `entity_for` returns nil for nil.
 
 It takes an optional second argument if you want a different entity class than the mapper's:
@@ -204,9 +179,14 @@ class ProjectMapper < Minimapper::AR
 end
 ```
 
-### Typed attributes
+### Typed attributes and type coercion
+
+If you specify type, Minimapper will only allow values of that type, or strings that can be coerced into that type.
 
-If you specify type, minimapper will attempt to convert into that type. Supported types: Integer and DateTime (:integer and :date_time).
+The latter means that it can accept e.g. string integers directly from a form.
+Minimapper aims to be much less of a form value parser than ActiveRecord, but we'll allow ourselves conveniences like this.
+
+Supported types: Integer and DateTime (`:integer` and `:date_time`).
 
 ``` ruby
 class User
@@ -303,17 +283,6 @@ end
 
 [Minimapper::Entity](https://github.com/joakimk/minimapper/blob/master/lib/minimapper/entity.rb) adds some convenience methods for when a model is used within a Rails application. If you don't need that you can just include the core API from the [Minimapper::Entity::Core](https://github.com/joakimk/minimapper/blob/master/lib/minimapper/entity/core.rb) module (or implement your own version that behaves like [Minimapper::Entity::Core](https://github.com/joakimk/minimapper/blob/master/lib/minimapper/entity/core.rb)).
 
-### Adding a new mapper
-
-If you were to add a [Mongoid](http://mongoid.org/en/mongoid/index.html) mapper:
-
-1. Start by copying *spec/ar_spec.rb* to *spec/mongoid_spec.rb* and adapt it for Mongoid.
-2. Add any setup code needed in *spec/support/database_setup.rb*.
-3. Get the [shared tests](https://github.com/joakimk/minimapper/blob/master/spec/support/shared_examples/mapper.rb) to pass for *spec/mongoid_spec.rb*.
-4. Ensure all other tests pass.
-5. Send a pull request.
-6. As soon as it can be made to work in travis in all ruby versions that apply (in Mongoid's case that is only the 1.9 rubies), I'll merge it in.
-
 ## Inspiration
 
 ### People
@@ -336,7 +305,7 @@ Robert "Uncle Bob" Martin:
 
 ### 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.
+You need mysql and postgres installed (but they do not have to be running) to be able to run bundle. The mapper tests use sqlite3 by default.
 
     bundle
     rake
@@ -355,19 +324,7 @@ You need mysql and postgres installed (but they do not have to be running) to be
 
 ### Next
 
-* Make it possible to override minimapper attributes with super (like it's done in https://github.com/barsoom/traco)
 * Support default values for attributes (probably only using lambdas to avoid bugs).
-* Built in way to set induvidual attributes in a way that bypasses protected attributes like you can do with an AR model.
-  - user.is_admin = true; user_mapper.update(user) should probably set is_admin to true, mass-assignment should not.
-* Extract entity and model class lookup code from the ar-mapper and reuse it in the memory mapper.
-* Change the memory mapper to store entity attributes, not entity instances.
-  - Unless this makes it difficult to handle associated data.
-
-### Ideas
-
-I won't implement anything that isn't actually used. But here are some ideas for things that might make it into minimapper someday if there is a need for it.
-
-* Provide a hook to convert attributes between entities and the backing models (when your entity attributes and db-schema isn't a one-to-one match).
 
 ## Credits and license
 

data/lib/minimapper/mapper.rb

@@ -0,0 +1,150 @@
+module Minimapper
+  EntityNotFound = Class.new(StandardError)
+
+  class Mapper
+    attr_accessor :repository
+
+    # Create
+
+    def create(entity)
+      record = record_class.new
+
+      copy_attributes_to_record(record, entity)
+      validate_record_and_copy_errors_to_entity(record, entity)
+
+      if entity.valid?
+        record.save!
+        entity.id = record.id
+        entity.id
+      else
+        false
+      end
+    end
+
+    # Read
+
+    def find(id)
+      entity_for(find_record_safely(id))
+    end
+
+    def find_by_id(id)
+      entity_for(find_record(id))
+    end
+
+    def all
+      entities_for record_class.all
+    end
+
+    def first
+      entity_for(record_class.order("id ASC").first)
+    end
+
+    def last
+      entity_for(record_class.order("id ASC").last)
+    end
+
+    def count
+      record_class.count
+    end
+
+    # Update
+
+    def update(entity)
+      record = record_for(entity)
+
+      copy_attributes_to_record(record, entity)
+      validate_record_and_copy_errors_to_entity(record, entity)
+
+      if entity.valid?
+        record.save!
+        true
+      else
+        false
+      end
+    end
+
+    # Delete
+
+    def delete(entity)
+      delete_by_id(entity.id)
+      entity.id = nil
+    end
+
+    def delete_by_id(id)
+      find_record_safely(id).delete
+    end
+
+    def delete_all
+      record_class.delete_all
+    end
+
+    private
+
+    # NOTE: Don't memoize the record_class or code reloading will break in rails apps.
+    def record_class
+      "#{self.class.name}::Record".constantize
+    end
+
+    # Will attempt to use Project as the entity class when
+    # the mapper class name is ProjectMapper.
+    def entity_class
+      self.class.name.sub(/Mapper$/, '').constantize
+    end
+
+    def accessible_attributes(entity)
+      entity.attributes.reject { |k, v| protected_attributes.include?(k.to_s) }
+    end
+
+    def protected_attributes
+      record_class.protected_attributes
+    end
+
+    def copy_attributes_to_record(record, entity)
+      record.attributes = accessible_attributes(entity)
+    end
+
+    def validate_record_and_copy_errors_to_entity(record, entity)
+      record.valid?
+      entity.mapper_errors = record.errors.map { |k, v| [k, v] }
+    end
+
+    def find_record_safely(id)
+      find_record(id) ||
+        raise(EntityNotFound, :id => id)
+    end
+
+    def find_record(id)
+      id && record_class.find_by_id(id)
+    end
+
+    def record_for(entity)
+      (entity.id && record_class.find_by_id(entity.id)) ||
+        raise(EntityNotFound, entity.inspect)
+    end
+
+    def entities_for(records)
+      records.map { |record| entity_for(record) }
+    end
+
+    def entity_for(record, klass = entity_class)
+      if record
+        entity = klass.new
+        entity.id = record.id
+        entity.attributes = record.attributes.symbolize_keys
+
+        if klass == entity_class
+          after_find(entity, record)
+        end
+
+        entity
+      else
+        nil
+      end
+    end
+
+    # Hooks
+
+    def after_find(entity, record)
+    end
+  end
+end

data/lib/minimapper/version.rb

@@ -1,3 +1,3 @@
 module Minimapper
-  VERSION = "0.6.2"
+  VERSION = "0.7.0"
 end

data/minimapper.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version       = Minimapper::VERSION
   gem.authors       = ["Joakim Kolsjo"]
   gem.email         = ["joakim.kolsjo@gmail.com"]
-  gem.description   = %q{A minimalistic way of separating your models from ORMs like ActiveRecord.}
-  gem.summary       = %q{A minimalistic way of separating your models from ORMs like ActiveRecord.}
+  gem.description   = %q{A minimalistic way of separating your models from ActiveRecord.}
+  gem.summary       = %q{A minimalistic way of separating your models from ActiveRecord.}
   gem.homepage      = ""
 
   gem.files         = `git ls-files`.split($/)

data/spec/{mapper/ar_spec.rb → mapper_spec.rb}

@@ -1,22 +1,14 @@
 require "spec_helper"
 require "minimapper/entity/core"
-require "minimapper/mapper/ar"
+require "minimapper/mapper"
 
-class TestEntity
+class Project
   include Minimapper::Entity::Core
 end
 
-class TestMapper < Minimapper::Mapper::AR
+class ProjectMapper < Minimapper::Mapper
   private
 
-  def entity_class
-    TestEntity
-  end
-
-  def record_class
-    Record
-  end
-
   class Record < ActiveRecord::Base
     attr_protected :visible
 
@@ -29,9 +21,9 @@ class TestMapper < Minimapper::Mapper::AR
   end
 end
 
-describe Minimapper::Mapper::AR do
-  let(:mapper) { TestMapper.new }
-  let(:entity_class) { TestEntity }
+describe Minimapper::Mapper do
+  let(:mapper) { ProjectMapper.new }
+  let(:entity_class) { Project }
 
   include_examples :mapper
 
@@ -45,9 +37,9 @@ describe Minimapper::Mapper::AR do
       stored_entity.attributes[:visible].should be_nil
       stored_entity.attributes[:name].should == "Joe"
 
-      entity = TestEntity.new
+      entity = Project.new
       entity.attributes = { :visible => true, :name => "Joe" }
-      TestMapper::Record.stub(:protected_attributes => [])
+      ProjectMapper::Record.stub(:protected_attributes => [])
       lambda { mapper.create(entity) }.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
     end
 
@@ -75,7 +67,7 @@ describe Minimapper::Mapper::AR do
     end
 
     def build_entity(attributes)
-      entity = TestEntity.new
+      entity = Project.new
       entity.attributes = attributes
       entity
     end
@@ -83,7 +75,7 @@ describe Minimapper::Mapper::AR do
 
   describe "#update" do
     it "does not include protected attributes" do
-      entity = TestEntity.new
+      entity = Project.new
       mapper.create(entity)
 
       entity.attributes = { :visible => true, :name => "Joe" }
@@ -92,7 +84,7 @@ describe Minimapper::Mapper::AR do
       stored_entity.attributes[:visible].should be_nil
       stored_entity.attributes[:name].should == "Joe"
 
-      TestMapper::Record.stub(:protected_attributes => [])
+      ProjectMapper::Record.stub(:protected_attributes => [])
       lambda { mapper.update(entity) }.should raise_error(ActiveModel::MassAssignmentSecurity::Error)
     end
 
@@ -100,7 +92,7 @@ describe Minimapper::Mapper::AR do
       old_entity = build_entity(:email => "joe@example.com")
       mapper.create(old_entity)
 
-      new_entity = TestEntity.new
+      new_entity = Project.new
       mapper.create(new_entity)
       new_entity.mapper_errors.should == []
 
@@ -113,7 +105,7 @@ describe Minimapper::Mapper::AR do
       old_entity = build_entity(:email => "joe@example.com")
       mapper.create(old_entity)
 
-      new_entity = TestEntity.new
+      new_entity = Project.new
       mapper.create(new_entity)
       new_entity.mapper_errors.should == []
 
@@ -127,7 +119,7 @@ describe Minimapper::Mapper::AR do
     end
 
     def build_entity(attributes)
-      entity = TestEntity.new
+      entity = Project.new
       entity.attributes = attributes
       entity
     end

data/unit/entity/convert_spec.rb

@@ -2,39 +2,46 @@ require 'minimapper/entity/convert'
 require 'active_support/core_ext'
 
 describe Minimapper::Entity::Convert do
-  it "converts strings into integers" do
-    described_class.new('10').to(:integer).should == 10
-    described_class.new(' 10 ').to(:integer).should == 10
-  end
+  describe ":integer" do
+    it "allows integers" do
+      described_class.new(10).to(:integer).should == 10
+    end
+
+    it "converts strings into integers" do
+      described_class.new('10').to(:integer).should == 10
+      described_class.new(' 10 ').to(:integer).should == 10
+    end
 
-  it "converts datetime strings into datetimes" do
-    described_class.new('2012-01-01 20:57').to(:date_time).should == DateTime.new(2012, 01, 01, 20, 57)
+    it "makes it nil when it can't convert" do
+      described_class.new(' ').to(:integer).should be_nil
+      described_class.new('garbage').to(:integer).should be_nil
+    end
   end
 
-  it "makes it nil when it can't convert" do
-    described_class.new(' ').to(:integer).should be_nil
-    described_class.new(' ').to(:date_time).should be_nil
-    described_class.new('garbage').to(:integer).should be_nil
-    described_class.new('garbage').to(:date_time).should be_nil
+  describe ":date_time" do
+    it "allows DateTimes" do
+      described_class.new(DateTime.new(2013, 6, 1)).to(:date_time).should == DateTime.new(2013, 6, 1)
+    end
+
+    it "converts datetime strings into datetimes" do
+      described_class.new('2012-01-01 20:57').to(:date_time).should == DateTime.new(2012, 01, 01, 20, 57)
+    end
+
+    it "makes it nil when it can't convert" do
+      described_class.new(' ').to(:date_time).should be_nil
+      described_class.new('garbage').to(:date_time).should be_nil
+    end
   end
 
   it "returns the value as-is when the type isn't specified" do
     described_class.new('foobar').to(nil).should == 'foobar'
   end
 
-  it "does not make false nil" do
-    described_class.new(false).to(nil).should eq(false)
-  end
-
   it "raises when the type isn't known" do
     lambda { described_class.new('foobar').to(:unknown) }.should raise_error(/Unknown attribute type/)
   end
 
   it "does not make false nil" do
-    described_class.new(false).to(:unknown).should eq(false)
-  end
-
-  it "does not make false nil" do
-    described_class.new(false).to(:unknown).should eq(false)
+    described_class.new(false).to(:whatever).should eq(false)
   end
 end

data/unit/repository_spec.rb

@@ -1,8 +1,8 @@
 require 'minimapper/repository'
-require 'minimapper/mapper/memory'
 
 module Test
-  class ProjectMapper < Minimapper::Mapper::Memory
+  class ProjectMapper
+    attr_accessor :repository
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minimapper
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-23 00:00:00.000000000 Z
+date: 2013-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70133111671800 !ruby/object:Gem::Requirement
+  requirement: &70148053526900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,8 +21,8 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70133111671800
-description: A minimalistic way of separating your models from ORMs like ActiveRecord.
+  version_requirements: *70148053526900
+description: A minimalistic way of separating your models from ActiveRecord.
 email:
 - joakim.kolsjo@gmail.com
 executables: []
@@ -44,15 +44,13 @@ files:
 - lib/minimapper/entity/convert/to_integer.rb
 - lib/minimapper/entity/core.rb
 - lib/minimapper/entity/rails.rb
-- lib/minimapper/mapper/ar.rb
-- lib/minimapper/mapper/common.rb
-- lib/minimapper/mapper/memory.rb
+- lib/minimapper/mapper.rb
 - lib/minimapper/repository.rb
 - lib/minimapper/version.rb
 - minimapper.gemspec
 - script/ci
 - script/turbux_rspec
-- spec/mapper/ar_spec.rb
+- spec/mapper_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_setup.rb
 - spec/support/shared_examples/mapper.rb
@@ -60,7 +58,6 @@ files:
 - unit/entity/core_spec.rb
 - unit/entity/rails_spec.rb
 - unit/entity_spec.rb
-- unit/mapper/memory_spec.rb
 - unit/repository_spec.rb
 - unit/spec_helper.rb
 homepage: ''
@@ -77,7 +74,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2264146464665909809
+      hash: -4244542897336928819
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -86,15 +83,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2264146464665909809
+      hash: -4244542897336928819
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: A minimalistic way of separating your models from ORMs like ActiveRecord.
+summary: A minimalistic way of separating your models from ActiveRecord.
 test_files:
-- spec/mapper/ar_spec.rb
+- spec/mapper_spec.rb
 - spec/spec_helper.rb
 - spec/support/database_setup.rb
 - spec/support/shared_examples/mapper.rb

data/lib/minimapper/mapper/ar.rb

@@ -1,155 +0,0 @@
-require "minimapper/mapper/common"
-
-module Minimapper
-  module Mapper
-    class AR
-      include Common
-
-      # Create
-
-      def create(entity)
-        record = record_class.new
-
-        copy_attributes_to_record(record, entity)
-        validate_record_and_copy_errors_to_entity(record, entity)
-
-        if entity.valid?
-          record.save!
-          entity.id = record.id
-          entity.id
-        else
-          false
-        end
-      end
-
-      # Read
-
-      def find(id)
-        entity_for(find_record_safely(id))
-      end
-
-      def find_by_id(id)
-        entity_for(find_record(id))
-      end
-
-      def all
-        entities_for record_class.all
-      end
-
-      def first
-        entity_for(record_class.order("id ASC").first)
-      end
-
-      def last
-        entity_for(record_class.order("id ASC").last)
-      end
-
-      def count
-        record_class.count
-      end
-
-      # Update
-
-      def update(entity)
-        record = record_for(entity)
-
-        copy_attributes_to_record(record, entity)
-        validate_record_and_copy_errors_to_entity(record, entity)
-
-        if entity.valid?
-          record.save!
-          true
-        else
-          false
-        end
-      end
-
-      # Delete
-
-      def delete(entity)
-        delete_by_id(entity.id)
-        entity.id = nil
-      end
-
-      def delete_by_id(id)
-        find_record_safely(id).delete
-      end
-
-      def delete_all
-        record_class.delete_all
-      end
-
-      private
-
-      # NOTE: Don't memoize the classes or code reloading will break in rails apps.
-
-      # Will attempt to use AR:Project as the record class
-      # when the mapper class name is AR::ProjectMapper.
-      def record_class
-        self.class.name.sub(/Mapper$/, '').constantize
-      end
-
-      # Will attempt to use Project as the entity class when
-      # the mapper class name is AR::ProjectMapper.
-      def entity_class
-        ("::" + self.class.name.split('::').last.sub(/Mapper$/, '')).constantize
-      end
-
-      def accessible_attributes(entity)
-        entity.attributes.reject { |k, v| protected_attributes.include?(k.to_s) }
-      end
-
-      def protected_attributes
-        record_class.protected_attributes
-      end
-
-      def copy_attributes_to_record(record, entity)
-        record.attributes = accessible_attributes(entity)
-      end
-
-      def validate_record_and_copy_errors_to_entity(record, entity)
-        record.valid?
-        entity.mapper_errors = record.errors.map { |k, v| [k, v] }
-      end
-
-      def find_record_safely(id)
-        find_record(id) ||
-          raise(EntityNotFound, :id => id)
-      end
-
-      def find_record(id)
-        id && record_class.find_by_id(id)
-      end
-
-      def record_for(entity)
-        (entity.id && record_class.find_by_id(entity.id)) ||
-          raise(EntityNotFound, entity.inspect)
-      end
-
-      def entities_for(records)
-        records.map { |record| entity_for(record) }
-      end
-
-      def entity_for(record, klass = entity_class)
-        if record
-          entity = klass.new
-          entity.id = record.id
-          entity.attributes = record.attributes.symbolize_keys
-
-          if klass == entity_class
-            after_find(entity, record)
-          end
-
-          entity
-        else
-          nil
-        end
-      end
-
-      # Hooks
-
-      def after_find(entity, record)
-      end
-    end
-  end
-end

data/lib/minimapper/mapper/common.rb

@@ -1,9 +0,0 @@
-module Minimapper
-  EntityNotFound = Class.new(StandardError)
-
-  module Mapper
-    module Common
-      attr_accessor :repository
-    end
-  end
-end

data/lib/minimapper/mapper/memory.rb

@@ -1,101 +0,0 @@
-require 'minimapper/mapper/common'
-
-module Minimapper
-  module Mapper
-    class Memory
-      include Common
-
-      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_safely(id).dup
-      end
-
-      def find_by_id(id)
-        entity = find_internal(id)
-        entity && entity.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_safely(entity.id)
-          known_entity.attributes = entity.attributes
-          true
-        else
-          false
-        end
-      end
-
-      # Delete
-      def delete(entity)
-        delete_by_id(entity.id)
-        entity.id = nil
-      end
-
-      def delete_by_id(id)
-        entity = find_internal_safely(id)
-        store.delete(entity)
-      end
-
-      def delete_all
-        store.clear
-      end
-
-      private
-
-      def find_internal_safely(id)
-        find_internal(id) ||
-          raise(EntityNotFound, :id => id)
-      end
-
-      def find_internal(id)
-        entity = id && store.find { |e| e.id == id.to_i }
-        after_find(entity)
-        entity
-      end
-
-      def next_id
-        @last_id += 1
-      end
-
-      attr_reader :store, :last_id
-
-      # Hooks
-
-      def after_find(entity)
-      end
-    end
-  end
-end

data/unit/mapper/memory_spec.rb

@@ -1,13 +0,0 @@
-require 'minimapper/mapper/memory'
-require 'minimapper/entity/core'
-
-class BasicEntity
-  include Minimapper::Entity::Core
-end
-
-describe Minimapper::Mapper::Memory do
-  let(:mapper) { described_class.new }
-  let(:entity_class) { BasicEntity }
-
-  include_examples :mapper
-end