muve 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e64ab439f78e810ebff042a097baf5b95eaba0ac
-  data.tar.gz: 1911f6965e437dab3fe5630b16e7594a09395738
+  metadata.gz: 07fd84a42ff9d48763eb97e0991f3b29c1922a5a
+  data.tar.gz: bae3ee756eb66eff4539fed0fcd717ca1bde469a
 SHA512:
-  metadata.gz: f4f53bcfb178526d45860ff5bc19f1654532dddde18f67677816982031f41b03505237f1271e505bfcbac558329caf814418dc3a0a042d76efa913106a2dbeeb
-  data.tar.gz: 9e5efb1a4511f3f008af45abdc9724474e72329a2f312436b07d2d649654688f0fa5abdec664241dd59c08bed80621e6f00cc3ec6d78867bb8a63ef3c6835874
+  metadata.gz: c864989ed5a970291c4a794e503553def1dcf813c92d7d8700858434a8170e51c3183cbd9ad0e0fa43651299e6f77a4887e74948bc04704a10140af0c1bbb0f4
+  data.tar.gz: 0bb9e70a4e32a2ae7c44d07689b433f67074353cf508201cc16f45b1c9aec7861cf785c54fa61ccd6e8fb7f6f094bea11d9e96100e0f8a3b261213c5a6247b10

data/.gitignore

@@ -11,6 +11,7 @@ InstalledFiles
 _yardoc
 coverage
 doc/
+html/
 lib/bundler/man
 pkg
 rdoc

data/Gemfile

@@ -1,4 +1,14 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in muve.gemspec
 gemspec
+
+gem "rake", "~> 10.3.2"
+gem "bundler", "~> 1.6"
+
+group :test do
+  gem "mongo", "~> 1.10.2"
+  gem "bson_ext"
+  gem "ffaker", "~> 1.24.0"
+  gem "factory_girl", "~> 4.0.0"
+  gem "rspec", "~> 3.0.0"
+end

data/Rakefile

@@ -1,9 +1,15 @@
 require "rspec/core/rake_task"
 require "rake/testtask"
 require "bundler/gem_tasks"
+require "rdoc/task"
 
 RSpec::Core::RakeTask.new('spec') do |t|
   t.verbose = false
 end
 
+RDoc::Task.new do |rdoc|
+  rdoc.main = "README.rdoc"
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
 task default: :spec

data/lib/muve/errors.rb

@@ -1,7 +1,19 @@
 module MuveError
-  class MuveError < StandardError
+  class MuveStandardError < StandardError
   end
 
-  class MuveSaveError < MuveError
+  class MuveSaveError < MuveStandardError
+  end
+
+  class MuveInvalidQuery < MuveStandardError
+  end
+
+  class MuveInvalidAttributes < MuveStandardError
+  end
+
+  class MuveIncompleteImplementation < MuveStandardError
+  end
+
+  class MuveNotConfigured < MuveStandardError
   end
 end

data/lib/muve/helpers.rb

@@ -0,0 +1,7 @@
+module Muve
+  module Helper
+    def self.symbolize_keys(hash)
+      hash.map { |k, v| { k.to_sym => v } }.inject(&:merge)
+    end
+  end
+end

data/lib/muve/model.rb

@@ -1,40 +1,204 @@
 module Muve
+  # Muve models imitate some behavior that one may commonly expect of typical
+  # models. There are mechanisms in place for creation, modification, retrieval 
+  # and the removal of resources.
+  #
+  # In order to make this a flexible solution, models never take care of 
+  # handling the persisting of the resources they manange. That part of the 
+  # lifing is dispatched to the +Model::Store+ object which may be though of 
+  # as an adaptor.
+  #
+  # --
+  # TODO: Include ActiveRecord::Model instead of using this tedious
+  # implementation
+  # ++
   module Model
     include MuveError
