muve 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83efb234b5e0adc0d47b9d3d6263e03068a35631
-  data.tar.gz: 45802b059dcb15e55f077e6530df7268e21c3e08
+  metadata.gz: d2c799eb30443546d3054c9dfb9b04069fa8ed21
+  data.tar.gz: e47754d72235cafaaaf41e5075319e0b7aab1c84
 SHA512:
-  metadata.gz: 5fbcbd69dd00b52e288a46d6c0d61db502f9e655bb6e2437aea3ac799c4863ee2cb86ef1b029a8161697d29f81147d0746aa12b542b0c2cf0a9c4d2a40aed96d
-  data.tar.gz: b8717958986af1366ede7c2e22676c0d6aa8bd92fd94a7c89c76c99c10369775247b7bbe0474e7cfa604c714624d470e96b29ec6b0776ca526bc6fe5eabbf992
+  metadata.gz: 58c9bd11811f3b4181e8ff738963f275fffe8b36244d73a3013e0d5fdaaeef7bcdc8e1ca94d9d9f018995274e79680b6471388f0dd3d7dd556fb1f7b07eb7d55
+  data.tar.gz: abd202a42a8d6da4ebac3409657f9239f4313656028ab64cac55657e57cfd6bf2a632dc02e3453426985232a33e6d811177c3c10948c2c6c077055c4183155ad

data/lib/muve.rb

@@ -66,7 +66,7 @@ module Muve
   # connection, an adaptor will be needed to actually handle the interaction 
   # between the models and the datastore through the given connection.
   def self.init(connection=nil, database=nil)
-    Model.connection =connection
-    Model.database = database # can't automatically infer the db as this may differ among adaptors
+    Model.connection = connection if connection
+    Model.database = database if database
   end
 end

data/lib/muve/errors.rb

@@ -1,19 +1,17 @@
 module MuveError
-  class MuveStandardError < StandardError
-  end
+  class MuveStandardError < StandardError; end
 
-  class MuveSaveError < MuveStandardError
-  end
+  class MuveIncompleteImplementation < MuveStandardError; end
 
-  class MuveInvalidQuery < MuveStandardError
-  end
+  class MuveInvalidAttributes < MuveStandardError; end
 
-  class MuveInvalidAttributes < MuveStandardError
-  end
+  class MuveInvalidQuery < MuveStandardError; end
 
-  class MuveIncompleteImplementation < MuveStandardError
-  end
+  class MuveNotConfigured < MuveStandardError; end
 
-  class MuveNotConfigured < MuveStandardError
-  end
+  class MuveNotFound < MuveStandardError; end
+
+  class MuveValidationError < MuveStandardError; end
+
+  class MuveSaveError < MuveStandardError; end
 end

data/lib/muve/helpers.rb

@@ -1,6 +1,7 @@
 module Muve
   module Helper
-    def self.symbolize_keys(hash)
+    def self.symbolize_keys(hash = {})
+      raise ArgumentError.new("argument must be a Hash but was a #{hash.class} #{hash}") unless hash.kind_of? Hash
       hash.map { |k, v| { k.to_sym => v } }.inject(&:merge)
     end
   end

data/lib/muve/location.rb

@@ -2,29 +2,23 @@ module Muve
   class Location
     include Model
   
-    attr_accessor :latitude, :longitude
+    with_fields :latitude, :longitude
   
     alias_method :lat,   :latitude
     alias_method :lat=,  :latitude=
-    
+    alias_method :lon,   :longitude
+    alias_method :lon=,  :longitude=
     alias_method :lng,   :longitude
     alias_method :lng=,  :longitude=
     alias_method :long,  :longitude
     alias_method :long=, :longitude=
   
-    def initialize(latitude=nil, longitude=nil, type=:wgs84)
-      @latitude, @longitude = latitude, longitude
-    end
-  
     def valid?
