memory_model 0.0.1

data/spec/memory_model/base/attributable_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Attributable do
+
+  let(:model) do
+    Class.new(MemoryModel::Base) do
+      field :foo
+      field :bar
+    end
+  end
+  let(:instance) do
+    model.new
+  end
+
+  describe '#any_field_name' do
+    it 'should read an attribute' do
+      instance.write_attribute :foo, "bar"
+      instance.foo.should == "bar"
+    end
+  end
+
+  describe '#any_field_name=' do
+    it 'should read an attribute' do
+      instance.foo= "bar"
+      instance.read_attribute(:foo).should == "bar"
+    end
+  end
+
+  describe '#has_attribute?' do
+    context 'given nil' do
+      it 'should be false' do
+        instance.foo = nil
+        instance.has_attribute?(:foo).should be_false
+      end
+    end
+
+    context 'given an empty string' do
+      it 'should be true' do
+        instance.foo = ''
+        instance.has_attribute?(:foo).should be_true
+      end
+    end
+
+    context 'given a Hash' do
+      it 'should be true' do
+        instance.foo = { foo: :bar }
+        instance.has_attribute?(:foo).should be_true
+      end
+    end
+
+    context 'given an emtpy Hash' do
+      it 'should be true' do
+        instance.foo = {}
+        instance.has_attribute?(:foo).should be_false
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it 'inspect into a readable format' do
+      instance.inspect.should match /#<#{instance.class}/
+    end
+
+    it 'should contain the attributes' do
+      instance.attributes.each do |name, value|
+        value = instance.send :attribute_for_inspect, name
+        instance.inspect.should include "#{name}: #{value}" if instance.has_attribute? name
+      end
+    end
+
+    it 'should read not initialized' do
+      model.allocate.inspect.should match /not initialized/
+    end
+  end
+
+  describe '#read_attribute' do
+    it 'should return a value' do
+      instance.write_attribute(:foo, "bar")
+      instance.read_attribute(:foo).should == 'bar'
+    end
+
+    it "should return nil if the key doesn't exist" do
+      instance.read_attribute(:bar).should be_nil
+    end
+  end
+
+  describe '#write_attribute' do
+    it 'should raise an error with an invalid field' do
+      expect { instance.write_attribute(:baz, 'razzle') }.to raise_error MemoryModel::InvalidFieldError
+    end
+  end
+
+  describe '#attribute_for_inspect' do
+    it 'truncates values over 50 chars' do
+      value = instance.foo = 'barbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbarbar'
+      instance.send(:attribute_for_inspect, :foo).should_not == value.inspect
+    end
+
+    it 'should convert a time to string' do
+      instance.foo = Time.now
+      instance.send(:attribute_for_inspect, :foo).should be_a String
+    end
+
+    it 'should convert a date to string' do
+      instance.foo = Date.today
+      instance.send(:attribute_for_inspect, :foo).should be_a String
+    end
+
+    it 'inspects objects' do
+      value = instance.foo = 'bar'
+      instance.send(:attribute_for_inspect, :foo).should == value.inspect
+    end
+  end
+
+  describe '#reset_attribute_to_default' do
+    let(:model) do
+      Class.new(MemoryModel::Base) do
+        field :foo, default: 'bar'
+      end
+    end
+    it 'should reset an attribute to its default value' do
+      instance.foo = 'baz'
+      instance.foo.should == 'baz'
+      instance.reset_foo_to_default!
+      instance.foo.should == 'bar'
+    end
+  end
+
+  describe '#clear_attribute' do
+    let(:model) do
+      Class.new(MemoryModel::Base) do
+        field :foo
+      end
+    end
+    it 'should reset an attribute to its default value' do
+      instance.foo = 'baz'
+      instance.foo.should == 'baz'
+      instance.clear_foo
+      instance.foo.should be_nil
+    end
+  end
+
+end

data/spec/memory_model/base/collectable_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Collectable do
+
+  let(:model) do
+    Class.new(MemoryModel::Base) do
+      field :foo
+      field :bar
+    end
+  end
+
+  describe '.collection' do
+    it 'should be a collection' do
+      model.collection.should be_a MemoryModel::Collection
+    end
+  end
+
+  describe '.inherited' do
+    it 'should use its parents collection' do
+      Class.new(model).collection.should == model.collection
+    end
+  end
+
+end

