little_mapper 0.0.3

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
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in little_mapper.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Simon Robson
+
+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,88 @@
+# LittleMapper
+
+Early stage simple datamapper/repository backed by ActiveRecord (only, for the moment). Still working out the best DSL. Currently in use on an internal project.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'little_mapper', :github => 'simonrobson/little-mapper'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install little_mapper
+
+## Usage
+
+Define one or more plain ruby classes:
+
+	class Person < OpenStruct
+	  attr_accessor :phone_numbers
+	  def initialize(*args)
+        super
+		@phone_numbers = []
+	  end
+	end
+
+	class PhoneNumber
+	  attr_accessor :id, :code, :number
+	  def initialize(opts = {})
+	    opts.each_pair {|k, v| self.send("#{k}=", v)}
+	  end
+	end
+
+
+Define the mappers:
+
+	class PersonMapper
+	  include LittleMapper
+	  entity Person
+	  persistent_entity Persistent::Person
+	  maps :name, :age
+	  map :phone_numbers, :as => [PhoneNumber]
+	  # see integration test for more complex example
+	  # map :all_cats, :as => [Cat], :entity_collection_adder => :receive_cat,
+	  #    :to => :cats
+	  map :spouse, :as => Person
+	end
+
+	class PhoneNumberMapper
+	  include LittleMapper
+	  entity PhoneNumber
+	  persistent_entity Persistent::PhoneNumber
+	  maps :code, :number
+	end
+
+Define the ActiveRecord classes (and their migrations, not shown):
+
+	module Persistent
+	  class Person < ActiveRecord::Base
+	    has_many :phone_numbers
+	    belongs_to :spouse, :class_name => 'Person'
+	  end
+
+	  class PhoneNumber < ActiveRecord::Base
+	    belongs_to :person
+	  end
+	end
+
+Exercise the code:
+
+	jane = Person.new(:name => 'Jane', :age => 28)
+    LittleMapper[Person] << jane # stores jane
+    john = Person.new(:name => 'John', :age => 27, :spouse => o)
+    LittleMapper[Person] << john
+    found = LittleMapper[Person].find_by_id(john.id)
+    puts found.spouse.name # Jane - found and spouse are plain Ruby objects
+
+## 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,12 @@
+require "bundler/gem_tasks"
+require "minitest/unit"
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << 'lib/little_helper'
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb', 'test/integration/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/little_mapper.rb

@@ -0,0 +1,46 @@
+require "little_mapper/version"
+require "little_mapper/dsl_class_methods"
+require "little_mapper/mapper_instance_methods"
+require "little_mapper/mapping_factory"
+require "little_mapper/mappers/mappers"
+require "little_mapper/mappers/active_record"
+require "little_mapper/result/repo_response"
+require "little_mapper/result/repo_success"
+require "little_mapper/result/repo_failure"
+
+module LittleMapper
+
+  # Registers a mapper under a key.
+  #
+  # Will generally be called by Little Mapper itself during inclusion of the
+  # LittleMapper module in your class.
+  #
+  # entity - The key under which the mapper will be held. Generally the
+  #          the non-persistent entity class name.
+  # mapper - The class of the mapper.
+  #
+  # Returns the mapper
+  def self.register(entity, mapper)
+    @mappers ||= {}
+    @mappers[entity] = mapper
+  end
+
+  # Returns an instantiated mapper for the given key.
+  #
+  # The primary way of interacting with LittleMapper having set up one or more
+  # mappers.
+  #
+  # key - The key under which the mapper was stored. Generally the non-
+  #       persistent entity class name.
+  #
+  # Returns a mapper instance for the key
+  def self.[](key)
+    @mappers[key].new
+  end
+
+  # Private: kicks off the action when this module is included
+  def self.included(klass)
+    klass.extend DslClassMethods
+    klass.module_eval { include MapperInstanceMethods}
+  end
+end

data/lib/little_mapper/dsl_class_methods.rb

