mongoid-collection-snapshot 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdda543f7183d461cf4b7068b97c7c9bba6523b9
+  data.tar.gz: a83c53f21498ad03d49089382dd9e519a9451d79
+SHA512:
+  metadata.gz: de91fdde1b8c8b6457cdcecb4e91eec67f4eb3fddf0f96702092ef3a8df9e4747401571d1475478e1f82e28b33133287df422fce178ac245c238c6474de2be93
+  data.tar.gz: c9682df34fa35b1e444f6f10ccbf28a15517ca141c397d689493aca9de664c0c524cebb11c1a58f7a3abafd15fca855ac233fa3c1d538e408c3fc494392558c4

data/.gitignore

@@ -0,0 +1,54 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# bundler
+pkg
+
+# Gemfile lock
+Gemfile.lock
+
+# rvm
+.rvmrc
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+#.DS_Store
+
+# For TextMate
+*.tmproj
+tmtags
+
+# For emacs:
+*~
+\#*
+.\#*
+
+# For vim:
+*.swp
+
+# For redcar:
+.redcar
+
+# For rubinius:
+*.rbc

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: .rubocop_todo.yml

data/.rubocop_todo.yml

@@ -0,0 +1,72 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2017-01-20 11:17:06 -0500 using RuboCop version 0.47.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 4
+# Configuration parameters: Include.
+# Include: **/Gemfile, **/gems.rb
+Bundler/DuplicatedGem:
+  Exclude:
+    - 'Gemfile'
+
+# Offense count: 1
+Lint/IneffectiveAccessModifier:
+  Exclude:
+    - 'spec/models/custom_connection_snapshot.rb'
+
+# Offense count: 1
+# Configuration parameters: ContextCreatingMethods, MethodCreatingMethods.
+Lint/UselessAccessModifier:
+  Exclude:
+    - 'spec/models/custom_connection_snapshot.rb'
+
+# Offense count: 3
+Metrics/AbcSize:
+  Max: 34
+
+# Offense count: 5
+# Configuration parameters: CountComments, ExcludedMethods.
+Metrics/BlockLength:
+  Max: 145
+
+# Offense count: 1
+Metrics/CyclomaticComplexity:
+  Max: 8
+
+# Offense count: 42
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 192
+
+# Offense count: 3
+# Configuration parameters: CountComments.
+Metrics/MethodLength:
+  Max: 31
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ModuleLength:
+  Max: 147
+
+# Offense count: 1
+Metrics/PerceivedComplexity:
+  Max: 10
+
+# Offense count: 2
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/mongoid-collection-snapshot.rb'
+
+# Offense count: 1
+# Configuration parameters: ExpectMatchingDefinition, Regex, IgnoreExecutableScripts, AllowedAcronyms.
+# AllowedAcronyms: CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS
+Style/FileName:
+  Exclude:
+    - 'lib/mongoid-collection-snapshot.rb'

data/.travis.yml

@@ -0,0 +1,27 @@
+sudo: false
+
+matrix:
+  include:
+    - rvm: 2.3.1
+      env:
+        - MONGOID_VERSION=6
+      before_script:
+        - bundle exec danger
+    - rvm: 2.3.1
+      env:
+        - MONGOID_VERSION=5
+    - rvm: 2.2
+      env:
+        - MONGOID_VERSION=4
+    - rvm: 2.1
+      env:
+        - MONGOID_VERSION=3
+
+services: mongodb
+
+addons:
+  apt:
+    sources:
+      - mongodb-3.2-precise
+    packages:
+      - mongodb-org-server

data/CHANGELOG.md

