peacekeeper 0.0.0 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fa3eff5db180174619150ac1f8004706e6cfa9e
+  data.tar.gz: 9668cfd0a54b84b6825338f9dda8c5b8d4c11e7f
+SHA512:
+  metadata.gz: 73461cb3360790b227ddd4504858b112cd2db729d59af6c21893a9b702c5b0c3f04824f7a16250864464495c8923342f8110898cf545d5509f8ab94c1f51d7e9
+  data.tar.gz: fa72f99fef480695f45d4116c6b7226981ec95f21b25af8406058170eb09d946b3bf205ddd0224c911f0338f3eaf6cd6957494a96b1b0efb3005c11fef2233bf

data/README.md

@@ -0,0 +1,119 @@
+## What is Peacekeeper?
+
+Peacekeeper is a simple delegation library that allows the creation of business objects (Peacekeeper models) that hide the data objects they pull from. This allows a clean separation of business logic and data logic, without any kind of imposition on how the data is stored. Business objects (Peacekeeper models) can pull from an API resource or database resource, or this can be changed at runtime.
+
+Peacekeeper delegates any unknown methods from your business objects directly to their respective data object.
+
+examples usages for each DB type:
+
+```ruby
+# API resource using Nasreddin
+# lib/models/car_model.rb
+class CarModel < Peacekeeper::Model
+  self.data_source = :api
+  # application specific business logic
+end
+
+# lib/data/api/car.rb
+class Car < Nasreddin::Resource('cars')
+  # data retrieval logic
+end
+
+# Database resource using Sequel
+# lib/models/car_model.rb
+class CarModel < Peacekeeper::Model
+  self.data_source = :sequel # Can also use :active_record
+  # application specific business logic
+end
+
+# lib/data/sequel/car.rb
+class Car < Sequel::Model
+  # data retrieval logic
+end
+
+# lib/data/active_record/car.rb
+class Car < ActiveRecord::Base
+  # data retrieval logic
+end
+```
+
+# Setting up Peacekeeper
+Peacekeeper requires that your data source be configured. This can be done in a
+yaml file:
+
+```yaml
+default: &default
+  adapter: <%= defined?(JRUBY_VERSION) ? 'jdbc:mysql':'mysql2' %> 
+  username: root
+  password:
+  host: localhost
+  xa: false
+
+development:
+  <<: *default
+  database: dev
+test:
+  <<: *default
+  database: test
+build:
+  <<: *default
+  database: build
+staging:
+  <<: *default
+  database: staging
+production:
+  <<: *default
+  database: production
+```
+
+# Sinatra
+If you are using Sinatra, you can setup Peacekeeper with something like this in
+your lib dir.
+
+```ruby
+# lib/database.rb
+dbcfg = File.read(File.expand_path('config/database.yml', APP_ROOT))
+dbcfg = ERB.new(dbcfg).result(binding)
+Peacekeeper::Model.config = YAML.load(dbcfg)[ENV['RACK_ENV']]
+Sequel.default_timezone = :utc
+```
+
+# Rails
+If you are using Rails, you can setup Peacekeeper with something like this in
+your application.rb.
+
+```ruby
+# config/application.rb
+class Application < Rails::Application
+  dbcfg = File.read(File.expand_path('config/database.yml', config.root))
+  dbcfg = ERB.new(dbcfg).result(binding)
+  Peacekeeper::Model.config = YAML.load(dbcfg)[Rails.env]
+end
+```
+
+# Testing with Peacekeeper
+Peacekeeper also makes testing easy with the :mock ORM type, this can be set in your test code which sets Peacekeeper to return mock objects from any delegated methods.
+You will need a mocking library installed that responds to mock(). If you are using rspec, add this to your spec_helper.rb file:
+
+```ruby
+RSpec.configure do |config|
+  config.before(:all) do
+    Peacekeeper::Model.config[:mock_library] = 'mocha'
+    Peacekeeper::Model.data_source = :mock
+  end
+end
+```
+
+example usage:
+```ruby
+describe 'CarModel' do
+  CarModel.data_source = :mock
+  # test business logic
+end
+```
+
+# License
+
+Copyright (C) 2012-2013 Burnside Digital
+
+Licensed under the BSD 2-Clause License. See COPYING for license details.

data/Rakefile

@@ -1 +1,12 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'yard'
+
+desc 'Run all the tests'
+task :test do
+  sh 'bacon -a'
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.name = 'doc'
+  t.files = Dir["#{File.dirname(__FILE__)}/lib/**/*"]
+end

data/lib/peacekeeper.rb

@@ -1,5 +1,4 @@
-require "peacekeeper/version"
-
-module Peacekeeper
-  # Your code goes here...
-end
+require 'peacekeeper/version'
+require 'peacekeeper/loader'
+require 'peacekeeper/model_delegation'
+require 'peacekeeper/model'