-  
-    def initialize
+    include Muve::Helper
+    
+    def initialize(params={})
+      params = {} unless params
+      params.each do |attr, value|
+        next if invalid_attributes.include? attr.to_s
+        self.public_send "#{attr}=", value
+      end
+
       @new_record = true
+      @destroyed = false
     end
-  
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # 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
+    end
+
+    # Returns the adaptor set to handle retrieval and storage of resources
+    def self.handler
+      @@adaptor
+    end
+
+    # Save a resource and raises an MuveSaveError on failure
     def save!
-      create_or_update || raise(MuveSaveError)
+      create_or_update
+    rescue => e
+      raise MuveSaveError, "Save failed because #{e} was raised"
     end
   
+    # Save a resource
     def save
       create_or_update
+    rescue => e
+      false
     end
-  
-    def create
-    end
-  
-    def update
+
+    # Destroy a resource
+    def destroy
+      if adaptor.delete(container, id) == true
+        @destroyed = true 
+      end
     end
-  
+
+    # Returns true if the resource has recently been instantiated but not yet
+    # written to the data store.
     def new_record?
-      @new_record ||= true
+      @new_record = true if @new_record.nil?
+      @new_record
+    end
+
+    # Returns true if the resource is not newly instantiated or recently 
+    # destroyed.
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    # Returns true if the resource in question has been destroyed
+    def destroyed?
+      @destroyed
     end
   
+    # Returns a true if the resource passes all validations
     def valid?
       false
     end
   
+    # Returns true if the resource fails any validation
     def invalid?
       !valid?
     end
+
+    def id
+      @id
+    end
   
     private
+    def invalid_attributes
+      %w(id adaptor)
+    end
+
+    def populate(details)
+      details = {} unless details
+
+      @id = details[:id] if details.key? :id
+
+      details.each do |attr, value|
+        next if invalid_attributes.include? attr.to_s
+        self.public_send "#{attr}=", value
+      end
+
+      @new_record = false if details.key? :id
+    end
+
     def create_or_update
-      result = new_record? ? create : update
+      result = new_record? ? create(attributes) : update(attributes)
+      self
+    end
+
+    # NOTE: not sure we need this
+    def attributes
+      data = {}
+      fields.each { |k| data[k.to_sym] = self.public_send(k) }
+      data
+    end
+
+    # 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(container, attr)
+      @new_record = false
+    end
+
+    # TODO: Update the record and return the number of modified rows
+    def update(attr)
+      adaptor.update(container, id, attr)
+    end
+
+    def adaptor
+      self.class.adaptor
+    end
+
+    def container
+    end
+
+    def details
+    end
+
+    # Class methods exposed to all Muve models
+    module ClassMethods
+      # Configure the adaptor to take care of handling persistence for this
+      # model. The adaptor should extend +Muve::Store+.
+      #
+      # Adaptors provide an abstraction layer between Muve models and the actual 
+      # datastore. This provides some flexibility in design as one may exchange
+      # 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
+      end
+  
+      # The adaptor currently set to handle persistence for all Muve::Model
+      # classes and instances
+      def adaptor
+        @@adaptor
+      end
+
+      def connection
+        Muve::Model.connection
+      end
+
+      def database
+        Muve::Model.database
+      end
+  
+      # The container (e.g.: collection, tablename or anything that is analogous
+      # to this construct) of the resource
+      def container
+        raise MuveError::MuveNotConfigured, "container not defined for #{self}"
+      end
+
+      # Finds a resource by id
+      def find(id)
+        result = self.new()
+        result.send(:populate, self.adaptor.get(self, id))
+        result
+      end
+
+      # Querries the resource repository for all resources that match the
+      # specified parameters.
+      def where(params)
+        Enumerator.new do |item|
+          (self.adaptor.get(self, nil, params) or []).each do |details|
+            details
+            result = self.new()
+            result.send(:populate, details)
+            item << result
+          end
+        end
+      end
     end
   end
 end

data/lib/muve/store/mongo.rb