@@ -0,0 +1,72 @@
+module LittleMapper
+  module DslClassMethods
+
+    # Getter/Setter for the Domain Entity to persist.
+    def entity(klass = nil)
+      if klass.nil?
+        @_entity
+      else
+        @_entity = klass
+        LittleMapper.register(klass, self)
+      end
+    end
+
+    # Getter/Setter for the (Currently ActiveRecord only) class to use for
+    # persistence.
+    def persistent_entity(klass = nil)
+      klass.nil? ? @_persistent_entity :  @_persistent_entity = klass
+    end
+
+    def mappings
+      @_mappings ||= []
+    end
+
+    def add_mapping(m)
+      mappings << m
+    end
+
+    def mapping_factory=(mf)
+      @_mapping_factory = mf
+    end
+
+    def mapping_factory
+      @_mapping_factory ||= LittleMapper::MappingFactory.new
+    end
+
+    # Add one or more simple one-to-one mappings.
+    #
+    # args - one or more Symbols. The names of the fields to map.
+    #
+    # Examples
+    #
+    #   maps :first_name, :last_name
+    def maps(*args)
+       args.each {|f| map(f)}
+    end
+
+
+    # Add a single mapping.
+    #
+    # field - A Symbol, the name of the field to map.
+    # opts  - A Hash of options to configure the mapper (default: {}):
+    #         :as            - The Class of Mapper to use to map an entity
+    #                          value. Can be enclosed in Array notation to
+    #                          signify a one to many relationship
+    #         :to            - Name of the field on the persistent entity
+    #                          to which we will map (default: field)
+    #         :entity_setter - a Symbol representing the name of a function
+    #                          to use when setting the value on the entity
+    #                          (default: field=)
+    #         :entity_collection_adder - in a one-to-many relationship, the name of
+    #                          of a method to use when adding associated objetcs
+    #                          (default: to#<<)
+    # Examples
+    #
+    #   map :metrics, :as => [Metric]
+    #   map :owner, :entity_setter => :assign_owner
+    def map(field, opts = {})
+      add_mapping(mapping_factory.map(self, field, opts))
+    end
+
+  end
+end

data/lib/little_mapper/mapper_instance_methods.rb

@@ -0,0 +1,52 @@
+module LittleMapper
+  module MapperInstanceMethods
+    def to_persistent(entity)
+      pe = persisted?(entity) ? find_persistent_by_id(entity.id) : self.class.persistent_entity.new
+      self.class.mappings.each do |m|
+        m.from(entity).to_persistent(pe)
+      end
+      pe
+    end
+
+    def to_entity(persistent)
+      e = self.class.entity.new
+      e.id = persistent.id # probably set this only if configured & see duplication below
+      self.class.mappings.each do |m|
+        m.from(persistent).to_entity(e)
+      end
+      e
+    end
+
+    def persisted?(entity)
+      !entity.id.nil? # should maybe check for empty strings too?
+    end
+
+    def <<(entity)
+      pe = to_persistent(entity)
+      if pe.save
+        entity.id = pe.id unless entity.id # set this only if configured
+        LittleMapper::Result::RepoSuccess.new(pe)
+      else
+        LittleMapper::Result::RepoFailure.new(pe)
+      end
+    end
+
+    def find_persistent_by_id(id)
+      self.class.persistent_entity.find_by_id(id)
+    end
+
+    def find_by_id(id)
+      pe = find_persistent_by_id(id)
+      return nil unless pe
+      to_entity(pe)
+    end
+
+    def find_all
+      self.class.persistent_entity.all.collect { |e| to_entity(e) }
+    end
+
+    def last
+      to_entity(self.class.persistent_entity.last)
+    end
+  end
+end

data/lib/little_mapper/mappers/AR/one_to_many.rb