data/lib/peacekeeper/loader.rb

@@ -0,0 +1,112 @@
+module Peacekeeper
+  class Loader
+    attr_reader :source, :config
+
+    def initialize(config)
+      @config = config
+      @source = config[:source]
+    end
+
+    def load_source
+      case source
+      when :sequel
+        require 'sequel'
+        Sequel::Model.db = Sequel::DATABASES.find { |db| db.uri == sequel_db_uri } || Sequel.connect(sequel_db_uri)
+      when :active_record
+        require 'active_record'
+        ActiveRecord::Base.establish_connection(active_record_config)
+      when :api
+        require 'nasreddin'
+      when :mock
+        require config[:mock_library] if config[:mock_library]
+        #data_class # Trigger mock data_class creation
+      end
+    end
+
+
+    # Construct uri to connect to database
+    # Sequel: http://sequel.rubyforge.org/rdoc/files/doc/opening_databases_rdoc.html
+    def sequel_db_uri
+      # Set the protocol (DB engine; i.e. mysql, sqlite3, postgres, etc.)
+      protocol = config['protocol'] || config['adapter'] || 'sqlite'
+      if RUBY_ENGINE == 'jruby'
+        protocol = "jdbc:#{protocol}" unless protocol.start_with? "jdbc:"
+      end
+
+      # Set the path (hostname & database name)
+      path = "#{config['host'] || config['path']}/#{config['database']}"
+      path = '' if path == '/' # Clear path if 'host', 'path', and 'database' are all unset
+
+      # Set the user and password
+      if RUBY_ENGINE == 'jruby' && protocol == 'jdbc:mysql'
+        # Special case for JRuby and MySQL
+        user_pass = "?user=#{config['username']}&password=#{config['password']}"
+        server_path = "#{path}#{user_pass}"
+      else
+        user_pass = "#{config['username']}:#{config['password']}@"
+        user_pass = '' if user_pass == ':@' # Clear user_pass if both 'username' and 'password' are unset
+        server_path = "#{user_pass}#{path}"
+      end
+
+      # Finally, put the protocol and path components together
+      server_path = "/#{server_path}" unless server_path.empty?
+      uri = "#{protocol}:/#{server_path}"
+      uri = 'jdbc:sqlite::memory:' if uri == 'jdbc:sqlite:/' && RUBY_ENGINE == 'jruby'
+      if config['options']
+        if uri =~ /\?/
+          uri += "&#{paramize(config['options'])}"
+        else
+          uri += "?#{paramize(config['options'])}"
+        end
+      end
+      uri
+    end
+
+    def active_record_config
+      protocol = config['protocol'] || config['adapter'] || 'sqlite3'
+      # Set the adapter (DB engine; i.e. mysql, sqlite3, postgres, etc.)
+
+      database = config['database']
+      ar_config = {
+        adapter:  protocol,
+        database: database
+      }
+      ar_config['host'] = config['host'] if config['host']
+      ar_config['username'] = config['username'] if config['username']
+      ar_config['password'] = config['password'] if config['password']
+      ar_config['driver'] = config['driver'] if config['driver']
+      ar_config
+    end
+
+    def paramize(options)
+      params = options.map { |k, v| "#{k}=#{v}" }
+      "#{params.join('&')}"
+    end
+  end
+
+  module DataLoader
+    def self.data_class(config)
+      source = config[:source]
+      data_lib_name = config[:data_lib_name]
+      data_name = config[:data_name]
+      if source.nil?
+        nil
+      elsif source == :mock
+        Kernel.const_set(data_name, Class.new do
+                                      def self.new(opts = {})
+                                        mock(self.name.gsub(/^.*:/, ''), opts)
+                                      end
+                                      def self.method_missing(*)
+                                        self.new
+                                      end
+                                      def self.respond_to?(*)
+                                        true
+                                      end
+                                    end)
+      else
+        require "data/#{source}/#{data_lib_name}"
+        Kernel.const_get(data_name)
+      end
+    end
+  end
+end

data/lib/peacekeeper/model.rb

