mongoid_collection_snapshot 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8354fa3558b50530619ef83969005b83f797408b
-  data.tar.gz: 545fe63db62763ff9bf579f5880be6cc7759ecfd
+  metadata.gz: 041a83b26ca092439e83e0dd525c73d08ece188a
+  data.tar.gz: 4a5e32a1d3f3809279fbb0747988bde7f254db3b
 SHA512:
-  metadata.gz: 17ee7b9cc0b5da03afce28a44b2455181bafc26bb83e0185071a0b0437aa46f7301db3f67f182335aed9aab1bda2323fe48796a73ec348c14257566f701e725a
-  data.tar.gz: 2049669da108f6693b98628cfa24fc0bbfe179b5c8171ee4f36883ddb820845a663f457dc97d55756268c4e999299a467fb0bc8f4bb8e9c99d19ce3af9debbe5
+  metadata.gz: b889d8da972a015996384bdf38f2bbe2b53b025efb716a95d55ab88a429e9268dd5cbbdd045edc84fbdbfd34ab694190bcb0554e57c0c3a48802d84393fed2b6
+  data.tar.gz: 2945f8661a3dd9eb70795d79cca5efae7a925a3454a6e94ffe607ce3dd81816055a90ecd4cf2a74b9b7d2f9079776aebaa03fa21d38ec529f944468f11354ada

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=progress

data/.travis.yml

@@ -13,3 +13,5 @@ env:
 language: ruby
 
 cache: bundler
+
+sudo: false

data/CHANGELOG.md

@@ -1,6 +1,12 @@
 Next Release
 ------------
 