@@ -0,0 +1,34 @@
+module LittleMapper
+  module Mappers
+    module AR
+      class OneToMany < Base
+        attr_accessor :mapper, :entity_field, :persistent_field, :persistent_klass
+        attr_accessor :entity_collection_adder, :reflexive, :reflexive_setter
+        def initialize(mapper, entity_field, persistent_klass, opts = {})
+          @mapper = mapper
+          @entity_field = entity_field
+          @persistent_klass = persistent_klass
+          @persistent_field = opts[:to] || entity_field
+          @entity_collection_adder = opts[:entity_collection_adder]
+          @reflexive = opts.fetch(:reflexive, true)
+          @reflexive_setter = opts[:reflexive_setter] || "#{camel_to_snake(mapper.entity.to_s)}="
+        end
+
+        def to_persistent(target)
+          source.__send__(entity_field).each do |associated|
+            target.__send__(persistent_field).__send__(:<<, LittleMapper[persistent_klass].to_persistent(associated))
+          end
+        end
+        def to_entity(target)
+          source.__send__(persistent_field).each do |associated|
+            assoc_entity = LittleMapper[persistent_klass].to_entity(associated)
+            if reflexive
+              assoc_entity.__send__(reflexive_setter, target)
+            end
+            target.__send__(entity_field).__send__(:<<, assoc_entity)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/little_mapper/mappers/AR/one_to_one.rb

@@ -0,0 +1,39 @@
+module LittleMapper
+  module Mappers
+    module AR
+      class OneToOne < Mappers::Base
+        attr_accessor :mapper, :field, :persistent_klass, :persistent_field, :entity_setter, :persistent_entity_setter
+        def initialize(mapper, field, opts = {})
+          @mapper = mapper
+          @field = field
+          @persistent_klass = opts[:as]
+          @persistent_field = opts[:to] || field
+          @entity_setter = opts[:entity_setter] || "#{field}=".to_sym
+          @persistent_entity_setter = opts[:persistent_entity_setter] || "#{persistent_field}=".to_sym
+        end
+
+        def to_persistent(target)
+          if persistent_klass
+            val = source.__send__(field)
+            if val
+              target.__send__(persistent_entity_setter, LittleMapper[persistent_klass].to_persistent(val))
+            end
+          else
+            target.__send__(persistent_entity_setter, source.__send__(field))
+          end
+        end
+
+        def to_entity(target)
+          if persistent_klass
+            val = source.__send__(persistent_field)
+            if val
+              target.__send__(entity_setter, LittleMapper[persistent_klass].to_entity(val))
+            end
+          else
+            target.__send__(entity_setter, source.__send__(persistent_field))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/little_mapper/mappers/active_record.rb

@@ -0,0 +1,2 @@
+require 'little_mapper/mappers/AR/one_to_one'
+require 'little_mapper/mappers/AR/one_to_many'

data/lib/little_mapper/mappers/mappers.rb

@@ -0,0 +1,15 @@
+module LittleMapper
+  module Mappers
+    class Base
+      attr_accessor :source
+      def from(source)
+        @source = source
+        self
+      end
+
+      def camel_to_snake(cc)
+        cc.gsub(/(.)([A-Z])/,'\1_\2').downcase
+      end
+    end
+  end
+end

data/lib/little_mapper/mapping_factory.rb

@@ -0,0 +1,36 @@
+module LittleMapper
+  class MappingFactory
+
+    def initialize(strategy = :activerecord)
+      @_strategy = strategy
+    end
+
+    def strategy
+      @_strategy
+    end
+
+    def map(mapper, field, opts = {})
+      if opts[:as] && opts[:as].is_a?(Array)
+        as = opts.delete(:as)
+        one_to_many.new(mapper, field, as[0], opts)
+      else
+        one_to_one.new(mapper, field, opts)
+      end
+    end
+
+    def strategy_module
+      case strategy
+      when :activerecord
+        ::LittleMapper::Mappers::AR
+      end
+    end
+
+    def one_to_one
+      strategy_module.const_get('OneToOne')
+    end
+
+    def one_to_many
+      strategy_module.const_get('OneToMany')
+    end
+  end
+end

data/lib/little_mapper/result/repo_failure.rb

@@ -0,0 +1,11 @@
+module LittleMapper
+  module Result
+    class RepoFailure < RepoResult
+      def after_initialize
+        if object && object.respond_to?(:errors)
+          @messages = object.errors.full_messages
+        end
+      end
+    end
+  end
+end

data/lib/little_mapper/result/repo_response.rb

@@ -0,0 +1,14 @@
+module LittleMapper
+  module Result
+  	class RepoResult
+      attr_reader :messages, :object
+      def initialize(object = nil)
+        @messages = []
+        @object = object
+        after_initialize
+      end
+      def success?; false; end
+      def after_initialize; end
+    end
+  end
+end

