memory_model 0.0.1

data/lib/memory_model/collection.rb

@@ -0,0 +1,80 @@
+class MemoryModel::Collection
+
+  class InvalidTypeError < StandardError;
+  end
+
+  class << self
+    attr_accessor :all
+  end
+
+  self.all = []
+
+  def initialize(model=Class.new)
+    @model   = model
+    @records = []
+    self.class.all << self
+  end
+
+  def all
+    unique.reject(&:deleted?)
+  end
+
+  def deleted
+    unique.select(&:deleted?)
+  end
+
+  def find(id, options={ })
+    version        = options[:version] || 0
+    return_deleted = !!options[:deleted]
+    record         = sorted.select { |r| r.id == id }[version]
+    return nil unless record
+    if !record.deleted? || (return_deleted && record.deleted?)
+      record
+    else
+      raise MemoryModel::RecordNotFoundError
+    end
+  end
+
+  def insert(record)
+    raise InvalidTypeError unless record.is_a? @model
+    record = record.dup
+    record.freeze unless record.frozen?
+    @records << record
+    self
+  end
+
+  alias :<< :insert
+
+  def inspect
+    self.all.inspect
+  end
+
+  def records(dup = true)
+    if dup
+      @records.map do |record|
+        record.deleted? ? record : record.dup
+      end
+    else
+      @records
+    end
+  end
+
+  private
+
+  def method_missing(m, *args, &block)
+    all.respond_to?(m) ? all.send(m, *args, &block) : super
+  end
+
+  def respond_to_missing?(m, include_private=false)
+    all.respond_to?(m, include_private)
+  end
+
+  def sorted(records=self.records)
+    records.sort { |b, a| a.timestamp <=> b.timestamp }
+  end
+
+  def unique(records=self.records)
+    sorted(records).uniq(&:id)
+  end
+
+end

data/lib/memory_model/core_ext/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def not_a?(klass)
+    !is_a?(klass)
+  end
+end

data/lib/memory_model/version.rb

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

data/lib/memory_model.rb

@@ -0,0 +1,13 @@
+require "memory_model/version"
+require "memory_model/core_ext/object"
+
+module MemoryModel
+  autoload :Collection, 'memory_model/collection'
+  autoload :Base, 'memory_model/base'
+
+  class InvalidCollectionError < StandardError ; end
+  class InvalidFieldError < StandardError ; end
+  class ReadonlyFieldError < StandardError ; end
+  class RecordNotFoundError < StandardError ; end
+
+end

data/memory_model.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memory_model/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "memory_model"
+  gem.version       = MemoryModel::VERSION
+  gem.authors       = ["Jason Waldrip"]
+  gem.email         = ["jason@waldrip.net"]
+  gem.description   = %q{An in memory, ORM, Built on top of ActiveModel. Allows for in memory models, great for rspec testing.}
+  gem.summary       = %q{An in memory, ORM}
+  gem.homepage      = "http://github.com/jwaldrip/memory_model"
+
+  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 = %w{lib}
+
+  gem.add_development_dependency 'activesupport'
+  gem.add_development_dependency 'activemodel'
+  gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'rb-fsevent'
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'terminal-notifier-guard'
+  gem.add_development_dependency 'ice_nine'
+  gem.add_development_dependency 'test-unit'
+
+end