+1.1.0
+-----
+
+* [#11](https://github.com/aaw/mongoid_collection_snapshot/pull/10): Added support for accessing snapshot collection documents via Mongoid::CollectionSnapshot#documents - [@dblock](https://github.com/dblock).
+* [#11](https://github.com/aaw/mongoid_collection_snapshot/pull/11): Upgraded RSpec - [@dblock](https://github.com/dblock).
+
 1.0.1
 -----
 

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 case version = ENV['MONGOID_VERSION'] || '~> 4.0'
 when /4/
@@ -9,10 +9,10 @@ else
   gem 'mongoid', version
 end
 
-gem "mongoid_slug"
+gem 'mongoid_slug'
 
 group :development, :test do
-  gem "rspec", "~> 2.11.0"
-  gem "rake"
+  gem 'rspec', '~> 3.1'
+  gem 'rake'
+  gem 'timecop'
 end
-

data/README.md

@@ -8,30 +8,18 @@ Easy maintenance of collections of processed data in MongoDB with the Mongoid 3.
 Quick example:
 --------------
 
-Suppose that you have a Mongoid model called `Artwork`, stored
-in a MongoDB collection called `artworks` and the underlying documents
-look something like:
+Suppose that you have a Mongoid model called `Artwork`, stored in a MongoDB collection called `artworks` and the underlying documents look something like:
 
     { name: 'Flowers', artist: 'Andy Warhol', price: 3000000 }
 
-From time to time, your system runs a map/reduce job to compute the
-average price of each artist's works, resulting in a collection called
-`artist_average_price` that contains documents that look like:
+From time to time, your system runs a map/reduce job to compute the average price of each artist's works, resulting in a collection called `artist_average_price` that contains documents that look like:
 
-    { _id: { artist: 'Andy Warhol'}, value: { price: 1500000 } }
+    { _id: { artist: 'Andy Warhol' }, value: { price: 1500000 } }
 
-If your system wants to maintain and use this average price data, it has
-to do so at the level of raw MongoDB operations, since
-map/reduce result documents don't map well to models in Mongoid.
-Furthermore, even though map/reduce jobs can take some time to run, you probably
-want the entire `artist_average_price` collection populated atomically
-from the point of view of your system, since otherwise you don't ever
-know the state of the data in the collection - you could access it in
-the middle of a map/reduce and get partial, incorrect results.
+If your system wants to maintain and use this average price data, it has to do so at the level of raw MongoDB operations, since map/reduce result documents don't map well to models in Mongoid.
+Furthermore, even though map/reduce jobs can take some time to run, you probably want the entire `artist_average_price` collection populated atomically from the point of view of your system, since otherwise you don't ever know the state of the data in the collection - you could access it in the middle of a map/reduce and get partial, incorrect results.
 
-mongoid_collection_snapshot solves this problem by providing an atomic
-view of collections of data like map/reduce results that live outside
-of Mongoid.
+A mongoid_collection_snapshot solves this problem by providing an atomic view of collections of data like map/reduce results that live outside of Mongoid.
 
 In the example above, we'd set up our average artist price collection like:
 
@@ -40,9 +28,10 @@ class AverageArtistPrice
   include Mongoid::CollectionSnapshot
 
   def build
+
     map = <<-EOS
       function() {
-        emit({artist: this['artist']}, {count: 1, sum: this['price']})
+        emit({ artist_id: this['artist_id']}, { count: 1, sum: this['price'] })
       }
     EOS
 
@@ -51,49 +40,82 @@ class AverageArtistPrice
         var sum = 0;
         var count = 0;
         values.forEach(function(value) {
-          sum += value['price'];
+          sum += value['sum'];
           count += value['count'];
         });
-        return({count: count, sum: sum});
+        return({ count: count, sum: sum });
       }
     EOS
 
-    Mongoid.default_session.command(
-      "mapreduce" => "artworks",
-      map: map,
-      reduce: reduce,
-      out: collection_snapshot.name)
+    Artwork.map_reduce(map, reduce).out(inline: 1).each do |doc|
+      collection_snapshot.insert(
+        artist_id: doc['_id']['artist_id'],
+        count: doc['value']['count'],
+        sum: doc['value']['sum']
+      )
+    end
   end
+end
 
-  def average_price(artist)
-    doc = collection_snapshot.find({'_id.artist': artist}).first
-    doc['value']['sum']/doc['value']['count']
+```
+
+Now, if you want to schedule a recomputation, just call `AverageArtistPrice.create`. You can define other methods on collection snapshots.
+
+```ruby
+class AverageArtistPrice
+  ...
+
+  def average_price(artist_name)
+    artist = Artist.where(name: artist_name).first
+    doc = collection_snapshot.where(artist_id: artist.id).first
+    doc['sum'] / doc['count']
   end
 end
 ```
 
-Now, if you want
-to schedule a recomputation, just call `AverageArtistPrice.create`. The latest
-snapshot is always available as `AverageArtistPrice.latest`, so you can write
-code like:
+The latest snapshot is always available as `AverageArtistPrice.latest`, so you can write code like:
 
-``` ruby
+```ruby
 warhol_expected_price = AverageArtistPrice.latest.average_price('Andy Warhol')
 ```
 
-And always be sure that you'll never be looking at partial results. The only
-thing you need to do to hook into mongoid_collection_snapshot is implement the
-method `build`, which populates the collection snapshot and any indexes you need.
+And always be sure that you'll never be looking at partial results. The only thing you need to do to hook into mongoid_collection_snapshot is implement the method `build`, which populates the collection snapshot and any indexes you need.
 
-By default, mongoid_collection_snapshot maintains the most recent two snapshots
-computed any given time.
+By default, mongoid_collection_snapshot maintains the most recent two snapshots computed any given time.
+
+Query Snapshot Data with Mongoid
+--------------------------------
+
+You can do better than the average price example above and define first-class models for your collection snapshot data, then access them as any other Mongoid collection via collection snapshot's `.documents` method.
+
+```ruby
+class AverageArtistPrice
+  document do
+    belongs_to :artist, inverse_of: nil
+    field :sum, type: Integer
+    field :count, type: Integer
+  end
+
+  def average_price(artist_name)
+    artist = Artist.where(name: artist_name).first
+    doc = documents.where(artist: artist).first
+    doc.sum / doc.count
+  end
+end
+```
+
+Another example iterates through all latest artist price averages.
+
+```ruby
+AverageArtistPrice.latest.documents.each do |doc|
+  puts "#{doc.artist.name}: #{doc.sum / doc.count}"
+end
+```
 
 Multi-collection snapshots
 --------------------------
 
-You can maintain multiple collections atomically within the same snapshot by
-passing unique collection identifiers to ``collection_snaphot`` when you call it
-in your build or query methods:
+You can maintain multiple collections atomically within the same snapshot by passing unique collection identifiers to `collection_snaphot` when you call it in your build or query methods:
 
 ``` ruby
 class ArtistStats
@@ -103,22 +125,53 @@ class ArtistStats
     # ...
     # define map/reduce for average and max aggregations
     # ...
-    Mongoid.default_session.command("mapreduce" => "artworks", map: map_avg, reduce: reduce_avg, out: collection_snapshot('average'))
-    Mongoid.default_session.command("mapreduce" => "artworks", map: map_max, reduce: reduce_max, out: collection_snapshot('max'))
+    Mongoid.default_session.command('mapreduce' => 'artworks', map: map_avg, reduce: reduce_avg, out: collection_snapshot('average'))
+    Mongoid.default_session.command('mapreduce' => 'artworks', map: map_max, reduce: reduce_max, out: collection_snapshot('max'))
   end
 
   def average_price(artist)
-    doc = collection_snapshot('average').find({'_id.artist': artist}).first
-    doc['value']['sum']/doc['value']['count']
+    doc = collection_snapshot('average').find('_id.artist' => artist).first
+    doc['value']['sum'] / doc['value']['count']
   end
 
   def max_price(artist)
-    doc = collection_snapshot('max').find({'_id.artist': artist}).first
+    doc = collection_snapshot('max').find('_id.artist' => artist).first
     doc['value']['max']
   end
 end
 ```
 
+Specify the name of the collection to define first class Mongoid models.
+
+```ruby
+class ArtistStats
+  document('average') do
+    field :value, type: Hash
+  end
+
+  document('max') do
+    field :value, type: Hash
+  end
+end
+```
+
+Access these by name.
+
+```ruby
+ArtistStats.latest.documents('average')
+ArtistStats.latest.documents('max')
+```
+
+If fields across multiple collection snapshots are identical, a single default `document` is sufficient.
+
+```ruby
+class ArtistStats
+  document do
+    field :value, type: Hash
+  end
+end
+```
+
 Custom database connections
 ---------------------------
 

data/Rakefile

@@ -9,7 +9,7 @@ begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  $stderr.puts 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
 
@@ -19,7 +19,7 @@ require 'rspec/core'
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
-  spec.rspec_opts = "--color --format progress"
+  spec.rspec_opts = '--color --format progress'
 end
 
-task :default => :spec
+task default: :spec

data/lib/mongoid_collection_snapshot.rb

@@ -1,59 +1,89 @@
 require 'mongoid_collection_snapshot/version'
 
-module Mongoid::CollectionSnapshot
-  extend ActiveSupport::Concern
+module Mongoid
+  module CollectionSnapshot
+    extend ActiveSupport::Concern
 
-  included do
-    require 'mongoid_slug'
+    DEFAULT_COLLECTION_KEY_NAME = '*'
 
-    include Mongoid::Document
-    include Mongoid::Timestamps::Created
-    include Mongoid::Slug
+    included do
+      require 'mongoid_slug'
 
-    field :workspace_basename, default: 'snapshot'
-    slug :workspace_basename
+      include Mongoid::Document
+      include Mongoid::Timestamps::Created
+      include Mongoid::Slug
 
-    field :max_collection_snapshot_instances, default: 2
+      field :workspace_basename, default: 'snapshot'
+      slug :workspace_basename
 
-    before_create :build
-    after_create :ensure_at_most_two_instances_exist
-    before_destroy :drop_snapshot_collections
-  end
+      field :max_collection_snapshot_instances, default: 2
+
+      before_create :build
+      after_create :ensure_at_most_two_instances_exist
+      before_destroy :drop_snapshot_collections
+
+      cattr_accessor :document_blocks
+      cattr_accessor :document_classes
 
-  module ClassMethods
-    def latest
-      order_by([[:created_at, :desc]]).first
+      # Mongoid documents on this snapshot.
+      def documents(name = nil)
+        self.document_classes ||= {}
+        class_name = "#{self.class.name}#{id}#{name}".underscore.camelize
+        key = "#{class_name}-#{name || DEFAULT_COLLECTION_KEY_NAME}"
+        self.document_classes[key] ||= begin
+          document_block = document_blocks[name || DEFAULT_COLLECTION_KEY_NAME] if document_blocks
+          collection_name = collection_snapshot(name).name
+          klass = Class.new do
+            include Mongoid::Document
+            cattr_accessor :mongo_session
+            instance_eval(&document_block) if document_block
+            store_in collection: collection_name
+          end
+          klass.mongo_session = snapshot_session
+          Object.const_set(class_name, klass)
+          klass
+        end
+      end
     end
-  end
 
-  def collection_snapshot(name=nil)
-    if name
-      snapshot_session["#{self.collection.name}.#{name}.#{slug}"]
-    else
-      snapshot_session["#{self.collection.name}.#{slug}"]
+    module ClassMethods
+      def latest
+        order_by([[:created_at, :desc]]).first
+      end
+
+      def document(name = nil, &block)
+        self.document_blocks ||= {}
+        self.document_blocks[name || DEFAULT_COLLECTION_KEY_NAME] = block
+      end
     end
-  end
 
-  def drop_snapshot_collections
-    snapshot_session.collections.each do |collection|
-      collection.drop if collection.name =~ /^#{self.collection.name}\.([^\.]+\.)?#{slug}$/
+    def collection_snapshot(name = nil)
+      if name
+        snapshot_session["#{collection.name}.#{name}.#{slug}"]
+      else
+        snapshot_session["#{collection.name}.#{slug}"]
+      end
     end
-  end
 
-  # Since we should always be using the latest instance of this class, this method is
-  # called after each save - making sure only at most two instances exists should be
-  # sufficient to ensure that this data can be rebuilt live without corrupting any
-  # existing computations that might have a handle to the previous "latest" instance.
-  def ensure_at_most_two_instances_exist
-    all_instances = self.class.order_by([[:created_at, :desc]]).to_a
-    if all_instances.length > self.max_collection_snapshot_instances
-      all_instances[self.max_collection_snapshot_instances..-1].each { |instance| instance.destroy }
+    def drop_snapshot_collections
+      snapshot_session.collections.each do |collection|
+        collection.drop if collection.name =~ /^#{self.collection.name}\.([^\.]+\.)?#{slug}$/
+      end
     end
-  end
 
-  # Override to supply custom database connection for snapshots
-  def snapshot_session
-    Mongoid.default_session
-  end
+    # Since we should always be using the latest instance of this class, this method is
+    # called after each save - making sure only at most two instances exists should be
+    # sufficient to ensure that this data can be rebuilt live without corrupting any
+    # existing computations that might have a handle to the previous "latest" instance.
+    def ensure_at_most_two_instances_exist
+      all_instances = self.class.order_by([[:created_at, :desc]]).to_a
+      return unless all_instances.length > max_collection_snapshot_instances
+      all_instances[max_collection_snapshot_instances..-1].each(&:destroy)
+    end
 
+    # Override to supply custom database connection for snapshots
+    def snapshot_session
+      Mongoid.default_session
+    end
+  end
 end

data/lib/mongoid_collection_snapshot/version.rb

@@ -1,7 +1,5 @@
 module Mongoid
   module CollectionSnapshot
-    VERSION = '1.0.1'
+    VERSION = '1.1.0'
   end
 end
-
-

data/spec/models/artist.rb

@@ -0,0 +1,7 @@
+class Artist
+  include Mongoid::Document
+
+  field :name
+
+  has_many :artworks
+end

data/spec/models/artwork.rb

@@ -2,6 +2,7 @@ class Artwork
   include Mongoid::Document
 
   field :name
-  field :artist
   field :price
+
+  belongs_to :artist
 end

data/spec/models/average_artist_price.rb

@@ -1,10 +1,16 @@
 class AverageArtistPrice
   include Mongoid::CollectionSnapshot
 
+  document do
+    belongs_to :artist, inverse_of: nil
+    field :sum, type: Integer
+    field :count, type: Integer
+  end
+
   def build
     map = <<-EOS
       function() {
-        emit({artist: this['artist']}, {count: 1, sum: this['price']})
+        emit({ artist_id: this['artist_id']}, { count: 1, sum: this['price'] })
       }
     EOS
 
@@ -16,20 +22,24 @@ class AverageArtistPrice
           sum += value['sum'];
           count += value['count'];
         });