@@ -0,0 +1,35 @@
+### 1.3.0 (1/20/2017)
+
+* [#2](https://github.com/mongoid/mongoid-collection-snapshot/pull/2): Support for Mongoid 6 - [@dblock](https://github.com/dblock).
+* [#1](https://github.com/mongoid/mongoid-collection-snapshot/pull/1): Gem renamed to mongoid-collection-snapshot and forked to the [mongoid org](https://github.com/mongoid) - [@dblock](https://github.com/dblock).
+* [#18](https://github.com/aaw/mongoid_collection_snapshot/pull/18): Fix: classes that include `Mongoid::CollectionSnapshot` can be inherited - [@dblock](https://github.com/dblock).
+* [#3](https://github.com/mongoid/mongoid-collection-snapshot/pull/3): Added Danger, PR linter - [@dblock](https://github.com/dblock).
+* [#4](https://github.com/mongoid/mongoid-collection-snapshot/pull/4): Added RuboCop - [@dblock](https://github.com/dblock).
+
+### 1.2.0
+
+* [#14](https://github.com/aaw/mongoid_collection_snapshot/pull/14): Compatibility with Mongoid 5 - [@dblock](https://github.com/dblock).
+
+### 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
+
+* [#8](https://github.com/aaw/mongoid_collection_snapshot/pull/8): Fixed .gemspec for compatibility with Mongoid 4.x - [@dblock](https://github.com/dblock).
+
+### 1.0.0
+
+* Expose `snapshot_session` for custom snapshot storage - [@joeyAghion](https://github.com/joeyAghion).
+* Compatibility with Mongoid 4.x - [@dblock](https://github.com/dblock).
+
+### 0.2.0
+
+* Added ability to maintain a snapshot of multiple collections atomically - [@aaw](https://github.com/aaw).
+* Added support for [Mongoid 3.0](https://github.com/mongoid/mongoid) - [@dblock](https://github.com/dblock).
+* Relaxed version limitations of [mongoid_slug](https://github.com/digitalplaywright/mongoid-slug) - [@dblock](https://github.com/dblock).
+
+### 0.1.0
+
+* Initial public release - [@aaw](https://github.com/aaw).

data/Dangerfile

@@ -0,0 +1 @@
+danger.import_dangerfile(gem: "mongoid-danger")

data/Gemfile

@@ -0,0 +1,24 @@
+source 'http://rubygems.org'
+
+gemspec
+
+case version = ENV['MONGOID_VERSION'] || '6.0'
+when /^6/
+  gem 'mongoid', '~> 6.0'
+when /^5/
+  gem 'mongoid', '~> 5.0'
+when /^4/
+  gem 'mongoid', '~> 4.0'
+when /^3/
+  gem 'mongoid', '~> 3.1'
+else
+  gem 'mongoid', version
+end
+
+group :development, :test do
+  gem 'mongoid-danger', '~> 0.1.1'
+  gem 'rake'
+  gem 'rspec', '~> 3.1'
+  gem 'rubocop', '0.47.1'
+  gem 'timecop'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2017 Art.sy Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,223 @@
+Mongoid Collection Snapshot
+===========================
+
+Easy maintenance of collections of processed data in MongoDB with Mongoid 3, 4, 5 and 6.
+
+This is a forked, renamed, maintained and supported version of [mongoid_collection_snapshot](https://github.com/aaw/mongoid_collection_snapshot).
+
+[![Gem Version](https://badge.fury.io/rb/mongoid-collection-snapshot.svg)](https://badge.fury.io/rb/mongoid-collection-snapshot)
+[![Build Status](https://travis-ci.org/mongoid/mongoid-collection-snapshot.svg)](https://travis-ci.org/mongoid/mongoid-collection-snapshot)
+
+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:
+
+    { 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:
+
+    { _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.
+
+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:
+
+``` ruby
+class AverageArtistPrice
+  include Mongoid::CollectionSnapshot
+
+  def build
+
+    map = <<-EOS
+      function() {
+        emit({ artist_id: this['artist_id']}, { count: 1, sum: this['price'] })
+      }
+    EOS
+
+    reduce = <<-EOS
+      function(key, values) {
+        var sum = 0;
+        var count = 0;
+        values.forEach(function(value) {
+          sum += value['sum'];
+          count += value['count'];
+        });
+        return({ count: count, sum: sum });
+      }
+    EOS
+
+    Artwork.map_reduce(map, reduce).out(inline: 1).each do |doc|
+      collection_snapshot.insert_one(
+        artist_id: doc['_id']['artist_id'],
+        count: doc['value']['count'],
+        sum: doc['value']['sum']
+      )
+    end
+  end
+end
+
+```
+
+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
+```
+
+The latest snapshot is always available as `AverageArtistPrice.latest`, so you can write code like:
+
+```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.
+
+By default, mongoid-collection-snapshot maintains the most recent two snapshots computed any given time.
+
+ery 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:
+
+``` ruby
+class ArtistStats
+  include Mongoid::CollectionSnapshot
+
+  def build
+    # ...
+    # 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'))
+  end
+
+  def average_price(artist)
+    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['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
+---------------------------
+
+Your class can specify a custom database for storage of collection snapshots by overriding the `snapshot_session` instance method. In this example, we memoize the connection at the class level to avoid creating many separate connection instances.
+
+```ruby
+class ArtistStats
+  include Mongoid::CollectionSnapshot
+
+  def build
+    # ...
+  end
+
+  def snapshot_session
+    self.class.snapshot_session
+  end
+
+  def self.snapshot_session
+    @@snapshot_session ||= Mongo::Client.new('mongodb://localhost:27017').tap do |c|
+      c.use :alternate_db
+    end
+  end
+end
+```
+
+Another common way of configuring this is through mongoid.yml.
+
+```yaml
+development:
+  sessions:
+    default:
+      database: dev_data
+    imports:
+      database: dev_imports
+```
+
+```ruby
+  def snapshot_session
+    Mongoid.session('imports')
+  end
+```
+
+License
+=======
+
+MIT License, see [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+require 'bundler'
+require 'bundler/gem_tasks'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts 'Run `bundle install` to install missing gems'
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
+
+task default: [:rubocop, :spec]

data/UPGRADING.md

@@ -0,0 +1,8 @@
+### Upgrading from 0.1.0 to >= 0.2.0
+
+When upgrading from 0.1.0 (pre-Mongoid 3.0) to 0.2.0 (Mongoid 3.x), you'll need to upgrade any existing snapshots created by mongoid_collection_snapshot 0.1.0 in your database before they're usable. You can do this by renaming the 'workspace_slug' attribute to 'slug' in MongoDB after upgrading. For example, to upgrade the snapshot class "MySnapshot", you'd enter the following at the mongo shell.
+
+```
+db.my_snapshot.rename({ 'workspace_slug' : { '$exists' : true } }, {'$rename' : {'workspace_slug' : 'slug' } })
+```
+

data/lib/mongoid-collection-snapshot.rb

@@ -0,0 +1,100 @@
+require 'mongoid-collection-snapshot/version'
+
+module Mongoid
+  module CollectionSnapshot
+    extend ActiveSupport::Concern
+
+    DEFAULT_COLLECTION_KEY_NAME = '*'.freeze
+
+    included do
+      require 'mongoid_slug'
+
+      include Mongoid::Document
+      include Mongoid::Timestamps::Created
+      include Mongoid::Slug
+
+      field :workspace_basename, default: 'snapshot'
+      slug :workspace_basename
+
+      field :max_collection_snapshot_instances, default: 2
+
+      before_create :build
+      after_create :ensure_at_most_two_instances_exist
+      before_destroy :drop_snapshot_collections
+
+      class_attribute :document_blocks
+      class_attribute :document_classes
+
+      # Mongoid documents on this snapshot.
+      def documents(name = nil)
+        self.class.document_classes ||= {}
+        class_name = "#{self.class.name}#{id}#{name}".underscore.camelize
+        key = "#{class_name}-#{name || DEFAULT_COLLECTION_KEY_NAME}"
+        self.class.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
+            if Mongoid::Compatibility::Version.mongoid5?
+              cattr_accessor :mongo_client
+            else
+              cattr_accessor :mongo_session
+            end
+            instance_eval(&document_block) if document_block
+            store_in collection: collection_name
+          end
+          if Mongoid::Compatibility::Version.mongoid6?
+            PersistenceContext.set(klass, database: snapshot_session.database.name)
+          elsif Mongoid::Compatibility::Version.mongoid5?
+            klass.mongo_client = snapshot_session
+          else
+            klass.mongo_session = snapshot_session
+          end
+          Object.const_set(class_name, klass)
+          klass
+        end
+      end
+    end
+
+    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
+
+    def collection_snapshot(name = nil)
+      if name
+        snapshot_session["#{collection.name}.#{name}.#{slug}"]
+      else
+        snapshot_session["#{collection.name}.#{slug}"]
+      end
+    end
+
+    def drop_snapshot_collections
+      collections = Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? snapshot_session.database.collections : snapshot_session.collections
+      collections.each do |collection|
+        collection.drop if collection.name =~ /^#{self.collection.name}\.([^\.]+\.)?#{slug}$/
+      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
+      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::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? Mongoid.default_client : Mongoid.default_session
+    end
+  end
+end

data/lib/mongoid-collection-snapshot/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module CollectionSnapshot
+    VERSION = '1.3.0'.freeze
+  end
+end

data/mongoid-collection-snapshot.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'mongoid-collection-snapshot/version'
+
+Gem::Specification.new do |s|
+  s.name = 'mongoid-collection-snapshot'
+  s.version = Mongoid::CollectionSnapshot::VERSION
+  s.authors = ['Aaron Windsor']
+  s.email = 'aaron.windsor@gmail.com'
+  s.platform = Gem::Platform::RUBY
+  s.required_rubygems_version = '>= 1.3.6'
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.homepage = 'http://github.com/mongoid/mongoid-collection-snapshot'
+  s.licenses = ['MIT']
+  s.summary = 'Easy maintenence of collections of processed data in MongoDB with the Mongoid ODM.'
+  s.add_dependency 'mongoid', '>= 3.0'
+  s.add_dependency 'mongoid-compatibility'
+  s.add_dependency 'mongoid-slug'
+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

@@ -0,0 +1,9 @@
+class Artwork
+  include Mongoid::Document
+
+  field :name
+  field :price
+
+  belongs_to :artist
+  belongs_to :partner
+end

data/spec/models/average_price.rb

@@ -0,0 +1,107 @@
+class AveragePrice
+  include Mongoid::CollectionSnapshot
+end
+
+class AverageArtistPrice < AveragePrice
+  document do
+    belongs_to :artist, inverse_of: nil
+    field :sum, type: Integer
+    field :count, type: Integer
+  end
+
+  def build
+    map = <<-EOS
+      function() {
+        emit({ artist_id: this['artist_id']}, { count: 1, sum: this['price'] })
+      }
+    EOS
+
+    reduce = <<-EOS
+      function(key, values) {
+        var sum = 0;
+        var count = 0;
+        values.forEach(function(value) {
+          sum += value['sum'];
+          count += value['count'];
+        });
+        return({ count: count, sum: sum });
+      }
+    EOS
+
+    Artwork.map_reduce(map, reduce).out(inline: 1).each do |doc|
+      if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+        collection_snapshot.insert_one(
+          artist_id: doc['_id']['artist_id'],
+          count: doc['value']['count'],
+          sum: doc['value']['sum']
+        )
+      else
+        collection_snapshot.insert(
+          artist_id: doc['_id']['artist_id'],
+          count: doc['value']['count'],
+          sum: doc['value']['sum']
+        )
+      end
+    end
+  end
+
+  def average_price(artist_name)
+    artist = Artist.where(name: artist_name).first
+    raise 'missing artist' unless artist
+    doc = documents.where(artist: artist).first
+    raise 'missing record' unless doc
+    doc.sum / doc.count
+  end
+end
+
+class AveragePartnerPrice < AveragePrice
+  document do
+    belongs_to :partner, inverse_of: nil
+    field :sum, type: Integer
+    field :count, type: Integer
+  end
+
+  def build
+    map = <<-EOS
+      function() {
+        emit({ partner_id: this['partner_id']}, { count: 1, sum: this['price'] })
+      }
+    EOS
+
+    reduce = <<-EOS
+      function(key, values) {
+        var sum = 0;
+        var count = 0;
+        values.forEach(function(value) {
+          sum += value['sum'];
+          count += value['count'];
+        });
+        return({ count: count, sum: sum });
+      }
+    EOS
+
+    Artwork.map_reduce(map, reduce).out(inline: 1).each do |doc|
+      if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+        collection_snapshot.insert_one(
+          partner_id: doc['_id']['partner_id'],
+          count: doc['value']['count'],
+          sum: doc['value']['sum']
+        )
+      else
+        collection_snapshot.insert(
+          partner_id: doc['_id']['partner_id'],
+          count: doc['value']['count'],
+          sum: doc['value']['sum']
+        )
+      end
+    end
+  end
+
+  def average_price(partner_name)
+    partner = Partner.where(name: partner_name).first
+    raise 'missing partner' unless partner
+    doc = documents.where(partner: partner).first
+    raise 'missing record' unless doc
+    doc.sum / doc.count
+  end
+end

data/spec/models/custom_connection_snapshot.rb

@@ -0,0 +1,33 @@
+class CustomConnectionSnapshot
+  include Mongoid::CollectionSnapshot
+
+  def self.snapshot_session
+    @snapshot_session ||= new_snapshot_session
+  end
+
+  def snapshot_session
+    self.class.snapshot_session
+  end
+
+  def build
+    if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+      collection_snapshot.insert_one('name' => 'foo')
+      collection_snapshot('foo').insert_one('name' => 'bar')
+    else
+      collection_snapshot.insert('name' => 'foo')
+      collection_snapshot('foo').insert('name' => 'bar')
+    end
+  end
+
+  private
+
+  def self.new_snapshot_session
+    if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+      Mongo::Client.new('mongodb://localhost:27017/snapshot_test')
+    else
+      Moped::Session.new(['127.0.0.1:27017']).tap do |session|
+        session.use :snapshot_test
+      end
+    end
+  end
+end

data/spec/models/multi_collection_snapshot.rb

@@ -0,0 +1,34 @@
+class MultiCollectionSnapshot
+  include Mongoid::CollectionSnapshot
+
+  document('foo') do
+    field :name, type: String
+    field :count, type: Integer
+  end
+
+  document('bar') do
+    field :name, type: String
+    field :number, type: Integer
+  end
+
+  document('baz') do
+    field :name, type: String
+    field :digit, type: Integer
+  end
+
+  def build
+    if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+      collection_snapshot('foo').insert_one('name' => 'foo!', count: 1)
+      collection_snapshot('bar').insert_one('name' => 'bar!', number: 2)
+      collection_snapshot('baz').insert_one('name' => 'baz!', digit: 3)
+    else
+      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
+  end
+
+  def names
+    %w(foo bar baz).map { |x| collection_snapshot(x).find.first['name'] }.join('')
+  end
+end

data/spec/models/partner.rb

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

data/spec/mongoid/collection_snapshot_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+module Mongoid
+  describe CollectionSnapshot do
+    it 'has a version' do
+      expect(Mongoid::CollectionSnapshot::VERSION).not_to be_nil
+    end
+
+    context 'creating a basic snapshot' do
+      let!(:gagosian) { Partner.create!(name: 'Gagosian') }
+      let!(:pace) { Partner.create!(name: 'Pace') }
+      let!(:andy_warhol) { Artist.create!(name: 'Andy Warhol') }
+      let!(:damien_hirst) { Artist.create!(name: 'Damien Hirst') }
+      let!(:flowers) { Artwork.create!(name: 'Flowers', partner: gagosian, artist: andy_warhol, price: 3_000_000) }
+      let!(:guns) { Artwork.create!(name: 'Guns', partner: pace, artist: andy_warhol, price: 1_000_000) }
+      let!(:vinblastine) { Artwork.create!(name: 'Vinblastine', partner: gagosian, artist: damien_hirst, price: 1_500_000) }
+
+      it 'returns nil if no snapshot has been created' do
+        expect(AverageArtistPrice.latest).to be_nil
+        expect(AveragePartnerPrice.latest).to be_nil
+      end
+
+      it 'runs the build method on creation for average artist price' do
+        snapshot = AverageArtistPrice.create
+        expect(snapshot.average_price('Andy Warhol')).to eq(2_000_000)
+        expect(snapshot.average_price('Damien Hirst')).to eq(1_500_000)
+      end
+
+      it 'runs the build method on creation for average partner price' do
+        snapshot = AveragePartnerPrice.create
+        expect(snapshot.average_price('Gagosian')).to eq(2_250_000)
+        expect(snapshot.average_price('Pace')).to eq(1_000_000)
+      end
+
+      it 'returns the most recent snapshot through the latest methods' do
+        first = AverageArtistPrice.create
+        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.
+        Timecop.travel(1.second.from_now)
+        second = AverageArtistPrice.create
+        expect(AverageArtistPrice.latest).to eq(second)
+        Timecop.travel(1.second.from_now)
+        third = AverageArtistPrice.create
+        expect(AverageArtistPrice.latest).to eq(third)
+      end
+
+      it 'maintains at most two of the latest snapshots to support its calculations' do
+        AverageArtistPrice.create
+        10.times do
+          AverageArtistPrice.create
+          expect(AverageArtistPrice.count).to eq(2)
+        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
+
+          snapshot = AveragePartnerPrice.create
+          expect(snapshot.documents.count).to eq 2
+          document = snapshot.documents.where(partner: pace).first
+          expect(document.partner).to eq pace
+          expect(document.count).to eq 1
+          expect(document.sum).to eq 1_000_000
+        end
+
+        it 'only creates one global class reference' do
+          3.times do
+            index = AverageArtistPrice.create
+            2.times { expect(index.documents.count).to eq 2 }
+            index = AveragePartnerPrice.create
+            2.times { expect(index.documents.count).to eq 2 }
+          end
+          expect(AveragePrice.document_classes).to be nil
+          expect(AverageArtistPrice.document_classes.count).to be >= 3
+          expect(AveragePartnerPrice.document_classes.count).to be >= 3
+        end
+      end
+    end
+
+    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 }
+        expect(MultiCollectionSnapshot.latest.names).to eq('foo!bar!baz!')
+      end
+
+      it 'safely cleans up all collections used by the snapshot' do
+        # Create some collections with names close to the snapshots we'll create
+        if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+          Mongoid.default_client["#{MultiCollectionSnapshot.collection.name}.do.not_delete"].insert_one('a' => 1)
+          Mongoid.default_client["#{MultiCollectionSnapshot.collection.name}.snapshorty"].insert_one('a' => 1)
+          Mongoid.default_client["#{MultiCollectionSnapshot.collection.name}.hello.1"].insert_one('a' => 1)
+        else
+          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)
+        end
+
+        MultiCollectionSnapshot.create
+        collections = Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? Mongoid.default_client.database.collections : Mongoid.default_session.collections
+        before_create = collections.map(&:name)
+        expect(before_create.length).to be > 0
+
+        Timecop.travel(1.second.from_now)
+        MultiCollectionSnapshot.create
+        collections = Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? Mongoid.default_client.database.collections : Mongoid.default_session.collections
+        after_create = collections.map(&:name)
+        collections_created = (after_create - before_create).sort
+        expect(collections_created.length).to eq(3)
+
+        MultiCollectionSnapshot.latest.destroy
+        collections = Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? Mongoid.default_client.database.collections : Mongoid.default_session.collections
+        after_destroy = collections.map(&:name)
+        collections_destroyed = (after_create - after_destroy).sort
+        expect(collections_created).to eq(collections_destroyed)
+      end
+    end
+
+    context 'with a custom snapshot connection' do
+      around(:each) do |example|
+        if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+          CustomConnectionSnapshot.snapshot_session.database.drop
+        else
+          CustomConnectionSnapshot.snapshot_session.drop
+        end
+        example.run
+        if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+          CustomConnectionSnapshot.snapshot_session.database.drop
+        else
+          CustomConnectionSnapshot.snapshot_session.drop
+        end
+      end
+
+      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|
+          session = Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6? ? Mongoid.default_client : Mongoid.default_session
+          expect(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
+          if Mongoid::Compatibility::Version.mongoid6?
+            expect(CustomConnectionSnapshot.new.documents.database_name).to eq :snapshot_test
+          elsif Mongoid::Compatibility::Version.mongoid5?
+            expect(CustomConnectionSnapshot.new.documents.mongo_client).to eq CustomConnectionSnapshot.snapshot_session
+          else
+            expect(CustomConnectionSnapshot.new.documents.mongo_session).to eq CustomConnectionSnapshot.snapshot_session
+          end
+        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

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rspec'
+
+require 'mongoid'
+require 'timecop'
+
+Mongoid.configure do |config|
+  config.connect_to('mongoid-collection-snapshot_test')
+end
+
+require File.expand_path('../../lib/mongoid-collection-snapshot', __FILE__)
+Dir["#{File.dirname(__FILE__)}/models/**/*.rb"].each { |f| require f }
+
+require 'mongoid-compatibility'
+
+RSpec.configure do |c|
+  c.before(:all) do
+    Mongoid.logger.level = Logger::INFO
+    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+  end
+  c.before(:each) do
+    Mongoid.purge!
+  end
+  c.after(:all) do
+    if Mongoid::Compatibility::Version.mongoid5? || Mongoid::Compatibility::Version.mongoid6?
+      Mongoid.default_client.database.drop
+    else
+      Mongoid.default_session.drop
+    end
+  end
+end
+
+RSpec.configure(&:raise_errors_for_deprecations!)

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-collection-snapshot
+version: !ruby/object:Gem::Version
+  version: 1.3.0
+platform: ruby
+authors:
+- Aaron Windsor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-20 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-compatibility
+  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'
+- !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: 
+email: aaron.windsor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Dangerfile
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- UPGRADING.md
+- 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_price.rb
+- spec/models/custom_connection_snapshot.rb
+- spec/models/multi_collection_snapshot.rb
+- spec/models/partner.rb
+- spec/mongoid/collection_snapshot_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/mongoid/mongoid-collection-snapshot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Easy maintenence of collections of processed data in MongoDB with the Mongoid
+  ODM.
+test_files: []