data/spec/concerned_inheritance/class_methods_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'concerned_inheritance'
+
+describe ConcernedInheritance::ClassMethods do
+
+  let(:klass) do
+    Class.new do
+      extend ConcernedInheritance
+    end
+  end
+
+  describe '.inherited' do
+
+    context 'with a subclass' do
+      it 'should call run inherited callbacks' do
+        mock_subclass = mock
+        klass.should_receive(:run_inherited_callbacks).with(mock_subclass)
+        klass.send :inherited, mock_subclass
+      end
+    end
+
+    context 'with a block' do
+      it 'should call define_inherited_callback' do
+        block = Proc.new { }
+        klass.should_receive(:define_inherited_callback).with(&block)
+        klass.send :inherited, &block
+      end
+    end
+
+  end
+
+  describe '.inherited_callbacks' do
+    it 'should call off to its ancestors' do
+      mock_ancestor = mock
+      mock_callback      = proc { "Bar" }
+      mock_ancestor.instance_variable_set :@inherited_callbacks, [mock_callback]
+      klass.singleton_class.stub(:ancestors).and_return([mock_ancestor])
+      klass.stub(:ancestors).and_return([mock_ancestor])
+      klass.inherited_callbacks.size.should > 0
+      klass.inherited_callbacks.each do |callback|
+        callback.should == mock_callback
+      end
+    end
+  end
+
+  describe '.run_inherited_callbacks' do
+    it 'should initialize an InheritanceDelegator' do
+      mock_subclass = mock
+      mock_callback = proc { }
+      ConcernedInheritance::Delegator.should_receive(:new).with(klass, mock_subclass, mock_callback)
+      klass.send :define_inherited_callback, &mock_callback
+      klass.send :run_inherited_callbacks, mock_subclass
+    end
+  end
+
+end
+