@@ -0,0 +1,50 @@
+module Muve
+  module Store
+    class Mongo
+      require 'mongo'
+
+      extend Muve::Store
+
+      def self.create(resource, details)
+        raise MuveInvalidAttributes, "invalid update data" unless details.kind_of? Hash
+        resource.database[resource.container].insert(details)
+      end
+
+      def self.fetch(resource, id, details={})
+        # TODO: discover a solution that works for situations where database 
+        # driver returns string keys as well as symbol keys
+        details = {} unless details.kind_of? Hash
+        result = resource.database[resource.container].find_one(details.merge(_id: id))
+        result = Helper.symbolize_keys(result)
+        result[:id] = result.delete(:_id)
+        result
+      end
+
+      def self.find(resource, details)
+        details = {} unless details.kind_of? Hash
+        Enumerator.new do |result|
+          resource.database[resource.container].find(details).each do |item|
+            item = Helper.symbolize_keys(item)
+            item[:id] = item.delete(:_id)
+            result << item
+          end
+        end
+      end
+
+      def self.update(resource, id, details)
+        raise MuveInvalidAttributes, "invalid update data" unless details.kind_of? Hash
+        # TODO: raise error if details is not valid
+        resource.database[resource.container].find_and_modify(
+          query: { _id: id },
+          update: details
+        )
+      end
+
+      def self.delete(resource, id, details=nil)
+        details = {} unless details.kind_of? Hash
+        details = details.merge(_id: id) if id
+        resource.database[resource.container].remove(details)
+      end
+    end
+  end
+end

data/lib/muve/store.rb

@@ -0,0 +1,81 @@
+require 'muve/store/mongo'
+
+module Muve
+  # Muve::Store takes care of resource persistence and retrieval. Use stores
+  # as adaptors to connect your implementation of Muve to whichever datastore
+  # you please.
+  #
+  # Adaptors or Stores only take of the interaction with the datastore but 
+  # leave the model's housekeeping up the respective model. Make sure to 
+  # conform to the expected return formats for the different adaptor methods.
+  #
+  # Take a look at +Muve::Store::Mongo+ to find an implementation of a store
+  # adaptor.
+  module Store
+    include MuveError
+    include Muve::Helper
+
+    # gets data from the given container matching the provided details
+    #
+    # Given a +Place+ resource the following calls may be acceptable
+    # - +Adaptor.get(Place, 1232) # find one resource where id = 1232+
+    # - +Adaptor.get(Place, nil, { city: 'NYC', rating: 5 })+ # find more
+    def get(resource, id=nil, details=nil)
+      raise MuveInvalidQuery unless id || details
+
+      if details
+        find(resource, details)
+      else
+        fetch(resource, id, {})
+      end
+    end
+
+    # creates a resource containing the specified details in the repository.
+    # Returns the id of the created object on success, raises an error otherwise
+    def create(resource, details)
+      raise MuveIncompleteImplementation, "implement a create handler for #{self}"
+    end
+
+    # removes a resource matching the optional +id+ and +details+ 
+    # from the repository.
+    # A successful removal operation should returns +true+ while any other 
+    # value is considered an error.
+    def delete(resource, id, details=nil)
+      raise MuveIncompleteImplementation, "implement a delete handler for #{self}"
+    end
+
+    # update a resource with the identified by +id+ with the given +details+
+    def update(resource, id, details)
+      raise MuveIncompleteImplementation, "implement a update handler for #{self}"
+    end
+
+    # collect a single resource from the repository that matches the given id 
+    # and details. Upon the successful retrieval of a resource the id of the 
+    # resource is presented under the key +id+ while other attributes of the 
+    # resource bear arbitrary names.
+    #
+    #   { id: 12, name: 'Spock', organization: 'The Enterprise' }
+    def fetch(resource, id, details={})
+      raise MuveIncompleteImplementation, "implement a fetch handler for #{self}"
+    end
+
+    # find resources from its repository that match the given id and details
+    # Returns an +Enumerator+ that returns a hash with the key +id+ containing
+    # the primary key for the respective resource.
+    #
+    #   def find(resource, details)
+    #     details = {} unless details.kind_of? Hash
+    #     Enumerator.new do |item|
+    #       fetched_result_from_datastore.each do |data|
+    #         item << format_data(data) # format_data composes the required hash 
+    #       end
+    #     end
+    #   end
+    def find(resource, details)
+      raise MuveIncompleteImplementation, "implement a find handler for #{self}"
+    end
+
+    alias_method :destroy, :delete
+    alias_method :remove, :delete
+  end
+end