@@ -0,0 +1,122 @@
+module Peacekeeper
+  class Model
+    kernel = ::Kernel.dup
+    kernel.class_eval do
+      [:to_s, :inspect, :=~, :!~, :===, :<=>, :eql?, :hash].each do |m|
+        undef_method m
+      end
+    end
+    include kernel
+
+    class<<self
+      include ModelDelegation
+
+      def new(*)
+        raise RuntimeError, "ModelObject cannot be instantiated directly. Please subclass first!" if self == Model
+        super
+      end
+
+      def subclasses; (@subclasses ||= []); end
+
+      def config; (@config ||= {}); end
+
+      def config=(new_config)
+        @config = new_config
+
+        subclasses.each do |sub|
+          sub.config = @config
+        end
+        @config
+      end
+
+      def data_source; (@data_source ||= nil); end
+
+      def data_source=(source)
+        @data_source = source
+        @loader = Loader.new(config.merge(source: source))
+        @loader.load_source
+
+        if source == :mock
+          data_class # Trigger mock data_class creation
+        end
+
+        subclasses.each do |sub|
+          sub.data_source = @data_source
+        end
+
+        @data_source
+      end
+
+      def data_class
+        return nil if self == Model
+        @data_class ||= (data_source.nil? ? nil : DataLoader.data_class(data_name: data_name, data_lib_name: data_lib_name, source: data_source))
+      end
+      alias :delegate :data_class
+
+      def inherited(sub)
+        unless sub.name.nil?
+          subclasses << sub
+          sub.setup(self)
+        end
+      end
+
+      def has_wrapper_for?(val)
+        !!wrapper_for(val)
+      end
+
+      def wrapper_for(val)
+        subclasses.find do |subclass|
+          val == subclass.delegate
+        end
+      end
+
+      def setup(parent)
+        self.config = parent.config
+        self.data_source = parent.data_source
+      end
+
+      def data_name
+        self.name.sub(/Model$/, '')
+      end
+
+      def data_lib_name
+        name = data_name
+        name.gsub!(/::/, '/')
+        name.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+        name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+        name.tr!("-", "_")
+        name.downcase!
+        name
+      end
+
+    end
+
+    include ModelDelegation
+
+    attr_reader :data
+    alias :delegate :data
+
+    def initialize(*args)
+      if !args.nil? && args.length == 1 && args.first.kind_of?(data_class)
+        @data = args.first
+      else
+        @data = data_class.new(*args)
+      end
+
+      unless self.class.instance_methods(false).include?(:to_json)
+        class<<self
+          undef_method :to_json if respond_to?(:to_json)
+          undef_method :as_json if respond_to?(:as_json)
+        end
+      end
+    end
+
+    def ==(obj)
+      obj.equal?(self) || @data == obj.data
+    end
+
+    def data_class
+      self.class.data_class
+    end
+  end
+end

data/lib/peacekeeper/model_delegation.rb