data/spec/concerned_inheritance/delegator_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+require 'concerned_inheritance'
+
+describe ConcernedInheritance::Delegator do
+
+  let(:baseclass) { Class.new }
+  let(:subclass) { Class.new }
+
+  describe '.new' do
+    context 'given a proc with no arity' do
+      let(:callback) do
+        proc { 'foo' }
+      end
+      it "should should call a subclass' instance method" do
+        expect { ConcernedInheritance::Delegator.new(baseclass, subclass, callback) }.to_not raise_error ArgumentError
+      end
+
+      it 'should instance_eval the callback' do
+        callback = proc { foo }
+        subclass.should_receive(:foo)
+        ConcernedInheritance::Delegator.new(baseclass, subclass, callback)
+      end
+    end
+
+    context 'given a proc with arity' do
+      let(:callback) do
+        proc { |foo| foo }
+      end
+      it 'should raise an error' do
+        expect { ConcernedInheritance::Delegator.new(baseclass, subclass, callback) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when not given a proc' do
+      it 'should raise an error' do
+        expect { ConcernedInheritance::Delegator.new(baseclass, subclass, Object.new) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:callback) { proc { } }
+    it 'should call a method on the subclass' do
+      block = proc { }
+      subclass.should_receive(:foo).with('bar', 'baz', &block)
+      delegator = ConcernedInheritance::Delegator.new(baseclass, subclass, callback)
+      delegator.foo 'bar', 'baz', &block
+    end
+  end
+
+end
+

data/spec/concerned_inheritance/module_methods_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'concerned_inheritance'
+
+describe ConcernedInheritance::ModuleMethods do
+  let(:the_module) do
+    Module.new do
+      extend ConcernedInheritance
+    end
+  end
+
+  describe '.define_inherited_callback' do
+    it 'should include the callback' do
+      block = Proc.new { }
+      the_module.send :define_inherited_callback, &block
+      the_module.inherited_callbacks.should include block
+    end
+  end
+
+  describe '.inherited' do
+    it 'should call define_inherited_callback' do
+      block = Proc.new { }
+      the_module.should_receive(:define_inherited_callback).with(&block)
+      the_module.send :inherited, &block
+    end
+  end
+end
+

data/spec/memory_model/base/actionable_spec.rb

@@ -0,0 +1,359 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Actionable do
+  let(:model) do
+    Class.new(MemoryModel::Base) do
+      field :foo
+    end
+  end
+  let(:value) { 'bar' }
+  subject(:instance) { model.new(foo: value) }
+  before(:each) do
+    stub_const('MyModel', model)
+  end
+
+  describe '.create' do
+    it 'should be persisted' do
+    instance = model.create
+    instance.should be_persisted
+    end
+
+    it 'should call the save method' do
+      model.any_instance.should_receive(:save)
+      model.create
+    end
+  end
+
+  describe '.delete_all' do
+    it 'should call delete on each item' do
+      collection_mock = 10.times.map { mock }
+      model.stub(:all).and_return(collection_mock)
+      model.all.each do |instance|
+        instance.should_receive(:delete).and_return(instance)
+        instance.should_receive(:deleted?).and_return(true)
+      end
+      model.delete_all
+    end
+    it 'should return true' do
+      10.times.each { model.create }
+      model.all.should be_present
+      model.delete_all.should be_true
+    end
+  end
+
+  describe '.destroy_all' do
+    it 'should call delete on each item' do
+      collection_mock = 10.times.map { mock }
+      model.stub(:all).and_return(collection_mock)
+      model.all.each do |instance|
+        instance.should_receive(:destroy).and_return(instance)
+        instance.should_receive(:deleted?).and_return(true)
+      end
+      model.destroy_all
+    end
+    it 'should return true' do
+      10.times.each { model.create }
+      model.all.should be_present
+      model.destroy_all.should be_true
+    end
+  end
+
+  describe '#commit' do
+    it 'should save to the collection' do
+      expect { instance.commit }.to change { model.all }
+    end
+
+    it 'should always be the latest record' do
+      instance.commit
+      instance.commit.timestamp.should == model.find(instance.id).timestamp
+    end
+
+    it 'should have a timestamp' do
+      instance.commit
+      instance.timestamp.should be_present
+    end
+
+    it 'should have unfrozen attributes' do
+      instance.commit
+      instance.instance_variable_get(:@attributes).should_not be_frozen
+    end
+  end
+
+  describe '#delete' do
+    it 'should be frozen' do
+      instance.commit.delete.should be_frozen
+    end
+  end
+
+  describe '#deleted_at' do
+    context 'when deleted' do
+      it 'should have a timestamp' do
+        deleted_instance = instance.commit.delete
+        instance.deleted_at.should == deleted_instance.timestamp
+      end
+    end
+
+    context 'when not deleted' do
+      it 'should be nil' do
+        instance.commit
+        instance.deleted_at.should be_nil
+      end
+    end
+  end
+
+  describe '#destroy' do
+    it 'should call delete' do
+      instance.should_receive(:delete)
+      instance.destroy
+    end
+
+    context 'with a before_destroy callback' do
+      it 'should run the callback' do
+        model.before_destroy :test_method
+        instance.should_receive(:test_method) do
+          instance.should_receive(:delete).and_return(true)
+        end
+        instance.destroy
+      end
+
+      it 'should execution if the callback returns false' do
+        model.before_destroy :test_method
+        instance.should_receive(:test_method).and_return(false)
+        instance.should_not_receive(:delete)
+        instance.destroy
+      end
+    end
+
+    context 'with an after_destroy callback' do
+      it 'should run the callback' do
+        model.after_destroy :test_method
+        instance.should_receive(:delete) do
+          instance.should_receive(:test_method)
+        end
+        instance.destroy
+      end
+    end
+
+    context 'with an around_destroy callback' do
+      it 'should run the callback' do
+        model.around_destroy :around_test
+        model.send :define_method, :around_test do |&block|
+          test_method_a
+          block.call
+          test_method_b
+        end
+        instance.should_receive(:test_method_a) do
+          instance.should_receive(:delete) do
+            instance.should_receive(:test_method_b)
+          end
+        end
+        instance.destroy
+      end
+    end
+  end
+
+  describe '#dup' do
+    it 'should perform a deep_dup' do
+      instance.should_receive(:deep_dup)
+      instance.dup
+    end
+  end
+
+  describe '#deep_dup' do
+    it 'should not be frozen' do
+      dup = instance.freeze.deep_dup
+      instance.should be_frozen
+      dup.should_not be_frozen
+    end
+
+    it 'should return a new object' do
+      dup = instance.deep_dup
+      dup.object_id.should_not == instance.object_id
+    end
+  end
+
+  describe '#freeze' do
+    it 'should remove invalid ivars' do
+      ivar = :@foo
+      instance.instance_variable_set ivar, 'bar'
+      instance.freeze
+      instance.instance_variables.should_not include ivar
+    end
+
+    it 'should be frozen' do
+      instance.freeze
+      instance.should be_frozen
+    end
+  end
+
+  describe '#restore' do
+    it 'should not be deleted' do
+      instance.commit.delete
+      restored_instance = instance.restore
+      restored_instance.should_not be_deleted
+    end
+  end
+
+  describe '#save' do
+    it 'should call delete' do
+      instance.should_receive(:commit)
+      instance.save
+    end
+
+    context 'with a before_save callback' do
+      it 'should run the callback' do
+        model.before_save :test_method
+        instance.should_receive(:test_method) do
+          instance.should_receive(:commit).and_return(true)
+        end
+        instance.save
+      end
+
+      it 'should execution if the callback returns false' do
+        model.before_save :test_method
+        instance.should_receive(:test_method).and_return(false)
+        instance.should_not_receive(:commit)
+        instance.save
+      end
+    end
+
+    context 'with an after_save callback' do
+      it 'should run the callback' do
+        model.after_save :test_method
+        instance.should_receive(:commit) do
+          instance.should_receive(:test_method)
+        end
+        instance.save
+      end
+    end
+
+    context 'with an around_save callback' do
+      it 'should run the callback' do
+        model.around_save :around_test
+        model.send :define_method, :around_test do |&block|
+          test_method_a
+          block.call
+          test_method_b
+        end
+        instance.should_receive(:test_method_a) do
+          instance.should_receive(:commit) do
+            instance.should_receive(:test_method_b)
+          end
+        end
+        instance.save
+      end
+    end
+
+    context 'with a new record' do
+      context 'with a before_create callback' do
+        it 'should run the callback' do
+          model.before_create :test_method
+          instance.should_receive(:test_method) do
+            instance.should_receive(:commit).and_return(true)
+          end
+          instance.save
+        end
+
+        it 'should execution if the callback returns false' do
+          model.before_create :test_method
+          instance.should_receive(:test_method).and_return(false)
+          instance.should_not_receive(:commit)
+          instance.save
+        end
+      end
+
+      context 'with an after_create callback' do
+        it 'should run the callback' do
+          model.after_create :test_method
+          instance.should_receive(:commit) do
+            instance.should_receive(:test_method)
+          end
+          instance.save
+        end
+      end
+
+      context 'with an around_create callback' do
+        it 'should run the callback' do
+          model.around_create :around_test
+          model.send :define_method, :around_test do |&block|
+            test_method_a
+            block.call
+            test_method_b
+          end
+          instance.should_receive(:test_method_a) do
+            instance.should_receive(:commit) do
+              instance.should_receive(:test_method_b)
+            end
+          end
+          instance.save
+        end
+      end
+
+      context 'it should not call an update callback' do
+        it 'should run the callback' do
+          model.before_update :test_method
+          instance.should_receive(:commit)
+          instance.should_not_receive(:test_method)
+          instance.save
+        end
+      end
+    end
+
+    context 'with an existing record' do
+      before(:each) { instance.commit }
+      context 'with a before_update callback' do
+        it 'should run the callback' do
+          model.before_update :test_method
+          instance.should_receive(:test_method) do
+            instance.should_receive(:commit).and_return(true)
+          end
+          instance.save
+        end
+
+        it 'should execution if the callback returns false' do
+          model.before_update :test_method
+          instance.should_receive(:test_method).and_return(false)
+          instance.should_not_receive(:commit)
+          instance.save
+        end
+      end
+
+      context 'with an after_update callback' do
+        it 'should run the callback' do
+          model.after_update :test_method
+          instance.should_receive(:commit) do
+            instance.should_receive(:test_method)
+          end
+          instance.save
+        end
+      end
+
+      context 'with an around_update callback' do
+        it 'should run the callback' do
+          model.around_update :around_test
+          model.send :define_method, :around_test do |&block|
+            test_method_a
+            block.call
+            test_method_b
+          end
+          instance.should_receive(:test_method_a) do
+            instance.should_receive(:commit) do
+              instance.should_receive(:test_method_b)
+            end
+          end
+          instance.save
+        end
+      end
+
+      context 'it should not call an create callback' do
+        it 'should run the callback' do
+          model.before_create :test_method
+          instance.should_receive(:commit)
+          instance.should_not_receive(:test_method)
+          instance.save
+        end
+      end
+    end
+  end
+
+end