data/lib/little_mapper/result/repo_success.rb

@@ -0,0 +1,7 @@
+module LittleMapper
+  module Result
+    class RepoSuccess < RepoResult
+      def success?; true; end
+    end
+  end
+end

data/lib/little_mapper/version.rb

@@ -0,0 +1,3 @@
+module LittleMapper
+  VERSION = "0.0.3"
+end

data/little_mapper.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'little_mapper/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "little_mapper"
+  gem.version       = LittleMapper::VERSION
+  gem.authors       = ["Simon Robson"]
+  gem.email         = ["shrobson@gmail.com"]
+  gem.description   = %q{Simple, ActiveRecord-backed data mapper / repository}
+  gem.summary       = %q{Simple, ActiveRecord-backed data mapper / repository}
+  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_development_dependency('sqlite3')
+  gem.add_development_dependency('activerecord')
+end

data/test/dsl_class_methods_test.rb

@@ -0,0 +1,62 @@
+require 'helper'
+
+module LittleMapper
+  class DslClassMethodsTest < MiniTest::Unit::TestCase
+
+    class TestClass
+      extend DslClassMethods
+    end
+
+    class TheEntity; end
+
+    def test_enables_setting_and_getting_entity
+      TestClass.entity TheEntity
+      assert_equal TheEntity, TestClass.entity
+    end
+
+    def test_setting_the_entity_registers_the_mapper
+      TestClass.entity TheEntity
+      assert LittleMapper[TheEntity].is_a? TestClass
+    end
+
+    def test_enables_setting_and_getting_persistent_entity
+      TestClass.persistent_entity TheEntity
+      assert_equal TheEntity, TestClass.persistent_entity
+    end
+
+    def test_provides_mappings_array
+      assert TestClass.mappings.respond_to?(:each)
+    end
+
+    def test_enables_setting_and_getting_a_mapping_factory_instance
+      factory = Object.new
+      TestClass.mapping_factory = factory
+      assert_equal factory, TestClass.mapping_factory
+    end
+
+    def test_defaults_mapping_factory
+      TestClass.mapping_factory = nil
+      assert TestClass.mapping_factory.is_a? LittleMapper::MappingFactory
+    end
+
+    def test_maps_delegates_to_map_and_so_to_mapping_factory
+      factory = MiniTest::Mock.new
+      TestClass.mapping_factory = factory
+      args = [:a, :b, :c]
+      factory.expect(:map, true, [TestClass, :a, {}])
+      factory.expect(:map, true, [TestClass, :b, {}])
+      factory.expect(:map, true, [TestClass, :c, {}])
+      TestClass.maps(*args)
+      factory.verify
+    end
+
+    def test_delegates_map_to_mapping_factory
+      factory = MiniTest::Mock.new
+      TestClass.mapping_factory = factory
+      args = [:field, {:opt1 => :val, :opt2 => :val}]
+      factory.expect(:map, true, args.dup.unshift(TestClass))
+      TestClass.map(*args)
+      factory.verify
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,6 @@
+unless defined? LittleMapper
+  $:.unshift File.expand_path('../../lib', __FILE__)
+  require 'little_mapper'
+end
+
+require 'minitest/autorun'

data/test/integration/ar_sqlite_test.rb