data/spec/memory_model/base/comparable_spec.rb

@@ -0,0 +1,155 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Comparable do
+  let(:model) do
+    Class.new(MemoryModel::Base) do
+      field :foo
+    end
+  end
+  let(:value) { 'bar' }
+  subject(:instance) { model.new(foo: value) }
+
+  describe '#!=' do
+    context 'given a symbolized hash' do
+      let(:valid_hash) { { 'foo' => value } }
+      let(:invalid_hash) { { 'foo' => 'baz' } }
+      it 'should return true when given a valid hash' do
+        (instance != valid_hash).should be_false
+      end
+
+      it 'should return false when given a invalid hash' do
+        (instance != invalid_hash).should be_true
+      end
+    end
+
+    context 'given a symbolized hash' do
+      let(:valid_hash) { { foo: value } }
+      let(:invalid_hash) { { foo: 'baz' } }
+      it 'should return true when given a valid hash' do
+        (instance != valid_hash).should be_false
+      end
+
+      it 'should return false when given a invalid hash' do
+        (instance != invalid_hash).should be_true
+      end
+    end
+
+    context 'given an instance of the same class' do
+      let(:valid_instance) { model.new(foo: value) }
+      let(:invalid_instance) { model.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance != valid_instance).should be_false
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance != invalid_instance).should be_true
+      end
+    end
+
+    context 'given an instance of a different class' do
+      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:valid_instance) { other_class.new(foo: value) }
+      let(:invalid_instance) { other_class.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance != valid_instance).should be_false
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance != invalid_instance).should be_true
+      end
+    end
+  end
+
+  describe '#==' do
+    context 'given a symbolized hash' do
+      let(:valid_hash) { { 'foo' => value } }
+      let(:invalid_hash) { { 'foo' => 'baz' } }
+      it 'should return true when given a valid hash' do
+        (instance == valid_hash).should be_true
+      end
+
+      it 'should return false when given a invalid hash' do
+        (instance == invalid_hash).should be_false
+      end
+    end
+
+    context 'given a symbolized hash' do
+      let(:valid_hash) { { foo: value } }
+      let(:invalid_hash) { { foo: 'baz' } }
+      it 'should return true when given a valid hash' do
+        (instance == valid_hash).should be_true
+      end
+
+      it 'should return false when given a invalid hash' do
+        (instance == invalid_hash).should be_false
+      end
+    end
+
+    context 'given an instance of the same class' do
+      let(:valid_instance) { model.new(foo: value) }
+      let(:invalid_instance) { model.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance == valid_instance).should be_true
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance == invalid_instance).should be_false
+      end
+    end
+
+    context 'given an instance of a different class' do
+      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:valid_instance) { other_class.new(foo: value) }
+      let(:invalid_instance) { other_class.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance == valid_instance).should be_true
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance == invalid_instance).should be_false
+      end
+    end
+  end
+
+  describe '#===' do
+    context 'given a hash' do
+      it 'should return false' do
+        hash = { foo: value }
+        (instance === hash).should be_false
+      end
+    end
+
+    context 'given an instance of the same class' do
+      let(:valid_instance) { model.new(foo: value) }
+      let(:invalid_instance) { model.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance === valid_instance).should be_true
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance === invalid_instance).should be_false
+      end
+    end
+
+    context 'given an instance of an inherited class' do
+      let(:inherited_model) { Class.new(model) }
+      let(:valid_instance) { inherited_model.new(foo: value) }
+      let(:invalid_instance) { inherited_model.new(foo: 'baz') }
+      it 'should be true when given a valid instance' do
+        (instance === valid_instance).should be_true
+      end
+
+      it 'should be false when given a invalid instance' do
+        (instance === invalid_instance).should be_false
+      end
+    end
+
+    context 'given an instance of a different class' do
+      let(:other_class) { Class.new(MemoryModel::Base) }
+      let(:other_instance) { other_class.new(foo: value) }
+      it 'should be false' do
+        (instance === other_instance).should be_false
+      end
+    end
+  end
+end

data/spec/memory_model/base/fieldable/field_set_spec.rb