-        return({count: count, sum: sum});
+        return({ count: count, sum: sum });
       }
     EOS
 
-    Mongoid.default_session.command(
-      "mapreduce" => "artworks",
-      map: map,
-      reduce: reduce,
-      out: collection_snapshot.name)
+    Artwork.map_reduce(map, reduce).out(inline: 1).each do |doc|
+      collection_snapshot.insert(
+        artist_id: doc['_id']['artist_id'],
+        count: doc['value']['count'],
+        sum: doc['value']['sum']
+      )
+    end
   end
 
-  def average_price(artist)
-    doc = collection_snapshot.where({'_id.artist' => artist}).first
-    doc['value']['sum']/doc['value']['count']
+  def average_price(artist_name)
+    artist = Artist.where(name: artist_name).first
+    fail 'missing artist' unless artist
+    doc = documents.where(artist: artist).first
+    fail 'missing record' unless doc
+    doc.sum / doc.count
   end
-
 end

data/spec/models/custom_connection_snapshot.rb

@@ -2,7 +2,7 @@ class CustomConnectionSnapshot
   include Mongoid::CollectionSnapshot
 
   def self.snapshot_session
-    @@snapshot_session ||= Moped::Session.new(['127.0.0.1:27017']).tap do |session|
+    @snapshot_session ||= Moped::Session.new(['127.0.0.1:27017']).tap do |session|
       session.use :snapshot_test
     end
   end