+      return false unless latitude && longitude
       return false unless latitude.abs <= 90 && longitude.abs <= 180
       true
     end
   
-    def invalid?
-      !valid?
-    end
-  
     def random(center, range)
     end
   end

data/lib/muve/model.rb

@@ -33,32 +33,53 @@ module Muve
 
     # Initializes the +Muve::Model+ class. Use the +Muve::Model::init+ method 
     # to set a adaptor to take care of the retrieval and storage of resources.
-    def self.init(adaptor=nil)
-      @@adaptor = adaptor
+    def self.init(handler=nil)
+      @handler = handler if handler
     end
 
-    # Returns the adaptor set to handle retrieval and storage of resources
     def self.handler
-      @@adaptor
+      @handler
+    end
+
+    # Returns a hash of the object and subsequently
+    # containing objects that respond to #to_hash.
+    # In order to avoid circular reference hell you
+    # can set the limit.
+    #
+    # By default on the the root object and its 
+    # children a explored. Everything beyond that
+    # range is discarded.
+    def to_hash(level=0, limit=1)
+      hash = {}
+      attributes.map { |k, v|
+        if v.respond_to? :to_hash
+          (hash[k] = v.to_hash(level+1, limit)) if level < limit
+        else
+          #(raise MuveAssocError, "#Associated #{v.class} for #{k} must respond to #to_hash or be a Hash") unless v.kind_of? Hash
+          hash[k] = v
+        end
+      }
+      hash
     end
 
     # Save a resource and raises an MuveSaveError on failure
     def save!
       create_or_update
     rescue => e
+      e.backtrace.each { |err| p err }
       raise MuveSaveError, "Save failed because #{e} was raised"
     end
   
     # Save a resource
     def save
+      # TODO: be more verbose about the nature of the failure, if any
+      raise MuveValidationError, "validation failed" unless valid?
       create_or_update
-    rescue => e
-      false
     end
 
     # Destroy a resource
     def destroy
-      if adaptor.delete(self.class.container, id) == true
+      if adaptor.delete(self.class, id) == true
         @destroyed = true 
       end
     end
@@ -113,20 +134,28 @@ module Muve
       @new_record = false if details.key? :id
     end
 
+    def serialized_attributes
+      to_hash
+    end
+
     def create_or_update
-      result = new_record? ? create(attributes) : update(attributes)
+      result = new_record? ? create(serialized_attributes) : update(serialized_attributes)
       self
     end
 
     # NOTE: not sure we need this
     def attributes
-      data = {}
-      fields.select{ |k| k != invalid_attributes }.each { |k| 
-        data[k.to_sym] = self.public_send(k) 
-      }
-      data
+      self.class.extract_attributes(
+        resource: self,
+        fields: fields,
+        invalid_attributes: invalid_attributes,
+        id: self.id
+      )
     end
 
+    # A manifest of the fields known to the model. The model logic seeks 
+    # counsel from this resource to determine which properties to write and 
+    # read from the repository.
     def fields
       []
     end
@@ -134,13 +163,13 @@ module Muve
     # Creates the record and performs the necessary housekeeping (e.g.: setting
     # the new id and un-marking the new_record?
     def create(attr)
-      @id = adaptor.create(self.class.container, attr)
+      @id = adaptor.create(self.class, attr)
       @new_record = false
     end
 
     # TODO: Update the record and return the number of modified rows
     def update(attr)
-      adaptor.update(self.class.container, id, attr)
+      adaptor.update(self.class, id, attr)
     end
 
     def adaptor
@@ -149,6 +178,7 @@ module Muve
 
     # Class methods exposed to all Muve models
     module ClassMethods
+      include MuveError
       # Configure the adaptor to take care of handling persistence for this
       # model. The adaptor should extend +Muve::Store+.
       #
@@ -157,13 +187,14 @@ module Muve
       # an adaptor for another in order to support another database technology 
       # (.e.g: swithing between document databases or relational databases)
       def adaptor=(adaptor)