@@ -0,0 +1,160 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Fieldable::FieldSet do
+
+  let(:klass) { MemoryModel::Base::Fieldable::FieldSet }
+  subject(:field_set) { klass.new }
+
+  describe '.new' do
+    it "should have an empty array of fields" do
+      field_set.instance_variable_get(:@fields).should be_a Array
+      field_set.size.should == 0
+    end
+  end
+
+  describe '#[]' do
+    it "should return a field" do
+      field_set.add(:foo)
+      field_set[:foo].should be_present
+      field_set[:foo].name.should == :foo
+    end
+  end
+
+  describe '#<<' do
+    it 'should add a field with the symbol' do
+      expect { field_set << :foo }.to change { field_set.fields }
+    end
+  end
+
+  describe '#add' do
+    it "should add a field" do
+      expect { field_set.add(:foo) }.to change { field_set.fields }
+    end
+
+    it "should add a field with options" do
+      options = { foo: :bar }
+      expect { field_set.add(:foo, options) }.to change { field_set.fields }
+      field_set[:foo].options[:foo].should == :bar
+    end
+  end
+
+  describe '#comparable' do
+    it 'should only return comparable fields' do
+      field_set.add(:foo, comparable: true)
+      field_set.add(:bar, comparable: false)
+      field_set.comparable.each do |field|
+        field_set[field].should be_comparable
+      end
+    end
+  end
+
+  describe '#inspect' do
+    it 'should delegate inspect to #to_a' do
+      names_mock = mock
+      names_mock.should_receive(:inspect)
+      field_set.stub(:to_a).and_return(names_mock)
+      field_set.inspect
+    end
+  end
+
+  describe '#default_values' do
+    let(:mock_model) { mock }
+
+    context 'with a symbol' do
+      it 'should call the method on the model' do
+        mock_model.should_receive :foo_val
+        field_set.add :foo, default: :foo_val
+        field_set.default_values(mock_model)
+      end
+    end
+
+    context 'with a string' do
+      it 'should set the string' do
+        field_set.add :foo, default: 'foo_val'
+        defaults = field_set.default_values(mock_model)
+        defaults[:foo].should == 'foo_val'
+      end
+    end
+
+    context 'with a lambda with an arity of 0' do
+      it 'should evaluate the block' do
+        field_set.add :foo, default: -> { 5 + 5 }
+        field_set.default_values(mock_model)[:foo].should == 10
+      end
+    end
+
+    context 'with a lambda with an arity of 1' do
+      it 'should evaluate the block' do
+        mock_model.should_receive :foo_val
+        field_set.add :foo, default: ->(model) { model.foo_val }
+        field_set.default_values(mock_model)
+      end
+    end
+
+    context 'with a lambda with an arity of 2' do
+      it 'should raise an error' do
+        field_set.add :foo, default: ->(model, other_var) { nil }
+        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'with a proc with an arity of 0' do
+      it 'should evaluate the block' do
+        mock_model.should_receive :foo_val
+        field_set.add :foo, default: proc { foo_val }
+        field_set.default_values(mock_model)
+      end
+    end
+
+    context 'with a proc with an arity of 1' do
+      it 'should evaluate the block' do
+        mock_model.should_receive :foo_val
+        field_set.add :foo, default: proc { |model| model.foo_val }
+        field_set.default_values(mock_model)
+      end
+    end
+
+    context 'with a proc with an arity of 2' do
+      it 'should raise an error' do
+        field_set.add :foo, default: proc { |model, other_var| model.foo_val }
+        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'with a nil value' do
+      it 'should return nil' do
+        field_set.add :foo
+        field_set.default_values(mock_model)[:foo].should be_nil
+      end
+    end
+
+    context 'when an invalid object' do
+      it 'should raise an error' do
+        field_set.add :foo, default: Object.new
+        expect { field_set.default_values(mock_model) }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#to_a' do
+    it 'should return a list of names' do
+      field_set.add(:foo, comparable: true)
+      field_set.add(:bar, comparable: false)
+      field_set.to_a.should include :foo, :bar
+    end
+  end
+
+  describe '#method_missing' do
+    it 'should delegate off to #to_a' do
+      mock_array = mock
+      mock_array.should_receive :fubar
+      field_set.stub(:to_a).and_return(mock_array)
+      field_set.fubar
+    end
+
+    it 'should raise an error' do
+      expect { field_set.fubar }.to raise_error NoMethodError
+    end
+  end
+
+end