@@ -13,6 +13,6 @@ class CustomConnectionSnapshot
 
   def build
     collection_snapshot.insert('name' => 'foo')
-    collection_snapshot('foo').insert({'name' => 'bar'})
+    collection_snapshot('foo').insert('name' => 'bar')
   end
 end

data/spec/models/multi_collection_snapshot.rb

@@ -1,14 +1,28 @@
 class MultiCollectionSnapshot
   include Mongoid::CollectionSnapshot
-  
-  def build
-    collection_snapshot('foo').insert({'name' => 'foo!'})
-    collection_snapshot('bar').insert({'name' => 'bar!'})
-    collection_snapshot('baz').insert({'name' => 'baz!'})
+
+  document('foo') do
+    field :name, type: String
+    field :count, type: Integer
+  end
+
+  document('bar') do
+    field :name, type: String
+    field :number, type: Integer
   end
 
-  def get_names
-    ['foo', 'bar', 'baz'].map{ |x| collection_snapshot(x).find.first['name'] }.join('')
+  document('baz') do
+    field :name, type: String
+    field :digit, type: Integer
   end
 
+  def build
+    collection_snapshot('foo').insert('name' => 'foo!', count: 1)
+    collection_snapshot('bar').insert('name' => 'bar!', number: 2)
+    collection_snapshot('baz').insert('name' => 'baz!', digit: 3)
+  end
+
+  def names
+    %w(foo bar baz).map { |x| collection_snapshot(x).find.first['name'] }.join('')
+  end
 end