-        @@adaptor = adaptor
+        @adaptor = adaptor
       end
   
       # The adaptor currently set to handle persistence for all Muve::Model
       # classes and instances
       def adaptor
-        @@adaptor
+        raise MuveNotConfigured, "the adaptor has not been set" unless (@adaptor || Model.handler)
+        @adaptor or Model.handler
       end
 
       def connection
@@ -180,6 +211,18 @@ module Muve
         raise MuveError::MuveNotConfigured, "container not defined for #{self}"
       end
 
+      def extract_attributes(resource: self.new, fields: [], invalid_attributes: [], id: nil)
+        data = {}
+        fields.select{ |k| k != invalid_attributes }.each { |k| 
+          # TODO: confirm resource.respond_to? k prior to assigning
+          data[k.to_sym] = resource.public_send(k)
+        }
+        if id
+          data = data.merge(resource.class.adaptor.index_hash id)
+        end
+        data
+      end
+
       # Finds a resource by id
       def find(id)
         result = self.new()
@@ -199,6 +242,33 @@ module Muve
           end
         end
       end
+
+      # Counts the amount of records that match the parameters
+      def count(params={})
+        self.adaptor.count(self, params)
+      end
+  
+      # The +with_field+ helper allows one to declare a functioning model 
+      # with less lines of code.
+      #
+      # Instead of declaring +attr_accessor :name, :age, :hat_size+ along with
+      # the required private +#fields# method one may specify the known fields
+      # of the resource with one line of code.
+      def with_fields(*args)
+        attr_accessor *args
+        class_eval "def fields; #{args}; end"
+      end
+
+      # Creates a new resource and persists it to the datastore
+      def create(attributes)
+        resource = self.new(attributes)
+        resource.save if resource
+        resource
+      end
+
+      def destroy_all
+        warn "Destroying of all entities for a resource is not implemented"
+      end
     end
   end
 end

data/lib/muve/movement.rb

@@ -2,17 +2,13 @@ module Muve
   class Movement
     include Model
   
-    attr_accessor :traveller, :traveller_id, :location, :time
-  
-    def initialize(traveller=nil, location=nil, time=Time.now)
-      @traveller, @location, @time = traveller, location, time
-    end
+    with_fields :traveller, :location, :time
   
     def valid?
       assocs.each do |assoc|
         return false unless !assoc.nil? && assoc.valid?
       end
-      flds.each do |field|
+      fields.each do |field|
         return false unless time
       end
       true
@@ -25,11 +21,5 @@ module Muve
         @location
       ]
     end
-  
-    def flds
-      [
-        @time
-      ]
-    end
   end
 end

data/lib/muve/store.rb

@@ -73,7 +73,20 @@ module Muve
       raise MuveIncompleteImplementation, "implement a find handler for #{self}"
     end
 
+    # counts the resources matching the details, if any.
+    # Returns a integer that represents the amount of matching entities found.
+    def count(resource, details={})
+      raise MuveIncompleteImplementation, "implement a count handler for #{self}"
+    end
+
     alias_method :destroy, :delete
     alias_method :remove, :delete
+
+    # composes the id hash for the used store. Some in some cases the index
+    # is the +id+ or +_id+ field, while in other cases the index field may be
+    # different. The store should take care of index naming.
+    def index_hash(index_values)
+      {}
+    end
   end
 end

data/lib/muve/traveller.rb

@@ -1,15 +1,11 @@
 module Muve
   class Traveller
     include Model
-  
-    attr_accessor :id
-  
-    def initialize(id=nil)
-      @id = id
-    end
+
+    with_fields :name
   
     def valid?
-      !id.nil?
+      !name.nil? && !name.empty?
     end
   end
 end

data/lib/muve/version.rb

@@ -1,3 +1,3 @@
 module Muve
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/factories.rb