@@ -0,0 +1,68 @@
+module Peacekeeper
+  module ModelDelegation
+    class Pass
+      def self.===(o)
+        false
+      end
+    end
+
+    def method_missing(mid, *args, &block)
+      if !delegate.nil? && delegate.respond_to?(mid)
+        mblock = begin
+                   delegate.method(mid).to_proc
+                 rescue NameError
+                   proc do |*args, &block|
+                     delegate.send(mid, *args, &block)
+                   end
+                 end
+        define_wrapped_singleton_method(mid, mblock)
+        __send__(mid, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(mid, include_private)
+      ret = delegate.respond_to?(mid, include_private)
+      if ret && include_private && !delegate.respond_to?(mid, false)
+        # Don't delegate private methods
+        return false
+      end
+      ret
+    end
+
+    def wrap(val)
+      if (self.kind_of?(Class) && val.kind_of?(delegate))
+        new(val)
+      elsif (self.kind_of?(Peacekeeper::Model) && val.kind_of?(delegate.class))
+        self.class.new(val)
+      elsif (Peacekeeper::Model.has_wrapper_for?(val.class))
+        Peacekeeper::Model.wrapper_for(val.class).new(val)
+      elsif (val.kind_of?(Hash))
+        Hash[*val.flat_map { |k, v| [k, wrap(v)] }]
+      elsif (val.kind_of?(Enumerable) || val.methods.include?(:each))
+        val.map { |i| wrap(i) }
+      else
+        val
+      end
+    end
+
+    def define_wrapped_singleton_method(mid, mblock)
+      define_singleton_method(mid) do |*args, &block|
+        wrap(mblock.call(*args, &block))
+      end
+    end
+
+    def def_data_method(mid, &mblock)
+      define_method(mid) do |*args|
+        wrap(delegate.instance_exec(*args, &mblock))
+      end
+    end
+
+    def def_singleton_data_method(mid, &mblock)
+      define_singleton_method(mid) do |*args|
+        wrap(delegate.instance_exec(*args, &mblock))
+      end
+    end
+  end
+end

data/lib/peacekeeper/version.rb

@@ -1,3 +1,3 @@
 module Peacekeeper
-  VERSION = "0.0.0"
+  VERSION = '0.4.0'
 end

data/test/fixtures/data/active_record/after_ar.rb

@@ -0,0 +1,2 @@
+class AfterAr < ActiveRecord::Base
+end

data/test/fixtures/data/active_record/after_setting_ar.rb

@@ -0,0 +1 @@
+class AfterSettingAr; end

data/test/fixtures/data/active_record/before_ar.rb

@@ -0,0 +1,2 @@
+class BeforeAr < ActiveRecord::Base
+end

data/test/fixtures/data/active_record/before_setting_ar.rb

@@ -0,0 +1 @@
+class BeforeSettingAr; end

data/test/fixtures/data/active_record/my_subtest_ar.rb

@@ -0,0 +1,3 @@
+class MySubtestAr < ActiveRecord::Base
+  belongs_to :my_test_ar
+end

data/test/fixtures/data/active_record/my_test_ar.rb

@@ -0,0 +1,5 @@
+class MyTestAr < ActiveRecord::Base
+  has_one :other, class_name: "MyTestAr", foreign_key: :other_id
+  has_many :my_subtest_ars
+end
+

data/test/fixtures/data/sequel/after.rb

@@ -0,0 +1,2 @@
+class After < Sequel::Model
+end

data/test/fixtures/data/sequel/after_setting.rb

@@ -0,0 +1 @@
+class AfterSetting; end

data/test/fixtures/data/sequel/before.rb

@@ -0,0 +1,2 @@
+class Before < Sequel::Model
+end

data/test/fixtures/data/sequel/before_setting.rb

@@ -0,0 +1 @@
+class BeforeSetting; end

data/test/fixtures/data/sequel/my_subtest.rb

@@ -0,0 +1,3 @@
+class MySubtest < Sequel::Model
+  many_to_one :my_test
+end

data/test/fixtures/data/sequel/my_test.rb

@@ -0,0 +1,5 @@
+class MyTest < Sequel::Model
+  one_to_one :other, class: MyTest, key: :other_id
+  one_to_many :my_subtests
+end
+

data/test/peacekeeper/test_loader.rb

@@ -0,0 +1,137 @@
+require_relative '../test_helper'
+
+describe Peacekeeper::Loader do
+  describe 'manages a data source selection' do
+    # Implementation deatail...
+    Peacekeeper::Model.instance_variable_set(:@subclasses, [])
+
+    it 'is nil by default' do
+      Peacekeeper::Model.data_source.should.be.nil
+    end
+
+    describe 'set to Sequel' do
+      before do
+        Peacekeeper::Model.data_source = nil
+      end
+
+      it 'requires the Sequel library' do
+        loader = mock("Loader")
+        loader.should.receive(:load_source)
+        Peacekeeper::Loader.should.receive(:new).and_return(loader)
+        Peacekeeper::Model.data_source = :sequel
+      end
+
+      it 'loads the Data object for subclasses created before' do
+        loader = mock("Loader")
+        loader.should.receive(:load_source).times(3)
+        Peacekeeper::Loader.should.receive(:new).times(3).and_return(loader)
+
+        class BeforeModel < Peacekeeper::Model;
+        end
+        Peacekeeper::Model.data_source = :sequel
+        lambda do
+          BeforeModel.data_class.should.equal Before
+        end
+      end
+
+      it 'loads the Data object for subclasses created after' do
+        loader = mock("Loader")
+        loader.should.receive(:load_source).times(3)
+        Peacekeeper::Loader.should.receive(:new).times(3).and_return(loader)
+
+        Peacekeeper::Model.data_source = :sequel
+        class AfterModel < Peacekeeper::Model;
+        end
+        lambda do
+          AfterModel.data_class.should.equal After
+        end
+      end
+
+      it 'propogates the ORM setting to subclasses' do
+        class BeforeSettingModel < Peacekeeper::Model;
+        end
+        Peacekeeper::Model.data_source = :sequel
+        class AfterSettingModel < Peacekeeper::Model;
+        end
+
+        BeforeSettingModel.data_source.should.equal :sequel
+        AfterSettingModel.data_source.should.equal :sequel
+      end
+
+      it 'should only connect to the Database once' do
+        class BeforeModel < Peacekeeper::Model;
+        end
+        class BeforeSettingModel < Peacekeeper::Model;
+        end
+        Peacekeeper::Model.data_source = :sequel
+        class AfterModel < Peacekeeper::Model;
+        end
+        class AfterSettingModel < Peacekeeper::Model;
+        end
+        Sequel::DATABASES.length.should.equal 1
+      end
+    end
+
+    describe 'set to Active Record' do
+      before do
+        Peacekeeper::Model.data_source = nil
+      end
+
+      it 'requires the Active Record library' do
+        loader = mock("Loader")
+        loader.should.receive(:load_source).times(5)
+        Peacekeeper::Loader.should.receive(:new).times(5).and_return(loader)
+        Peacekeeper::Model.data_source = :active_record
+      end
+
+      it 'should connect to the Database' do
+        Peacekeeper::Model.data_source = :active_record
+        ActiveRecord::Base.connection() # Force AR to ~actually~ connect to the DB
+        ActiveRecord::Base.connected?.should.equal true
+      end
+    end
+
+    describe 'set to mock' do
+      Peacekeeper::Model.data_source = :nil
+      Peacekeeper::Model.config[:mock_library] = 'facon'
+
+      it 'requires the facon library' do
+        loader = mock("Loader")
+        loader.should.receive(:load_source).times(5)
+        Peacekeeper::Loader.should.receive(:new).times(5).and_return(loader)
+
+        Peacekeeper::Model.data_source = :mock
+      end
+
+      it 'creates a data class ready for mocking' do
+        class MyMockModel < Peacekeeper::Model; end
+        defined?(MyMock).should.equal 'constant'
+        MyMock.should.receive(:delegate_call)
+        MyMockModel.delegate_call
+      end
+
+      it 'returns empty mocks for data class calls by default' do
+        class MyMockableModel < Peacekeeper::Model; end
+
+        foo = MyMockableModel.get_foo
+
+        foo.name.should.equal 'MyMockable'
+        foo.should.be.kind_of Facon::Mock
+      end
+
+      it 'returns a mock with properties set when #new is called with options' do
+        class MyInstantiableMockModel < Peacekeeper::Model; end
+
+        user = MyInstantiableMockModel.new(name: "Joe", position: :employee, vacation_days: 14)
+
+        user.name.should.equal "Joe"
+        user.position.should.equal :employee
+        user.vacation_days.should.equal 14
+      end
+
+      # Implementation deatail...
+      Peacekeeper::Model.instance_variable_set(:@subclasses, [])
+    end
+  end
+
+end

data/test/peacekeeper/test_model.rb

@@ -0,0 +1,224 @@
+require_relative '../test_helper'
+
+describe Peacekeeper::Model do
+  it 'cannot be instantiated directly' do
+    -> { Peacekeeper::Model.new }.should.raise(RuntimeError)
+  end
+
+  class SubclassTestModel < Peacekeeper::Model; end
+
+  it 'derives a model name based on the subclass\'s name' do
+    SubclassTestModel.data_name.should.equal 'SubclassTest'
+  end
+
+  it 'derives a data library name based on the subclass\'s name' do
+    SubclassTestModel.data_lib_name.should.equal 'subclass_test'
+  end
+
+  describe 'manages a database config' do
+    #it 'is empty by default' do
+    #  Peacekeeper::Model.config.should.be.empty
+    #end
+
+    it 'is inherited by subclasses' do
+      path = 'tmp/test_db.sqlite'
+      class SubclassBeforeModel < Peacekeeper::Model;
+      end
+      Peacekeeper::Model.config = {path: path}
+      class SubclassAfterModel < Peacekeeper::Model;
+      end
+
+      SubclassBeforeModel.config[:path].should.equal path
+      SubclassAfterModel.config[:path].should.equal path
+    end
+  end
+
+  describe 'used to create a model subclass with Sequel' do
+    # Repeat config here in case these tests are run alone
+    Peacekeeper::Model.config[:protocol] = 'jdbc:sqlite::memory:'
+    Peacekeeper::Model.data_source = :sequel
+
+    class MyTestModel < Peacekeeper::Model
+      def test
+        :ok
+      end
+    end
+
+    class MySubtestModel < Peacekeeper::Model; end
+
+    # Setup the DB and populate with some test data
+    DB = Sequel::Model.db
+    DB.create_table :my_tests do
+      primary_key :id
+      foreign_key :other_id, :my_tests
+      String :name
+    end
+    DB[:my_tests].insert(id: 1, name: 'A Test')
+    DB[:my_tests].insert(id: 2, other_id: 1, name: 'Other')
+    DB[:my_tests].filter(id: 1).update(other_id: 2)
+
+    DB.create_table :my_subtests do
+      primary_key :id
+      foreign_key :my_test_id, :my_tests
+      String :name
+    end
+    DB[:my_subtests].insert(id: 1, my_test_id: 1, name: 'First')
+    DB[:my_subtests].insert(id: 2, my_test_id: 1, name: 'Second')
+    MySubtestModel.new # Instantiate to force loading of data class
+
+    it 'delegates data class methods to the data class' do
+      (MyTestModel.respond_to?(:table_name)).should.be.true
+      MyTestModel.table_name.should.equal :my_tests
+    end
+
+    describe 'when instantiated' do
+      my_test_model = MyTestModel.new
+
+      it 'creates a data instance' do
+        my_test_model.data.class.should.equal MyTest
+      end
+
+      it 'delegates data methods to the data object' do
+        my_test_model.columns.should.equal [:id, :other_id, :name]
+      end
+
+      it 'still has access to methods defined on the model' do
+        my_test_model.test.should.be.equal :ok
+      end
+
+      it 'wraps delegated methods that return data class instances' do
+        a_test = MyTestModel.filter(name: 'Other').first
+        a_test.other.should.be.kind_of MyTestModel
+      end
+    end
+
+    it 'wraps a data object return value in a model object' do
+      res = MyTestModel.first
+      res.should.be.kind_of MyTestModel
+    end
+
+    it 'wraps a collection of data object return values in model objects' do
+      res = MyTestModel.all
+      res.should.be.kind_of Array
+      res.each { |i| i.should.be.kind_of MyTestModel }
+    end
+
+    it 'wraps return values from other model objects' do
+      test = MyTestModel.first
+      res = test.my_subtests
+      res.should.be.kind_of Array
+      res.each { |i| i.should.be.kind_of MySubtestModel }
+    end
+
+    it 'maps a hash return value to a hash' do
+      res = MyTestModel.new.associations
+      res.should.be.kind_of Hash
+    end
+
+    it 'delegates class methods with an argument' do
+      my_test_model = MyTestModel.create name: 'Another Test'
+      my_test_model.should.be.kind_of MyTestModel
+      MyTestModel.filter(name: 'Another Test').first.should.equal my_test_model
+    end
+    it 'should prevent calling :to_json inherited from Object' do
+      class Object
+        def to_json
+          raise "don't call me"
+        end
+      end
+      class MyTestModel < Peacekeeper::Model
+      end
+      class MyTest
+        def to_json
+          :ok
+        end
+      end
+      MyTestModel.new.to_json.should.equal :ok
+      -> { Object.new.to_json }.should.raise(RuntimeError)
+    end
+
+    it 'should allow redefinition of :to_json in the model' do
+      class Object
+        def to_json
+          raise "don't call me"
+        end
+      end
+      class MyTestModel < Peacekeeper::Model
+        def to_json
+          :ok
+        end
+      end
+      class MyTest
+        def to_json
+          :ko
+        end
+      end
+      MyTestModel.new.to_json.should.equal :ok
+    end
+
+    it 'can define methods that operate directly on the data class' do
+      class MyTestModel
+        def_data_method :others_first_subtest do
+          other.my_subtests.first
+        end
+      end
+      res = MyTestModel.filter(id: 2).first.others_first_subtest
+      res.should.be.kind_of MySubtestModel
+      res.name.should.equal 'First'
+    end
+
+    it 'can define methods that operate directly on the data class and takes arguments' do
+      class MyTestModel
+        def_data_method :others_nth_subtest do |n|
+          other.my_subtests[n]
+        end
+      end
+      res = MyTestModel.filter(id: 2).first.others_nth_subtest(1)
+      res.should.be.kind_of MySubtestModel
+      res.name.should.equal 'Second'
+    end
+
+    it 'can define class methods that operate directly on the data class' do
+      class MyTestModel
+        def_singleton_data_method :first_subtest do
+          first.my_subtests.first
+        end
+      end
+      res = MyTestModel.first_subtest
+      res.should.be.kind_of MySubtestModel
+      res.name.should.equal 'First'
+    end
+  end
+
+  # These are too close to testing the implementation with the implementation.
+  # We should probably either test URL construction indirectly or using mocks.
+  # TODO: Implement a test for config['options'] as well.
+  #describe 'database connection uri' do
+  #  username = Peacekeeper::Model.config['username'] = 'username'
+  #  password = Peacekeeper::Model.config['password'] = 'password'
+  #  host = Peacekeeper::Model.config['host'] = 'localhost'
+  #  database = Peacekeeper::Model.config['database'] = 'database'
+
+  #  describe "when specified adapter is 'jdbc:mysql'" do
+  #    it 'generate uri for jdbc:mysql' do
+  #      adapter = Peacekeeper::Model.config['adapter'] = 'jdbc:mysql'
+  #      Peacekeeper::Model.sequel_db_uri.should.eql "#{adapter}://#{host}/#{database}?user=#{username}&password=#{password}"
+  #    end
+  #  end
+
+  #  describe "when specified adapter is not 'jdbc:mysql'" do
+  #    it 'generate non-jdbc uri' do
+  #      adapter = Peacekeeper::Model.config['adapter'] = 'mysql2'
+  #      Peacekeeper::Model.sequel_db_uri.should.eql "#{adapter}://#{username}:#{password}@#{host}/#{database}"
+  #    end
+  #  end
+
+  #  describe "when no adapter is specified" do
+  #    it 'generate sqlite uri' do
+  #      Peacekeeper::Model.config = {}
+  #      Peacekeeper::Model.sequel_db_uri.should.eql 'sqlite:/'
+  #    end
+  #  end
+  #end
+end
+

data/test/peacekeeper/test_orm_model.rb

@@ -0,0 +1,115 @@
+require_relative '../test_helper'
+
+describe Peacekeeper::Model do
+  describe 'used to create a model subclass with Active Record' do
+    class MyTestArModel < Peacekeeper::Model
+      def test
+        :ok
+      end
+    end
+
+    class MySubtestArModel < Peacekeeper::Model; end
+
+    # Setup the DB and populate with some test data
+    Peacekeeper::Model.config['database'] = ':memory:'
+    Peacekeeper::Model.config[:protocol] = 'jdbc:sqlite:'
+    Peacekeeper::Model.data_source = :active_record
+
+    ActiveRecord::Base.connection.execute("CREATE TABLE my_test_ars (id INTEGER PRIMARY KEY, other_id INTEGER, name STRING);")
+    ActiveRecord::Base.connection.execute("CREATE TABLE my_subtest_ars (id INTEGER PRIMARY KEY, my_test_ar_id INTEGER, name STRING);")
+
+    ActiveRecord::Base.connection.execute("INSERT INTO my_test_ars (id,other_id,name) VALUES (1, 2, 'A Test');")
+    ActiveRecord::Base.connection.execute("INSERT INTO my_test_ars (id,other_id,name) VALUES (2, 1, 'Other');")
+    ActiveRecord::Base.connection.execute("INSERT INTO my_subtest_ars (id,my_test_ar_id,name) VALUES (1, 1, 'First');")
+    ActiveRecord::Base.connection.execute("INSERT INTO my_subtest_ars (id,my_test_ar_id,name) VALUES (2, 1, 'Second');")
+
+    it 'delegates data class methods to the data class' do
+      (MyTestArModel.respond_to?(:table_name)).should.be.true
+      MyTestArModel.table_name.should.equal "my_test_ars"
+    end
+
+    describe 'when instantiated' do
+      my_test_model = MyTestArModel.new
+
+      it 'creates a data instance' do
+        my_test_model.data.class.should.equal MyTestAr
+      end
+
+      it 'delegates data methods to the data object' do
+        my_test_model.attribute_names.should.equal ['id', 'other_id', 'name']
+      end
+
+      it 'still has access to methods defined on the model' do
+        my_test_model.test.should.be.equal :ok
+      end
+
+      it 'wraps delegated methods that return data class instances' do
+        a_test = MyTestArModel.where(name: 'Other').first
+        a_test.other.should.be.kind_of MyTestArModel
+      end
+    end
+
+    it 'wraps a data object return value in a model object' do
+      res = MyTestArModel.first
+      res.should.be.kind_of MyTestArModel
+    end
+
+    it 'wraps a collection of data object return values in model objects' do
+      res = MyTestArModel.all
+      res.should.be.kind_of Array
+      res.each { |i| i.should.be.kind_of MyTestArModel }
+    end
+
+    it 'wraps return values from other model objects' do
+      test = MyTestArModel.first
+      res = test.my_subtest_ars
+      res.should.be.kind_of Array
+      res.each { |i| i.should.be.kind_of MySubtestArModel }
+    end
+
+    it 'maps a hash return value to a hash' do
+      res = MyTestArModel.new.attributes
+      res.should.be.kind_of Hash
+    end
+
+    it 'delegates class methods with an argument' do
+      my_test_model = MyTestArModel.create name: 'Another Test'
+      my_test_model.should.be.kind_of MyTestArModel
+      MyTestArModel.where(name: 'Another Test').first.should.equal my_test_model
+    end
+
+    it 'can define methods that operate directly on the data class' do
+      class MyTestArModel
+        def_data_method :others_first_subtest do
+          other.my_subtest_ars.first
+        end
+      end
+      res = MyTestArModel.where(id: 2).first.others_first_subtest
+      res.should.be.kind_of MySubtestArModel
+      res.name.should.equal 'First'
+    end
+
+    it 'can define methods that operate directly on the data class and takes arguments' do
+      class MyTestArModel
+        def_data_method :others_nth_subtest do |n|
+          other.my_subtest_ars[n]
+        end
+      end
+      res = MyTestArModel.where(id: 2).first.others_nth_subtest(1)
+      res.should.be.kind_of MySubtestArModel
+      res.name.should.equal 'Second'
+    end
+
+    it 'can define class methods that operate directly on the data class' do
+      class MyTestArModel
+        def_singleton_data_method :first_subtest do
+          first.my_subtest_ars.first
+        end
+      end
+      res = MyTestArModel.first_subtest
+      res.should.be.kind_of MySubtestArModel
+      res.name.should.equal 'First'
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -0,0 +1,32 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../fixtures', __FILE__)
+
+require 'ruby-debug'
+begin
+  require 'pry'
+rescue LoadError
+  $stderr.puts 'Install the pry gem for better debugging.'
+end
+require 'facon'
+require 'peacekeeper'
+
+# Until JRuby fixes http://jira.codehaus.org/browse/JRUBY-6550 ...
+class Should
+  def satisfy(*args, &block)
+    if args.size == 1 && String === args.first
+      description = args.shift
+    else
+      description = ""
+    end
+
+    # ToDo Jruby bug not yet resolved see http://jira.codehaus.org/browse/JRUBY-6550 Victor Christensen at 2:06 PM on 4/20/12
+    #r = yield(@object, *args)
+    r = yield(@object)
+    if Bacon::Counter[:depth] > 0
+      Bacon::Counter[:requirements] += 1
+      raise Bacon::Error.new(:failed, description) unless @negated ^ r
+    else
+      @negated ? !r : !!r
+    end
+  end
+end

metadata

@@ -1,52 +1,209 @@
 --- !ruby/object:Gem::Specification
 name: peacekeeper
 version: !ruby/object:Gem::Version
-  version: 0.0.0
-  prerelease: 
+  version: 0.4.0
 platform: ruby
 authors:
 - Josh Ballanco
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-03-24 00:00:00.000000000 Z
-dependencies: []
-description: Using Peacekeeper, you can develop models separately from the ORM used
-  to persist data.
+date: 2013-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.38.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.38.0
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.6
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: activerecord-jdbc-adapter
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.2
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: nasreddin
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: jdbc-sqlite3
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.7.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.7.2
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: bacon
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: facon
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.7
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.7
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: yard
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.8.2
+  prerelease: false
+  type: :development
+description: Using Peacekeeper, you can develop models separately from the ORM used to persist data.
 email:
 - jballanc@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- Gemfile
-- Rakefile
 - lib/peacekeeper.rb
+- lib/peacekeeper/loader.rb
+- lib/peacekeeper/model.rb
+- lib/peacekeeper/model_delegation.rb
 - lib/peacekeeper/version.rb
-- peacekeeper.gemspec
+- test/test_helper.rb
+- test/fixtures/data/active_record/after_ar.rb
+- test/fixtures/data/active_record/after_setting_ar.rb
+- test/fixtures/data/active_record/before_ar.rb
+- test/fixtures/data/active_record/before_setting_ar.rb
+- test/fixtures/data/active_record/my_subtest_ar.rb
+- test/fixtures/data/active_record/my_test_ar.rb
+- test/fixtures/data/sequel/after.rb
+- test/fixtures/data/sequel/after_setting.rb
+- test/fixtures/data/sequel/before.rb
+- test/fixtures/data/sequel/before_setting.rb
+- test/fixtures/data/sequel/my_subtest.rb
+- test/fixtures/data/sequel/my_test.rb
+- test/peacekeeper/test_loader.rb
+- test/peacekeeper/test_model.rb
+- test/peacekeeper/test_orm_model.rb
+- Rakefile
+- README.md
 homepage: ''
 licenses: []
-post_install_message: 
+metadata: {}
+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: peacekeeper
-rubygems_version: 1.8.15
-signing_key: 
-specification_version: 3
+rubygems_version: 2.1.10
+signing_key:
+specification_version: 4
 summary: Peacekeeper handles delegation to a variety of ORMs
-test_files: []
+test_files:
+- test/test_helper.rb
+- test/fixtures/data/active_record/after_ar.rb
+- test/fixtures/data/active_record/after_setting_ar.rb
+- test/fixtures/data/active_record/before_ar.rb
+- test/fixtures/data/active_record/before_setting_ar.rb
+- test/fixtures/data/active_record/my_subtest_ar.rb
+- test/fixtures/data/active_record/my_test_ar.rb
+- test/fixtures/data/sequel/after.rb
+- test/fixtures/data/sequel/after_setting.rb
+- test/fixtures/data/sequel/before.rb
+- test/fixtures/data/sequel/before_setting.rb
+- test/fixtures/data/sequel/my_subtest.rb
+- test/fixtures/data/sequel/my_test.rb
+- test/peacekeeper/test_loader.rb
+- test/peacekeeper/test_model.rb
+- test/peacekeeper/test_orm_model.rb
+has_rdoc:

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/Gemfile

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

data/peacekeeper.gemspec

@@ -1,24 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "peacekeeper/version"
-
-Gem::Specification.new do |s|
-  s.name        = "peacekeeper"
-  s.version     = Peacekeeper::VERSION
-  s.authors     = ["Josh Ballanco"]
-  s.email       = ["jballanc@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{Peacekeeper handles delegation to a variety of ORMs}
-  s.description = %q{Using Peacekeeper, you can develop models separately from the ORM used to persist data.}
-
-  s.rubyforge_project = "peacekeeper"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  # specify any dependencies here; for example:
-  # s.add_development_dependency "rspec"
-  # s.add_runtime_dependency "rest-client"
-end