data/spec/mongoid/collection_snapshot_spec.rb

@@ -2,104 +2,128 @@ require 'spec_helper'
 
 module Mongoid
   describe CollectionSnapshot do
-
-    it "has a version" do
-      Mongoid::CollectionSnapshot::VERSION.should_not be_nil
+    it 'has a version' do
+      expect(Mongoid::CollectionSnapshot::VERSION).not_to be_nil
     end
 
-    context "creating a basic snapshot" do
-
-      let!(:flowers)     { Artwork.create(:name => 'Flowers', :artist => 'Andy Warhol', :price => 3000000) }
-      let!(:guns)        { Artwork.create(:name => 'Guns', :artist => 'Andy Warhol', :price => 1000000) }
-      let!(:vinblastine) { Artwork.create(:name => 'Vinblastine', :artist => 'Damien Hirst', :price => 1500000) }
+    context 'creating a basic snapshot' do
+      let!(:andy_warhol) { Artist.create!(name: 'Andy Warhol') }
+      let!(:damien_hirst) { Artist.create!(name: 'Damien Hirst') }
+      let!(:flowers) { Artwork.create!(name: 'Flowers', artist: andy_warhol, price: 3_000_000) }
+      let!(:guns) { Artwork.create!(name: 'Guns', artist: andy_warhol, price: 1_000_000) }
+      let!(:vinblastine) { Artwork.create!(name: 'Vinblastine', artist: damien_hirst, price: 1_500_000) }
 