@@ -5,12 +5,12 @@ FactoryGirl.define do
   end
 
   factory Muve::Traveller do
-    id { SecureRandom.uuid }
+    name { Faker::Name.name }
   end
 
   factory Muve::Movement do
-    traveller { build(Muve::Traveller) }
-    #traveller_id { SecureRandom.uuid }
-    location { build(Muve::Location) }
+    traveller { build Muve::Traveller }
+    location { build Muve::Location }
+    time { Time.now - rand(500000) }
   end
 end

data/spec/location_spec.rb

@@ -4,28 +4,49 @@ describe Muve::Location do
   let(:latitude) { Faker::Geolocation.lat }
   let(:longitude) { Faker::Geolocation.lng }
 
-  subject { Muve::Location.new(latitude, longitude) }
+  subject { Muve::Location.new latitude: latitude, longitude: longitude }
   it { expect(subject.latitude).to eq(latitude) }
   it { expect(subject.longitude).to eq(longitude) }
   it { expect(subject.lat).to eq(latitude) }
   it { expect(subject.long).to eq(longitude) }
   it { expect(subject.lng).to eq(longitude) }
 
+  it { is_expected.to respond_to(:lat) }
+  it { is_expected.to respond_to(:latitude) }
+
+  it { is_expected.to respond_to(:lat=) }
+  it { is_expected.to respond_to(:latitude=) }
+
+  it { is_expected.to respond_to(:lon) }
+  it { is_expected.to respond_to(:long) }
+  it { is_expected.to respond_to(:longitude) }
+
+  it { is_expected.to respond_to(:lon=) }
+  it { is_expected.to respond_to(:long=) }
+  it { is_expected.to respond_to(:longitude=) }
+
   let(:new_latitude) { Faker::Geolocation.lat }
   let(:new_longitude) { Faker::Geolocation.lng }
-  it { expect { subject.latitude = new_latitude }.to change{subject.latitude}.to(new_latitude) }
+  # FIX: sometimes the new_* returns the same value as the already set value which fails when pulled through the change matcher
+  it { expect { subject.latitude = new_latitude }.to(change{subject.latitude}.to(new_latitude), "expected #{subject.latitude} to be #{new_latitude}") }
   it { expect { subject.lat = new_latitude }.to change{subject.latitude}.to(new_latitude) }
   it { expect { subject.longitude = new_longitude }.to change{subject.longitude}.to(new_longitude) }
   it { expect { subject.long = new_longitude }.to change{subject.longitude}.to(new_longitude) }
   it { expect { subject.lng = new_longitude }.to change{subject.longitude}.to(new_longitude) }
 
   it 'is invalid when latitude exceeds bounds' do
-    expect(Muve::Location.new(-91, longitude)).to be_invalid
-    expect(Muve::Location.new( 91, longitude)).to be_invalid
+    expect(build Muve::Location, latitude: -91).to be_invalid
+    expect(build Muve::Location, latitude:  91).to be_invalid
   end
 
   it 'is invalid when longitude exceeds bounds' do
-    expect(Muve::Location.new(latitude, -181)).to be_invalid
-    expect(Muve::Location.new(latitude,  181)).to be_invalid
+    expect(build Muve::Location, longitude: -181).to be_invalid
+    expect(build Muve::Location, longitude:  181).to be_invalid
+  end
+
+  context "validation" do
+    before(:each) { allow_any_instance_of(Muve::Location).to receive(:create_or_update).and_return(true) }
+    it { expect{build(Muve::Location, longitude: -181).save}.to raise_error }
+    it { expect{build(Muve::Location).save}.not_to raise_error }
   end
 end

data/spec/model_spec.rb

@@ -1,30 +1,163 @@
 describe 'Model' do
-  before do
+  before(:each) do
     class Resource
       include Muve::Model
-      attr_accessor :name, :version
+      with_fields :name, :version, :another
 
       def self.container
         'resources'
       end