data/lib/muve/version.rb

@@ -1,3 +1,3 @@
 module Muve
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/muve.rb

@@ -15,22 +15,58 @@ require "muve/version"
 # times to improve its usability and implementation.
 module Muve
   require "muve/errors"
+  require "muve/helpers"
   require "muve/model"
+  require "muve/store"
   require "muve/location"
   require "muve/traveller"
   require "muve/movement"
 
   module Model
+    # Connection to the datastore
     def connection
       Model.connection
     end
+    
+    # Database instance for the model
+    def database
+      Model.database
+    end
+
+    # Set the connection to the datastore
+    def self.connection=connection
+      (@@conn = connection) if (connection)
+    end
 
+    def self.database=database
+      (@@db = database) if (database)
+    end
+
+    # Connection to the datastore
     def self.connection
-      @@conn ||= Object.new
+      begin
+      @@conn
+      rescue => e
+        raise MuveNotConfigured, "the connection has not been defined"
+      end
+    end
+
+    # Database instance to be used by the adaptor
+    def self.database
+      begin
+        @@db
+      rescue => e
+        raise MuveNotConfigured, "the database has not been defined"
+      end
     end
   end
 
-  def self.init
-    Model.connection
+  # Initialize Muve with an optional connection to the datastore.
+  # This could be a MongoDB or PostgreSQL connection for instance. Besides a 
+  # 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
   end
 end

data/muve.gemspec

@@ -18,11 +18,7 @@ Gem::Specification.new do |s|
   s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
-  s.add_development_dependency "bundler", "~> 1.6"
-  s.add_development_dependency "rake"
-  s.add_development_dependency "rspec",   "~> 3.0.0"
-  s.add_development_dependency "ffaker"
-  s.add_development_dependency "factory_girl", "~> 4.0"
+  #s.add_development_dependency "bundler", "~> 1.6"
 
   s.required_ruby_version = '>= 1.9.2'
 end

data/spec/adaptor/mongo_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe 'Mongo Adaptor' do
+  let(:connection) { Mongo::MongoClient.new }
+  let(:database) { connection.db('muve_test') }
+  before do
+    class Place
+      include Muve::Model
+
+      def self.container
+        'places'
+      end
+    end
+
+    Muve.init(connection, database)
+  end
+  
+  it 'writes model data to the store' do
+    expect{
+      Muve::Store::Mongo.create(Place, {
+        city: Faker::Address.city,
+        street: Faker::Address.street_name,
+        building: Faker::Address.building_number
+      })
+    }.to change{database['places'].count}.by(1)
+  end
+
+  it 'writes modifications to the store' do
+    id = database['places'].insert(name: Faker::Venue.name)
+    new_name = Faker::Venue.name
+
+    expect{
+      Muve::Store::Mongo.update(Place, id, { name: new_name })
+    }.to change{database['places'].find_one(_id: id)['name']}.to(new_name)
+  end
+
+  it 'finds a resource from store' do
+    id = database['places'].insert(name: Faker::Venue.name)
+    expect(Muve::Store::Mongo.get(Place, id)[:id]).to eq(id)
+  end
+
+  it 'finds multiple resources from store' do
+    expect(Muve::Store::Mongo.find(Place, {})).to be_a(Enumerable)
+  end
+
+  it 'extracts a resource from every result in a multiple resource set' do
+    Muve::Store::Mongo.find(Place, {}).take(3).each do |result|
+      attributes = result.keys.map{ |i| i.to_s }
+      expect(attributes).to include('id', 'city', 'street', 'building')
+    end
+  end
+end