-      it "returns nil if no snapshot has been created" do
-        AverageArtistPrice.latest.should be_nil
+      it 'returns nil if no snapshot has been created' do
+        expect(AverageArtistPrice.latest).to be_nil
       end
 
-      it "runs the build method on creation" do
+      it 'runs the build method on creation' do
         snapshot = AverageArtistPrice.create
-        snapshot.average_price('Andy Warhol').should == 2000000
-        snapshot.average_price('Damien Hirst').should == 1500000
+        expect(snapshot.average_price('Andy Warhol')).to eq(2_000_000)
+        expect(snapshot.average_price('Damien Hirst')).to eq(1_500_000)
       end
 
-      it "returns the most recent snapshot through the latest methods" do
+      it 'returns the most recent snapshot through the latest methods' do
         first = AverageArtistPrice.create
-        first.should == AverageArtistPrice.latest
+        expect(first).to eq(AverageArtistPrice.latest)
         # "latest" only works up to a resolution of 1 second since it relies on Mongoid::Timestamp. But this
         # module is meant to snapshot long-running collection creation, so if you need a resolution of less
         # than a second for "latest" then you're probably using the wrong gem. In tests, sleeping for a second
         # makes sure we get what we expect.
-        sleep(1)
+        Timecop.travel(1.second.from_now)
         second = AverageArtistPrice.create
-        AverageArtistPrice.latest.should == second
-        sleep(1)
+        expect(AverageArtistPrice.latest).to eq(second)
+        Timecop.travel(1.second.from_now)
         third = AverageArtistPrice.create
-        AverageArtistPrice.latest.should == third
+        expect(AverageArtistPrice.latest).to eq(third)
       end
 
-      it "should only maintain at most two of the latest snapshots to support its calculations" do
+      it 'maintains at most two of the latest snapshots to support its calculations' do
         AverageArtistPrice.create
         10.times do
           AverageArtistPrice.create
-          AverageArtistPrice.count.should == 2
+          expect(AverageArtistPrice.count).to eq(2)
         end
       end
 
-    end
+      context '#documents' do
+        it 'provides access to a Mongoid collection' do
+          snapshot = AverageArtistPrice.create
+          expect(snapshot.documents.count).to eq 2
+          document = snapshot.documents.where(artist: andy_warhol).first
+          expect(document.artist).to eq andy_warhol
+          expect(document.count).to eq 2
+          expect(document.sum).to eq 4_000_000
+        end
 
-    context "creating a snapshot containing multiple collections" do
+        it 'only creates one global class reference' do
+          3.times do
+            index = AverageArtistPrice.create
+            2.times { expect(index.documents.count).to eq 2 }
+          end
+          expect(AverageArtistPrice.document_classes.count).to be >= 3
+        end
+      end
+    end
 
-      it "populates several collections and allows them to be queried" do
-        MultiCollectionSnapshot.latest.should be_nil
+    context 'creating a snapshot containing multiple collections' do
+      it 'populates several collections and allows them to be queried' do
+        expect(MultiCollectionSnapshot.latest).to be_nil
         10.times { MultiCollectionSnapshot.create }
-        MultiCollectionSnapshot.latest.get_names.should == "foo!bar!baz!"
+        expect(MultiCollectionSnapshot.latest.names).to eq('foo!bar!baz!')
       end
 
-      it "safely cleans up all collections used by the snapshot" do
+      it 'safely cleans up all collections used by the snapshot' do
         # Create some collections with names close to the snapshots we'll create
-        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.do.not_delete"].insert({'a' => 1})
-        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.snapshorty"].insert({'a' => 1})
-        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.hello.1"].insert({'a' => 1})
+        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.do.not_delete"].insert('a' => 1)
+        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.snapshorty"].insert('a' => 1)
+        Mongoid.default_session["#{MultiCollectionSnapshot.collection.name}.hello.1"].insert('a' => 1)
 
         MultiCollectionSnapshot.create