@@ -0,0 +1,94 @@
+require 'helper'
+require 'active_record'
+require 'integration/helper'
+
+
+
+class ArSqliteTest < MiniTest::Unit::TestCase
+  DBNAME = 'lmapper.sqlite'
+
+  def init_db
+    if File.directory?('tmp')
+      File.unlink('tmp/#{DBNAME}') if File.exists?('tmp/#{DBNAME}')
+    else
+      Dir.mkdir('tmp')
+    end
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => 'tmp/test.sqlite')
+    create_tables
+    @_db_initialized = true
+  end
+
+  def create_tables
+    CreatePeople.new.up
+    CreatePhoneNumbers.new.up
+    CreateCats.new.up
+  end
+
+  def clear_tables
+    Persistent::Person.delete_all
+  end
+
+  def setup
+    init_db unless @_db_initialized
+    clear_tables
+  end
+
+
+  def test_round_trip
+    p = Person.new(:name => 'John', :age => 27)
+    LittleMapper[Person] << p
+    assert_equal 1, LittleMapper[Person].find_all.length
+    found = LittleMapper[Person].last
+    assert_equal p.name, found.name
+    assert_equal p.age, found.age
+    refute_nil found.id
+    assert_equal p.id, found.id
+  end
+
+  def test_find_all
+    LittleMapper[Person] << Person.new(:name => 'John', :age => 27)
+    LittleMapper[Person] << Person.new(:name => 'Jane', :age => 67)
+    assert_equal 2, LittleMapper[Person].find_all.length
+  end
+
+  def test_simple_one_to_many_association
+    p = Person.new(:name => 'John', :age => 27)
+    p.phone_numbers << PhoneNumber.new(:code => '099', :number => '987654321')
+    p.phone_numbers << PhoneNumber.new(:code => '123', :number => '123456789')
+    LittleMapper[Person] << p
+    found = LittleMapper[Person].find_by_id(p.id)
+    assert_equal 2, found.phone_numbers.length
+  end
+
+  def test_one_to_many_with_custom_setters_getters
+    p = Person.new(:name => 'John', :age => 27)
+    p.receive_cat(Cat.new(:moniker => 'Meaw', :color => 'Tabby'))
+    LittleMapper[Person] << p
+    found = LittleMapper[Person].find_by_id(p.id)
+    assert_equal 1, found.all_cats.length
+  end
+
+  def test_one_to_one_with_another_entity
+    o = Person.new(:name => 'Jane', :age => 28)
+    LittleMapper[Person] << o
+    p = Person.new(:name => 'John', :age => 27, :spouse => o)
+    LittleMapper[Person] << p
+    found = LittleMapper[Person].find_by_id(p.id)
+    assert_equal found.spouse, o
+  end
+
+  def test_sets_up_reflexive_mapping_by_default_on_related_entities
+    p = Person.new(:name => 'John', :age => 27)
+    number1 = PhoneNumber.new(:code => '099', :number => '987654321')
+    p.phone_numbers << number1
+    p.phone_numbers << PhoneNumber.new(:code => '123', :number => '123456789')
+    LittleMapper[Person] << p
+    found = LittleMapper[Person].find_by_id(p.id)
+    assert_equal found, found.phone_numbers.first.person
+  end
+
+
+
+
+
+end

data/test/integration/helper.rb

@@ -0,0 +1,114 @@
+class Person < OpenStruct
+
+  attr_accessor :phone_numbers
+  def initialize(*args)
+    super
+    @cats = []
+    @phone_numbers = []
+  end
+
+  def receive_cat(cat)
+    @cats << cat
+  end
+
+  def all_cats
+    @cats
+  end
+end
+
+class PhoneNumber
+  attr_accessor :id, :code, :number, :person
+  def initialize(opts = {})
+    opts.each_pair {|k, v| self.send("#{k}=", v)}
+  end
+end
+
+class Cat
+  attr_accessor :moniker, :color, :id
+  def initialize(opts = {})
+    opts.each_pair {|k, v| self.send("#{k}=", v)}
+  end
+
+  def owner=(owner)
+    @owner = owner
+  end
+
+  def owner
+    @owner
+  end
+end
+
+
+module Persistent
+  class Person < ActiveRecord::Base
+    has_many :phone_numbers
+    has_many :cats
+    belongs_to :spouse, :class_name => 'Person'
+  end
+
+  class PhoneNumber < ActiveRecord::Base
+    belongs_to :person
+  end
+
+  class Cat < ActiveRecord::Base
+    belongs_to :person
+  end
+end
+
+class PersonMapper
+  include LittleMapper
+  entity Person
+  persistent_entity Persistent::Person
+  maps :name, :age
+  map :phone_numbers, :as => [PhoneNumber]
+  map :all_cats, :as => [Cat], :entity_collection_adder => :receive_cat,
+      :to => :cats, :reflexive_setter => :owner=
+  map :spouse, :as => Person
+end
+
+class PhoneNumberMapper
+  include LittleMapper
+  entity PhoneNumber
+  persistent_entity Persistent::PhoneNumber
+  maps :code, :number
+end
+
+class CatMapper
+  include LittleMapper
+  entity Cat
+  persistent_entity Persistent::Cat
+  map :color
+  map :moniker, :to => :name
+end
+
+class CreatePeople < ActiveRecord::Migration
+  def up
+    create_table :people, :force => true do |t|
+      t.string :name
+      t.integer :age
+      t.integer :spouse_id
+      t.timestamps
+    end
+  end
+end
+
+class CreatePhoneNumbers < ActiveRecord::Migration
+  def up
+    create_table :phone_numbers, :force => true do |t|
+      t.references :person
+      t.string :code
+      t.string :number
+    end
+  end
+end
+
+class CreateCats < ActiveRecord::Migration
+  def up
+    create_table :cats, :force => true do |t|
+      t.references :person
+      t.string :name
+      t.string :color
+    end
+  end
+end
+