data/spec/helper_spec.rb

@@ -0,0 +1,11 @@
+describe Muve::Helper do
+  describe '#symbolize_keys' do
+    it 'converts all keys to symbols' do
+      hash = { 'name' => 'Stewie Griffin', :skill => 'Physics' }
+      expect(Muve::Helper.symbolize_keys(hash)).to eq(
+        name: 'Stewie Griffin', 
+        skill: 'Physics'
+      )
+    end
+  end
+end

data/spec/model_spec.rb

@@ -0,0 +1,251 @@
+describe 'Model' do
+  before do
+    class Resource
+      include Muve::Model
+      attr_accessor :name, :version
+
+      def self.container
+        'resources'
+      end
+
+      def fields
+        [:name, :version]
+      end
+    end
+
+    class AnotherResource
+      include Muve::Model
+      attr_accessor :name, :version, :description
+
+      def self.container
+        'other_resources'
+      end
+
+      def fields
+        [:name, :version, :description]
+      end
+    end
+  end
+
+  it 'remembers its connection' do
+    object = Object.new
+    Muve::Model.connection = object
+    expect(Muve::Model.connection).to be(object)
+  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)
+  end
+
+  it 'knows the identifier of its repository' do
+    expect(Resource).to respond_to(:container)
+  end
+
+  it 'allows the setting of the adaptor' do
+    adaptor = Object.new
+    Resource.adaptor = adaptor
+    expect(Resource.adaptor).to be(adaptor)
+  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)
+  end
+
+  it 'sets the attributes of the resource at initialization' do
+    resource = Resource.new(name: 'muve-resource', version: 0)
+    expect(resource.name).to eq('muve-resource')
+    expect(resource.version).to eq(0)
+
+    another = AnotherResource.new(name: 'muve-something', version: nil, description: 'blah')
+    expect(another.name).to eq('muve-something')
+    expect(another.version).to eq(nil)
+    expect(another.description).to eq('blah')
+  end
+
+  # 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
+
+    expect(Resource.new.send(:adaptor)).to be(generic_adaptor)
+    expect(AnotherResource.new.send(:adaptor)).to be(generic_adaptor)
+  end
+
+  describe 'equiped with an adaptor' do
+    before do
+      class Resource
+        include Muve::Model
+
+        def valid?
+          true
+        end
+
+        def set_as_new_record(bool)
+          @new_record = bool
+        end
+      end
+
+      class GenericAdaptor
+        extend Muve::Store
+      end
+
+      Resource.adaptor = GenericAdaptor
+
+      @res = Resource.new
+    end
+
+    it 'calls the store create handler upon save' do
+      expect(GenericAdaptor).to receive(:create).once
+      @res.save
+    end
+
+    describe '#find' do
+      before(:each) do
+        @id = SecureRandom.hex
+        allow(GenericAdaptor).to receive(:fetch).and_return({ 
+          id: @id, 
+          name: 'Smile',
+          version: '0',
+          description: 'Supermodel smile... at least that is what they said'
+        })
+        allow(GenericAdaptor).to receive(:find).and_return(Enumerator.new { |y|
+          5.times {
+            y << { id: 12, name: 'Something', version: 1, description: 'haha' }
+          }
+        })
+      end
+
+      it 'returns an instance of the model' do
+        expect(AnotherResource.find(@id)).to be_a(AnotherResource)
+      end
+
+      it 'returns an object containing the record data' do
+        result = AnotherResource.find(@id)
+        expect(result.name).to eq('Smile')
+      end
+
+      it 'returns a record that is not a new record' do
+        expect(AnotherResource.find(@id).new_record?).to be(false)
+      end
+    end
+
+    describe '#where' do
+      before(:each) do
+        allow(GenericAdaptor).to receive(:find).and_return(Enumerator.new { |y|
+          5.times {
+            y << { id: 12, name: 'Something', version: 1, description: 'ahha' }
+          }
+        })
+      end
+
+      it 'returns the complete result set' do
+        expect(AnotherResource.where({ name: 'all' }).count).to eq(5)
+      end
+
+      it 'returns a instance of the resource for each item' do
+        AnotherResource.where({ name: 'all' }).each do |item|
+          expect(item).to be_a(AnotherResource)
+        end
+      end
+    end
+
+    describe '#save' do
+      before(:each) do
+        @res.name = 'first'
+        allow(GenericAdaptor).to receive(:create).and_return(@id = SecureRandom.hex)
+      end
+
+      describe 'on a new record' do
+        it 'returns an instance of itself' do
+          expect(@res.save).to be_a(Resource)
+        end
+  
+        it 'obtains an id' do
+          expect { @res.save }.to change{ @res.id }.to(@id)
+        end
+  
+        it 'is no longer a new record' do
+          expect{ @res.save }.to change{ @res.new_record? }.to(false)
+        end
+  
+        it 'is persisted' do
+          expect{ @res.save }.to change{ @res.persisted? }.to(true)
+        end
+      end
+
+      describe 'on a existing record' do
+        before(:each) do
+          allow(GenericAdaptor).to receive(:update).and_return(true)
+          @res.save
+        end
+  
+        it 'returns persist the resource' do
+          expect(@res).to receive(:update).once
+          @res.name = 'second'
+          @res.save
+        end
+      end
+    end
+
+    describe '#destroy' do
+      before(:each) do
+        @id = SecureRandom.hex
+        allow(GenericAdaptor).to receive(:fetch).and_return({ 
+          id: @id, 
+          name: 'Laugh',
+          version: 28,
+          description: 'The best laugh ever... makes me laugh'
+        })
+        allow(GenericAdaptor).to receive(:delete).and_return(true)
+        @res = AnotherResource.find(@id)
+      end
+
+      it 'is marked as removed' do
+        expect { @res.destroy }.to change{ @res.destroyed? }.to(true)
+      end
+
+      it 'is not a new record' do
+        expect { @res.destroy }.to change{ @res.destroyed? }.to(true)
+      end
+    end
+
+    it 'calls the delete handler upon remove' do
+      expect(GenericAdaptor).to receive(:delete).once
+      @res.destroy
+    end
+
+    it 'calls the update handler upon save on a resource with an id' do
+      id = SecureRandom.uuid
+      expect(GenericAdaptor).to receive(:update).once
+      @res.set_as_new_record false
+      expect(@res.new_record?).to be(false)
+      @res.save
+    end
+
+    it 'calls the find handler upon a request to find resources' do
+      expect(GenericAdaptor).to receive(:find).with(Resource, { name: 'bogus' })
+      Resource.where(name: 'bogus').take(1)
+    end
+
+    it 'calls the fetcher to get a resource' do
+      id = SecureRandom.uuid
+      expect(GenericAdaptor).to receive(:fetch).with(Resource, id, anything)
+      Resource.find(id)
+    end
+  end
+end