-
-      private
-      def fields
-        [:name, :version]
-      end
     end
 
     class AnotherResource
       include Muve::Model
-      attr_accessor :name, :version, :description
+      with_fields :name, :version, :description, :age
 
       def self.container
         'other_resources'
       end
+    end
+
+    class SomeAdaptor
+      extend Muve::Store
+
+      def self.index_hash(index_value)
+        { :_id => index_value }
+      end
+    end
+
+    class AnotherAdaptor
+      extend Muve::Store
 
-      private
-      def fields
-        [:name, :version, :description]
+      def self.index_hash(index_value)
+        { :_id => index_value }
+      end
+    end
+
+    Resource.remove_instance_variable(:@handler) if Resource.instance_variable_defined?(:@handler)
+    AnotherResource.remove_instance_variable(:@handler) if AnotherResource.instance_variable_defined?(:@handler)
+
+    Muve::Model.init SomeAdaptor
+  end
+
+  context 'AnotherResource' do
+    subject { AnotherResource }
+    it { is_expected.to respond_to(:extract_attributes) }
+    it { expect(subject.send(:extract_attributes,
+      resource: subject.new(
+        name: 'Stewie Griffin',
+        version: 'our instance of the multiverse',
+        description: 'Evil baby with a lot of heart',
+        age: 1
+      ),
+      fields: subject.new.send(:fields),
+      invalid_attributes: subject.new.send(:invalid_attributes),
+      id: SecureRandom.hex
+    )).to include :name, :version, :description, :age }
+  end
+
+  context 'Resource' do
+    before(:each) {
+      Muve::Model.init(SomeAdaptor)
+    }
+
+    subject { Resource }
+    it { is_expected.to respond_to(:extract_attributes) }
+    it { expect(subject.send(:extract_attributes,
+      resource: subject.new(
+        name: 'Stewie Griffin',
+        version: 'our instance of the multiverse',
+        another: AnotherResource.new
+      ),
+      fields: subject.new.send(:fields),
+      invalid_attributes: subject.new.send(:invalid_attributes),
+      id: SecureRandom.hex
+    )).to include :name, :version, :another }
+  end
+
+  context 'Resource' do
+    subject { Resource }
+    it { is_expected.to respond_to(:extract_attributes) }
+    it { expect(subject.send(:extract_attributes,
+      resource: subject.new(
+        name: 'Stewie Griffin',
+        version: 'our instance of the multiverse',
+        another: AnotherResource.new
+      ),
+      fields: subject.new.send(:fields),
+      invalid_attributes: subject.new.send(:invalid_attributes),
+      id: SecureRandom.hex
+    )).to include(:name, :version, :another) }
+
+    it { 
+      expect(subject.new(
+      name: 'Stewie Griffin',
+      version: 'our instance of the multiverse',
+      another: subject.new(
+        name: 'Bitch Stewie',
+        version: 'failed experiment',
+        another: subject.new(
+          name: 'Bitch-Brian',
+          version: 'failed clone by failed experiment'
+        )
+      )
+    ).send(:serialized_attributes)).to eq(
+      name: 'Stewie Griffin',
+      version: 'our instance of the multiverse',
+      another: {
+        name: 'Bitch Stewie',
+        version: 'failed experiment'
+      }
+    ) }
+
+    it { expect(subject.new(
+      name: 'Stewie Griffin',
+      version: 'our instance of the multiverse',
+      another: subject.new(
+        name: 'Bitch Stewie',
+        version: 'failed experiment',
+        another: subject.new(
+          name: 'Bitch-Brian',
+          version: 'failed clone by failed experiment'
+        )
+      )
+    ).send(:serialized_attributes)).to eq(
+      name: 'Stewie Griffin',
+      version: 'our instance of the multiverse',
+      another: {
+        name: 'Bitch Stewie',
+        version: 'failed experiment'
+      }
+    ) }
+  end
+
+  context "instantiated AnotherResource" do
+    subject { AnotherResource.new }
+    it { is_expected.to respond_to(:description) }
+    it { is_expected.to respond_to(:name) }
+    it { is_expected.to respond_to(:to_hash) }
+    it { is_expected.to respond_to(:version) }
+    it { is_expected.to respond_to(:valid?) }
+    it { expect(subject.send(:fields)).to include :name, :version, :description, :age }
+    it { expect(subject.send(:attributes)).to include :name, :version, :description, :age }
+
+    context "populating" do
+      context "with nothing" do
+        before { subject.send(:populate, {}) }
+        it { expect(subject.name).to eq(nil) }
+      end
+  
+      context "with unknown fields" do
+        before { subject.send(:populate, { name: 'Jack Sparrow', occupation: 'pirate' }) }
+        it { expect(subject.name).to eq('Jack Sparrow') }
+        it { expect{ subject.occupation }.to raise_error }
+      end
+  
+      context "with known fields" do
+        before { subject.send(:populate, { name: 'Peter Griffin', description: 'Surfin-bird lover', version: 'the fat one' }) }
+        it { expect(subject.name).to eq('Peter Griffin') }
+        it { expect(subject.description).to eq('Surfin-bird lover') }
+        it { expect(subject.version).to eq('the fat one') }
       end
     end
   end