data/spec/memory_model/base/fieldable/field_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Fieldable::Field do
+
+  subject(:field) { MemoryModel::Base::Fieldable::Field.new(:foo) }
+
+  describe '.new' do
+    it 'should not raise an error' do
+      expect { MemoryModel::Base::Fieldable::Field.new(:foo) }.to_not raise_error
+    end
+
+    it 'should have default options' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo)
+      field.options.should be_present
+    end
+
+    it 'should set_options' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, bar: :baz)
+      field.options[:bar].should == :baz
+    end
+  end
+
+  describe '#==' do
+    context 'given a field' do
+      it 'should be equal to an object with the same name' do
+        field_a = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
+        field_b = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: false)
+        (field_a == field_b).should be_true
+      end
+
+      it 'should not be equal to an object with a different name' do
+        field_a = MemoryModel::Base::Fieldable::Field.new(:foo)
+        field_b = MemoryModel::Base::Fieldable::Field.new(:bar)
+        (field_a == field_b).should be_false
+      end
+    end
+
+    context 'given a symbol' do
+      it 'should be equal to an object with the same name' do
+        field_a = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
+        field_b = :foo
+        (field_a == field_b).should be_true
+      end
+
+      it 'should not be equal to an object with a different name' do
+        field_a = MemoryModel::Base::Fieldable::Field.new(:foo)
+        field_b = :bar
+        (field_a == field_b).should be_false
+      end
+    end
+  end
+
+  describe '#comparable?' do
+    it 'should return true' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: true)
+      field.comparable?.should be_true
+    end
+
+    it 'should return false' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, comparable: false)
+      field.comparable?.should be_false
+    end
+  end
+
+  describe '#default' do
+    it 'should return the default value' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, default: 'foo')
+      field.default.should == 'foo'
+    end
+  end
+
+  describe '#readonly?' do
+    it 'should return true' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, readonly: true)
+      field.readonly?.should be_true
+    end
+
+    it 'should return false' do
+      field = MemoryModel::Base::Fieldable::Field.new(:foo, readonly: false)
+      field.readonly?.should be_false
+    end
+  end
+
+  describe '#to_sym' do
+    it 'should be the symbolized name' do
+      field.to_sym.should == :foo
+    end
+  end
+
+  describe '#to_s' do
+    it 'should be the symbolized name' do
+      field.to_s.should == 'foo'
+    end
+  end
+
+end

data/spec/memory_model/base/fieldable_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Fieldable do
+
+  let(:model_a) { Class.new(MemoryModel::Base) }
+  let(:model_b) { Class.new(MemoryModel::Base) }
+
+  describe '.field' do
+    it 'should add a field to fields' do
+      field = :foo
+      model_a.send :field, field
+      model_a.fields.should include field
+    end
+
+    it 'should not dirty other classes' do
+      field = :bar
+      model_a.send :field, field
+      model_a.fields.should include field
+      model_b.fields.should_not include field
+    end
+  end
+
+end

data/spec/memory_model/base/persistence_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Persistence 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 '#persisted?' do
+    it 'should be true if persisted' do
+      instance.commit
+      instance.persisted?.should be_true
+    end
+
+    it 'should be false if not persisted' do
+      instance.persisted?.should be_false
+    end
+  end
+
+  describe '#new_record?' do
+    it 'should be true unless persisted' do
+      instance.commit
+      instance.new_record?.should be_false
+    end
+
+    it 'should be false unless not persisted' do
+      instance.new_record?.should be_true
+    end
+  end
+
+end

data/spec/memory_model/base/versionable_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe MemoryModel::Base::Versionable do
+
+  let(:model) do
+    Class.new(MemoryModel::Base)
+  end
+  let(:instance) do
+    model.new
+  end
+  before(:each) do
+    stub_const('MyModel', model)
+  end
+
+  describe '#versions' do
+    it 'should have a number of versions' do
+      10.times.each do |index|
+        instance.versions.size.should == index
+        instance.commit
+      end
+    end
+  end
+
+  describe '#version' do
+    it 'should be the latest version' do
+      3.times.each { instance.commit }
+      instance.version.should == instance.versions.keys.last
+    end
+  end
+
+end