-        before_create = Mongoid.default_session.collections.map{ |c| c.name }
-        before_create.length.should > 0
+        before_create = Mongoid.default_session.collections.map(&:name)
+        expect(before_create.length).to be > 0
 
-        sleep(1)
+        Timecop.travel(1.second.from_now)
         MultiCollectionSnapshot.create
-        after_create = Mongoid.default_session.collections.map{ |c| c.name }
+        after_create = Mongoid.default_session.collections.map(&:name)
         collections_created = (after_create - before_create).sort
-        collections_created.length.should == 3
+        expect(collections_created.length).to eq(3)
 
         MultiCollectionSnapshot.latest.destroy
-        after_destroy = Mongoid.default_session.collections.map{ |c| c.name }
+        after_destroy = Mongoid.default_session.collections.map(&:name)
         collections_destroyed = (after_create - after_destroy).sort
-        collections_created.should == collections_destroyed
+        expect(collections_created).to eq(collections_destroyed)
       end
-
     end
 
-    context "with a custom snapshot connection" do
-
+    context 'with a custom snapshot connection' do
       around(:each) do |example|
         CustomConnectionSnapshot.snapshot_session.drop
         example.run
         CustomConnectionSnapshot.snapshot_session.drop
       end
 
-      it "builds snapshot in custom database" do
+      it 'builds snapshot in custom database' do
         snapshot = CustomConnectionSnapshot.create
         [
           "#{CustomConnectionSnapshot.collection.name}.foo.#{snapshot.slug}",
           "#{CustomConnectionSnapshot.collection.name}.#{snapshot.slug}"
         ].each do |collection_name|
-          Mongoid.default_session[collection_name].find.count.should == 0
-          CustomConnectionSnapshot.snapshot_session[collection_name].find.count.should == 1
+          expect(Mongoid.default_session[collection_name].find.count).to eq(0)
+          expect(CustomConnectionSnapshot.snapshot_session[collection_name].find.count).to eq(1)
         end
       end
 
+      context '#documents' do
+        it 'uses the custom session' do
+          expect(CustomConnectionSnapshot.new.documents.mongo_session).to eq CustomConnectionSnapshot.snapshot_session
+        end
+        it 'provides access to a Mongoid collection' do
+          snapshot = CustomConnectionSnapshot.create
+          expect(snapshot.collection_snapshot.find.count).to eq 1
+          expect(snapshot.documents.count).to eq 1
+        end
+      end
     end
-
   end
 end

data/spec/spec_helper.rb

@@ -3,12 +3,13 @@ require 'bundler/setup'
 require 'rspec'
 
 require 'mongoid'
+require 'timecop'
 
 Mongoid.configure do |config|
-  config.connect_to("mongoid_collection_snapshot_test")
+  config.connect_to('mongoid_collection_snapshot_test')
 end
 
-require File.expand_path("../../lib/mongoid_collection_snapshot", __FILE__)
+require File.expand_path('../../lib/mongoid_collection_snapshot', __FILE__)
 Dir["#{File.dirname(__FILE__)}/models/**/*.rb"].each { |f| require f }
 
 RSpec.configure do |c|
@@ -20,3 +21,4 @@ RSpec.configure do |c|
   end
 end
 
+RSpec.configure(&:raise_errors_for_deprecations!)

metadata

@@ -1,41 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_collection_snapshot
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Aaron Windsor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-07 00:00:00.000000000 Z
+date: 2015-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: mongoid_slug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: 
@@ -44,8 +44,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".travis.yml"
+- .gitignore
+- .rspec
+- .travis.yml
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
@@ -54,6 +55,7 @@ files:
 - lib/mongoid_collection_snapshot.rb
 - lib/mongoid_collection_snapshot/version.rb
 - mongoid_collection_snapshot.gemspec
+- spec/models/artist.rb
 - spec/models/artwork.rb
 - spec/models/average_artist_price.rb
 - spec/models/custom_connection_snapshot.rb
@@ -70,17 +72,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Easy maintenence of collections of processed data in MongoDB with the Mongoid