@@ -36,18 +169,21 @@ describe 'Model' do
   end
 
   it 'raises a not configured exception when connection is not set' do
-    skip # TODO: get rid of Singleton-like pattern?
-    expect {
-      Muve::Model.connection
-    }.to raise_error(MuveError::MuveNotConfigured)
-
-    expect {
-      Resource.connection
-    }.to raise_error(MuveError::MuveNotConfigured)
-
-    expect {
-      AnotherResource.connection
-    }.to raise_error(MuveError::MuveNotConfigured)
+    configuration_error = MuveError::MuveNotConfigured
+    Muve::Model.remove_class_variable(:@@conn) if Muve::Model.class_variable_defined?(:@@conn)
+
+    expect { Muve::Model.connection }.to raise_error(configuration_error)
+    expect { Resource.connection }.to raise_error(configuration_error) 
+    expect { AnotherResource.connection }.to raise_error(configuration_error)
+  end
+
+  it 'raises a not configured exception when database is not set' do
+    configuration_error = MuveError::MuveNotConfigured
+    Muve::Model.remove_class_variable(:@@db) if Muve::Model.class_variable_defined?(:@@db)
+
+    expect { Muve::Model.database }.to raise_error(configuration_error)
+    expect { Resource.database }.to raise_error(configuration_error) 
+    expect { AnotherResource.database }.to raise_error(configuration_error)
   end
 
   it 'knows the identifier of its repository' do
@@ -56,16 +192,22 @@ describe 'Model' do
   end
 
   it 'allows the setting of the adaptor' do
-    adaptor = Object.new
-    Resource.adaptor = adaptor
-    expect(Resource.adaptor).to be(adaptor)
+    Resource.adaptor = SomeAdaptor
+    expect(Resource.adaptor).to be(SomeAdaptor)
+  end
+
+  it 'allows different adaptors for different resources' do
+    Resource.adaptor = SomeAdaptor
+    AnotherResource.adaptor = AnotherAdaptor
+
+    expect(Resource.adaptor).to be(SomeAdaptor)
+    expect(AnotherResource.adaptor).to be(AnotherAdaptor)
   end
 
   it 'allows the setting of the adaptor through init' do
-    adaptor = Object.new
-    Muve::Model.init(adaptor = adaptor)
-    expect(Muve::Model::handler).to be(adaptor)
-    expect(Muve::Model.handler).to be(adaptor)
+    Muve::Model.init(adaptor = SomeAdaptor)
+    expect(Resource::adaptor).to be(SomeAdaptor)
+    expect(Resource.adaptor).to be(SomeAdaptor)
   end
 
   it 'sets the attributes of the resource at initialization' do