data/spec/movement_spec.rb

@@ -32,11 +32,11 @@ describe Muve::Movement do
     expect(Muve::Movement.new).to respond_to(:connection)
   end
 
-  it 'shares the connection among all instances' do
-    Muve.init
+  it 'shares the connection among other models' do
+    connection = Object.new
+    Muve.init(connection)
 
-    connection = Muve::Model.connection
-    expect(connection).not_to eq(nil)
+    expect(Muve::Model.connection).to eq(connection)
 
     expect(Muve::Movement.new.connection).to be(connection)
     expect(Muve::Location.new.connection).to be(connection)

data/spec/muve_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Muve do
+  it 'includes the model module' do
+    expect{ Muve::Model }.not_to raise_error
+  end
+
+  it 'includes the location class' do
+    expect{ Muve::Location }.not_to raise_error
+  end
+
+  it 'includes the traveller class' do
+    expect{ Muve::Traveller }.not_to raise_error
+  end
+
+  it 'includes the movement class' do
+    expect{ Muve::Movement }.not_to raise_error
+  end
+
+  it 'contains a model that behaves like one' do
+    class TestModel
+      include Muve::Model
+    end
+
+    expect(TestModel.new).to respond_to(:save)
+    expect(TestModel.new).to respond_to(:valid?)
+    expect(TestModel.new).to respond_to(:connection)
+  end
+end