data/test/little_mapper_module_test.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class LittleMapperModuleTest < MiniTest::Unit::TestCase
+
+  class A; end
+  class B; end
+
+  def test_it_registers_mappers
+    LittleMapper.register(A, B)
+    assert LittleMapper[A].is_a? B
+  end
+
+end

data/test/mapper_instance_methods_test.rb

@@ -0,0 +1,22 @@
+require 'helper'
+
+module LittleMapper
+  class MapperInstanceMethodsTest < MiniTest::Unit::TestCase
+    class InstanceTestClass
+      include MapperInstanceMethods
+    end
+
+    def test_implements_repo_interface
+      @repo = InstanceTestClass.new
+      assert @repo.respond_to?(:<<), "should respond to <<"
+      assert @repo.respond_to?(:find_by_id), "should respond to find_by_id"
+      assert @repo.respond_to?(:find_all), "should respond to find_by_all"
+      assert @repo.respond_to?(:last), "should respond to last"
+
+      assert @repo.respond_to?(:to_entity), "provides to_entity"
+      assert @repo.respond_to?(:to_persistent), "provides to_persistent"
+    end
+
+
+  end
+end

data/test/mapping_factory_test.rb

@@ -0,0 +1,14 @@
+require 'helper'
+
+module LittleMapper
+  class MappingFactoryTest < MiniTest::Unit::TestCase
+    def test_defaults_to_activerecord_strategy
+      assert MappingFactory.new.strategy == :activerecord
+    end
+
+    def test_one_to_one_constant
+      assert_equal LittleMapper::Mappers::AR::OneToOne, MappingFactory.new.one_to_one
+    end
+
+  end
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: little_mapper
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Simon Robson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple, ActiveRecord-backed data mapper / repository
+email:
+- shrobson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/little_mapper.rb
+- lib/little_mapper/dsl_class_methods.rb
+- lib/little_mapper/mapper_instance_methods.rb
+- lib/little_mapper/mappers/AR/one_to_many.rb
+- lib/little_mapper/mappers/AR/one_to_one.rb
+- lib/little_mapper/mappers/active_record.rb
+- lib/little_mapper/mappers/mappers.rb
+- lib/little_mapper/mapping_factory.rb
+- lib/little_mapper/result/repo_failure.rb
+- lib/little_mapper/result/repo_response.rb
+- lib/little_mapper/result/repo_success.rb
+- lib/little_mapper/version.rb
+- little_mapper.gemspec
+- test/dsl_class_methods_test.rb
+- test/helper.rb
+- test/integration/ar_sqlite_test.rb
+- test/integration/helper.rb
+- test/little_mapper_module_test.rb
+- test/mapper_instance_methods_test.rb
+- test/mapping_factory_test.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple, ActiveRecord-backed data mapper / repository
+test_files:
+- test/dsl_class_methods_test.rb
+- test/helper.rb
+- test/integration/ar_sqlite_test.rb
+- test/integration/helper.rb
+- test/little_mapper_module_test.rb
+- test/mapper_instance_methods_test.rb
+- test/mapping_factory_test.rb