@@ -82,11 +224,31 @@ describe 'Model' do
   # TODO: Study if this is desirable perhaps one would rather prefer setting
   # seperate adaptors for different models
   it 'shares the adaptor amongst all its instances' do
-    generic_adaptor = Object.new
-    Resource.adaptor = generic_adaptor
+    Resource.remove_instance_variable(:@adaptor) if Resource.instance_variable_defined?(:@adaptor)
+    AnotherResource.remove_instance_variable(:@adaptor) if AnotherResource.instance_variable_defined?(:@adaptor)
+
+    Muve::Model.init(SomeAdaptor)
+    expect(Muve::Model.send(:handler)).to be(SomeAdaptor)
+    expect(Resource.new.send(:adaptor)).to be(SomeAdaptor)
+    expect(AnotherResource.new.send(:adaptor)).to be(SomeAdaptor)
+
+    Muve::Model.init(AnotherAdaptor)
+    expect(Muve::Model.send(:handler)).to be(AnotherAdaptor)
+    expect(Resource.new.send(:adaptor)).to be(AnotherAdaptor)
+    expect(AnotherResource.new.send(:adaptor)).to be(AnotherAdaptor)
+  end
 
-    expect(Resource.new.send(:adaptor)).to be(generic_adaptor)
-    expect(AnotherResource.new.send(:adaptor)).to be(generic_adaptor)
+  it 'allows different adaptors for different entities' do
+    Resource.remove_instance_variable(:@adaptor) if Resource.instance_variable_defined?(:@adaptor)
+    AnotherResource.remove_instance_variable(:@adaptor) if AnotherResource.instance_variable_defined?(:@adaptor)
+    
+    a = SomeAdaptor
+    b = AnotherAdaptor
+
+    Muve::Model.init(a)
+    Resource.adaptor = b
+    expect(Resource.new.send(:adaptor)).to be(b)
+    expect(AnotherResource.new.send(:adaptor)).to be(a)
   end
 
   describe 'equiped with an adaptor' do
@@ -105,13 +267,42 @@ describe 'Model' do
 
       class GenericAdaptor
         extend Muve::Store
+
+        def self.index_hash(index_value)
+          hash = { :_id => index_value }
+          { :_id => index_value }
+        end
       end
 
       Resource.adaptor = GenericAdaptor
+      AnotherResource.adaptor = GenericAdaptor # FIX: allow setting system-wide adaptor?
 
       @res = Resource.new
     end
 
+    shared_examples "an ActiveRecord-like class" do
+      it { is_expected.to respond_to(:create) }
+      it { is_expected.to respond_to(:destroy_all) }
+      it { is_expected.to respond_to(:find) }
+    end
+
+    shared_examples "an ActiveRecord-like resource" do
+      it { is_expected.to respond_to(:save) }
+      it { is_expected.to respond_to(:destroy) }
+      it { is_expected.to respond_to(:new_record?) }
+      it { is_expected.to respond_to(:destroyed?) }
+    end
+  
+    context "the class" do
+      subject { Resource }
+      it_behaves_like "an ActiveRecord-like class"
+    end
+
+    context "a instance" do
+      subject { @res }
+      it_behaves_like "an ActiveRecord-like resource"
+    end
+
     it 'calls the store create handler upon save' do
       expect(GenericAdaptor).to receive(:create).once
       @res.save
@@ -167,6 +358,28 @@ describe 'Model' do
       end
     end
 