data/spec/store_spec.rb

@@ -0,0 +1,62 @@
+describe Muve::Store do
+  before do
+    class Resource
+      include Muve::Model
+
+      def self.container
+        'resources'
+      end
+    end
+
+    class GenericStore
+      extend Muve::Store
+    end
+  end
+
+  it 'provides methods to get a resource' do
+    expect(GenericStore).to respond_to(:get)
+    expect(GenericStore).to respond_to(:fetch)
+  end
+
+  it 'provides methods to create a resource' do
+    expect(GenericStore).to respond_to(:create)
+  end
+
+  it 'provides methods to destroy a resource' do
+    expect(GenericStore).to respond_to(:delete)
+    expect(GenericStore).to respond_to(:destroy)
+    expect(GenericStore).to respond_to(:remove)
+  end
+
+  it 'provides methods to update a resource' do
+    expect(GenericStore).to respond_to(:update)
+  end
+
+  it 'raises incomplete implementation errors on non-implemented methods' do
+    %w(create delete update fetch find).each do |method|
+      expect{
+        if method == 'update'
+          GenericStore.send(method, 'resource', nil, {})
+        else
+          GenericStore.send(method, 'resource', nil)
+        end
+      }.to raise_error(MuveError::MuveIncompleteImplementation)
+    end
+  end
+
+  it 'attempts to fetch a resource if the id is given' do
+    expect(GenericStore).to receive(:fetch)
+    GenericStore.get(Resource, SecureRandom.uuid)
+  end
+
+  it 'attempts to find a resource if the id is not given but the details are' do
+    expect(GenericStore).to receive(:find)
+    GenericStore.get(Resource, nil, { name: 'bogus' })
+  end
+
+  it 'raises an error if neither id nor details are given' do
+    expect{
+      GenericStore.get(Resource)
+    }.to raise_error
+  end
+end

metadata

@@ -1,85 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: muve
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - David Asabina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-15 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.0.0
-- !ruby/object:Gem::Dependency
-  name: ffaker
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: factory_girl
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
+date: 2014-07-29 00:00:00.000000000 Z
+dependencies: []
 description: Basic helpers to be used with Muvement
 email:
 - david@supr.nu
@@ -93,16 +23,24 @@ files:
 - Rakefile
 - lib/muve.rb
 - lib/muve/errors.rb
+- lib/muve/helpers.rb
 - lib/muve/location.rb
 - lib/muve/model.rb
 - lib/muve/movement.rb
+- lib/muve/store.rb
+- lib/muve/store/mongo.rb
 - lib/muve/traveller.rb
 - lib/muve/version.rb
 - muve.gemspec
+- spec/adaptor/mongo_spec.rb
 - spec/factories.rb
+- spec/helper_spec.rb
 - spec/location_spec.rb
+- spec/model_spec.rb
 - spec/movement_spec.rb
+- spec/muve_spec.rb
 - spec/spec_helper.rb
+- spec/store_spec.rb
 - spec/traveller_spec.rb
 homepage: ''
 licenses:
@@ -129,8 +67,13 @@ signing_key:
 specification_version: 4
 summary: muve gem
 test_files:
+- spec/adaptor/mongo_spec.rb
 - spec/factories.rb
+- spec/helper_spec.rb
 - spec/location_spec.rb
+- spec/model_spec.rb
 - spec/movement_spec.rb
+- spec/muve_spec.rb
 - spec/spec_helper.rb
+- spec/store_spec.rb
 - spec/traveller_spec.rb