+    describe '::create' do
+      before(:each) do
+        allow(GenericAdaptor).to receive(:create).and_return(@id = SecureRandom.hex)
+      end
+
+      it 'creates a new instance' do
+        attributes = { name: 'Bonobo' }
+        expect(Resource).to receive(:new).with(attributes).once
+        Resource.create(attributes)
+      end
+
+      it 'calls the save handler' do
+        expect_any_instance_of(Resource).to receive(:save).once
+        Resource.create(name: 'Nice')
+      end
+
+      it 'has the set attributes' do
+        resource = Resource.create(name: 'Monaco')
+        expect(resource.name).to eq('Monaco')
+      end
+    end
+
     describe '#save' do
       before(:each) do
         @res.name = 'first'
@@ -232,7 +445,7 @@ describe 'Model' do
       end
   
       it 'calls the delete handler with the proper details' do
-        expect(GenericAdaptor).to receive(:delete).with('other_resources', @id).once
+        expect(GenericAdaptor).to receive(:delete).with(AnotherResource, @id).once
         @res.destroy
       end
     end
@@ -255,5 +468,53 @@ describe 'Model' do
       expect(GenericAdaptor).to receive(:fetch).with(Resource, id, anything)
       Resource.find(id)
     end
+
+    it 'converts the attributes to saveable objects' do
+      expect(Resource.new(
+        name: 'Peter Griffin',
+        version: 'dumbass',
+        another: AnotherResource.new(
+          name: 'Brian Griffin',
+          version: 'the pretentious one',
+          description: 'Canine, liberal, writer',
+          age: 8
+        )
+      ).send(:to_hash)).to eq(
+        name: 'Peter Griffin',
+        version: 'dumbass',
+        another: {
+          name: 'Brian Griffin',
+          version: 'the pretentious one',
+          description: 'Canine, liberal, writer',
+          age: 8
+        }
+      )
+    end
+
+    it 'converts the attributes to saveable objects' do
+      another = AnotherResource.new
+      another.send :populate, {
+        id: SecureRandom.hex,
+        name: 'Brian Griffin',
+        version: 'the pretentious one',
+        description: 'Canine, liberal, writer',
+        age: 8
+      }
+      expect(Resource.new(
+        name: 'Peter Griffin', 
+        version: 'dumbass', 
+        another: another
+      ).send(:to_hash)).to eq(
+        name: 'Peter Griffin',
+        version: 'dumbass',
+        another: {
+          _id: another.id,
+          name: 'Brian Griffin',
+          version: 'the pretentious one',
+          description: 'Canine, liberal, writer',
+          age: 8
+        }
+      )
+    end
   end
 end

data/spec/movement_spec.rb

@@ -28,7 +28,7 @@ describe Muve::Movement do
   end
 
   context "new movement" do
-    subject { build(Muve::Movement) }
+    subject { build(Muve::Movement, time: Time.now) }
     it { expect(subject.time).to be_within(2).of(Time.now) }
     it { is_expected.to be_valid }
   end

data/spec/store_spec.rb

@@ -2,6 +2,7 @@ describe Muve::Store do
   before do
     class Resource
       include Muve::Model
+      with_fields :name
 
       def self.container
         'resources'

data/spec/traveller_spec.rb

@@ -1,13 +1,22 @@
 require 'spec_helper'
 
 describe Muve::Traveller do
-  subject { Muve::Traveller.new }
+  subject { build Muve::Traveller }
 
   it { is_expected.to respond_to(:id) }
-  it { is_expected.to be_invalid }
+  it { is_expected.to be_valid }
 
   context "linked to an existing traveller" do
-    subject { Muve::Traveller.new(SecureRandom.uuid) }
+    subject { 
+      res = build Muve::Traveller
+      res.send(:populate, ({ id: SecureRandom.uuid })) 
+      res
+    }
+
     it { is_expected.to be_valid }
   end
+
+  it 'is invalid if the traveller is nameless' do
+    expect(build Muve::Traveller, name: nil).to be_invalid
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: muve
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - David Asabina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-06 00:00:00.000000000 Z
+date: 2014-08-26 00:00:00.000000000 Z
 dependencies: []
 description: Basic helpers to be used with Muvement
 email: