mongoid-versioning 0.1.0

data/.gitignore

@@ -0,0 +1,25 @@
+# Because this is a gem, ignore Gemfile.lock:
+
+Gemfile.lock
+
+# And because this is Ruby, ignore the following
+#  (source: https://github.com/github/gitignore/blob/master/Ruby.gitignore):
+
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# 0.1.0 (February 26, 2013)
+* First public version.

data/Gemfile

@@ -0,0 +1,7 @@
+ruby '1.9.3'
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec'
+gem 'rake'

data/README.md

@@ -0,0 +1,73 @@
+# mongoid-versioning
+
+Mongoid supports simple versioning through inclusion of the `Mongoid::Versioning` module. Including this module will create a versions embedded relation on the document that it will append to on each save. It will also update the version number on the document, which is an integer.
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'mongoid-versioning'
+```
+
+## Usage
+
+```ruby
+class Person
+  include Mongoid::Document
+  include Mongoid::Versioning
+end
+```
+
+You can also set a `max_versions` setting, and Mongoid will only keep the max most recent versions.
+
+```ruby
+class Person
+  include Mongoid::Document
+  include Mongoid::Versioning
+
+  # keep at most 5 versions of a record
+  max_versions 5
+end
+```
+
+You may skip versioning at any point in time by wrapping the persistence call in a `versionless` block.
+
+```ruby
+person.versionless do |doc|
+  doc.update_attributes(name: "Theodore")
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Copyright
+
+(The MIT license)
+
+Copyright (c) 2013 Mario Uher
+
+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/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+task default: :test

data/lib/mongoid/versioning.rb

@@ -0,0 +1,217 @@
+# encoding: utf-8
+module Mongoid
+
+  # Include this module to get automatic versioning of root level documents.
+  # This will add a version field to the +Document+ and a has_many association
+  # with all the versions contained in it.
+  module Versioning
+    extend ActiveSupport::Concern
+
+    included do
+      field :version, type: Integer, default: 1
+
+      embeds_many \
+        :versions,
+        class_name: self.name,
+        validate: false,
+        cyclic: true,
+        inverse_of: nil,
+        versioned: true
+
+      set_callback :save, :before, :revise, if: :revisable?
+
+      class_attribute :version_max
+      self.cyclic = true
+    end
+
+    # Create a new version of the +Document+. This will load the previous
+    # document from the database and set it as the next version before saving
+    # the current document. It then increments the version number. If a #max_versions
+    # limit is set in the model and it's exceeded, the oldest version gets discarded.
+    #
+    # @example Revise the document.
+    #   person.revise
+    #
+    # @since 1.0.0
+    def revise
+      previous = previous_revision
+      if previous && versioned_attributes_changed?
+        new_version = versions.build(
+          previous.versioned_attributes, without_protection: true
+        )
+        new_version._id = nil
+        if version_max.present? && versions.length > version_max
+          deleted = versions.first
+          if deleted.paranoid?
+            versions.delete_one(deleted)
+            collection.find(atomic_selector).
+              update({ "$pull" => { "versions" => { "version" => deleted.version }}})
+          else
+            versions.delete(deleted)
+          end
+        end
+        self.version = (version || 1 ) + 1
+      end
+    end
+
+    # Forces the creation of a new version of the +Document+, regardless of
+    # whether a change was actually made.
+    #
+    # @example Revise the document.
+    #   person.revise!
+    #
+    # @since 2.2.1
+    def revise!
+      versions.build(
+        (previous_revision || self).versioned_attributes, without_protection: true
+      )
+      versions.shift if version_max.present? && versions.length > version_max
+      self.version = (version || 1 ) + 1
+      save
+    end
+
+    # Filters the results of +changes+ by removing any fields that should
+    # not be versioned.
+    #
+    # @return [ Hash ] A hash of versioned changed attributes.
+    #
+    # @since 2.1.0
+    def versioned_changes
+      only_versioned_attributes(changes.except("updated_at"))
+    end
+
+    # Filters the results of +attributes+ by removing any fields that should
+    # not be versioned.
+    #
+    # @return [ Hash ] A hash of versioned attributes.
+    #
+    # @since 2.1.0
+    def versioned_attributes
+      only_versioned_attributes(attributes)
+    end
+
+    # Check if any versioned fields have been modified. This is similar
+    # to +changed?+, except this method also ignores fields set to be
+    # ignored by versioning.
+    #
+    # @return [ Boolean ] Whether fields that will be versioned have changed.
+    #
+    # @since 2.1.0
+    def versioned_attributes_changed?
+      !versioned_changes.empty?
+    end
+
+    # Executes a block that temporarily disables versioning. This is for cases
+    # where you do not want to version on every save.
+    #
+    # @example Execute a save without versioning.
+    #   person.versionless(&:save)
+    #
+    # @return [ Object ] The document or result of the block execution.
+    #
+    # @since 2.0.0
+    def versionless
+      @versionless = true
+      result = yield(self) if block_given?
+      @versionless = false
+      result || self
+    end
+
+    private
+
+    # Find the previous version of this document in the database, or if the
+    # document had been saved without versioning return the persisted one.
+    #
+    # @example Find the last version.
+    #   document.find_last_version
+    #
+    # @return [ Document, nil ] The previously saved document.
+    #
+    # @since 2.0.0
+    def previous_revision
+      _loading_revision do
+        self.class.unscoped.
+          where(_id: id).
+          any_of({ version: version }, { version: nil }).first
+      end
+    end
+
+    # Is the document able to be revised? This is true if the document has
+    # changed and we have not explicitly told it not to version.
+    #
+    # @example Is the document revisable?
+    #   document.revisable?
+    #
+    # @return [ true, false ] If the document is revisable.
+    #
+    # @since 2.0.0
+    def revisable?
+      versioned_attributes_changed? && !versionless?
+    end
+
+    # Are we in versionless mode? This is true if in a versionless block on the
+    # document.
+    #
+    # @example Is the document in versionless mode?
+    #   document.versionless?
+    #
+    # @return [ true, false ] Is the document not currently versioning.
+    #
+    # @since 2.0.0
+    def versionless?
+      @versionless ||= false
+    end
+
+    # Filters fields that should not be versioned out of an attributes hash.
+    # Dynamic attributes are always versioned.
+    #
+    # @param [ Hash ] A hash with field names as keys.
+    #
+    # @return [ Hash ] The hash without non-versioned columns.
+    #
+    # @since 2.1.0
+    def only_versioned_attributes(hash)
+      versioned = {}
+      hash.except("versions").each_pair do |name, value|
+        add_versioned_attribute(versioned, name, value)
+      end
+      versioned
+    end
+
+    # Add the versioned attribute. Will work now for localized fields.
+    #
+    # @api private
+    #
+    # @example Add the versioned attribute.
+    #   model.add_versioned_attribute({}, "name", "test")
+    #
+    # @param [ Hash ] versioned The versioned attributes.
+    # @param [ String ] name The name of the field.
+    # @param [ Object ] value The value for the field.
+    #
+    # @since 3.0.10
+    def add_versioned_attribute(versioned, name, value)
+      field = fields[name]
+      if field && field.localized?
+        versioned["#{name}_translations"] = value
+      else
+        versioned[name] = value if !field || field.versioned?
+      end
+    end
+
+    module ClassMethods
+
+      # Sets the maximum number of versions to store.
+      #
+      # @example Set the maximum.
+      #   Person.max_versions(5)
+      #
+      # @param [ Integer ] number The maximum number to store.
+      #
+      # @return [ Integer ] The max number of versions.
+      def max_versions(number)
+        self.version_max = number.to_i
+      end
+    end
+  end
+end

data/lib/mongoid/versioning/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Versioning
+    VERSION = '0.1.0'
+  end
+end

data/mongoid-versioning.gemspec

@@ -0,0 +1,18 @@
+$: << File.expand_path('../lib', __FILE__)
+require 'mongoid/versioning/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'mongoid-versioning'
+  gem.version       = Mongoid::Versioning::VERSION
+  gem.authors       = 'Mario Uher'
+  gem.email         = 'uher.mario@gmail.com'
+  gem.homepage      = 'https://github.com/haihappen/mongoid-versioning'
+  gem.summary       = 'Extraction of mongoid-versioning into its own gem.'
+  gem.description   = "Mongoid supports simple versioning through inclusion of the Mongoid::Versioning module."
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.require_path  = 'lib'
+
+  gem.add_dependency 'activesupport'
+  gem.add_dependency 'mongoid'
+end

data/spec/app/models/account.rb

@@ -0,0 +1,32 @@
+class Account
+  include Mongoid::Document
+
+  field :_id, type: String, default: ->{ name.try(:parameterize) }
+
+  field :number, type: String
+  field :balance, type: String
+  field :nickname, type: String
+  field :name, type: String
+  field :balanced, type: Boolean, default: ->{ balance? ? true : false }
+
+  field :overridden, type: String
+
+  embeds_many :memberships
+  belongs_to :creator, class_name: "User", foreign_key: :creator_id
+  belongs_to :person
+  has_many :alerts
+  has_and_belongs_to_many :agents
+  has_one :comment, validate: false
+
+  attr_accessible :nickname, as: [ :default, :admin ]
+  attr_accessible :name, as: [ :default, :admin ]
+  attr_accessible :balance, as: :default
+
+  validates_presence_of :name
+  validates_presence_of :nickname, on: :upsert
+  validates_length_of :name, maximum: 10, on: :create
+
+  def overridden
+    self[:overridden] = "not recommended"
+  end
+end

data/spec/app/models/acolyte.rb

@@ -0,0 +1,16 @@
+class Acolyte
+  include Mongoid::Document
+  field :status
+  field :name
+
+  embeds_many :versions, as: :memorable
+  belongs_to :church
+
+  default_scope asc(:name)
+  scope :active, ->{ where(status: "active") }
+  scope :named, ->{ where(:name.exists => true) }
+
+  def callback_test?
+    name == "callback-test"
+  end
+end

data/spec/app/models/actor.rb

@@ -0,0 +1,19 @@
+class Actor
+  include Mongoid::Document
+  field :name
+  field :after_custom_count, type: Integer, default: 0
+  has_and_belongs_to_many :tags
+  embeds_many :things, validate: false, cascade_callbacks: true
+  accepts_nested_attributes_for :things, allow_destroy: true
+
+  define_model_callbacks :custom
+  observable :custom
+
+  def do_something
+    run_callbacks(:custom) do
+      self.name = "custom"
+    end
+  end
+end
+
+require "app/models/actress"

data/spec/app/models/actor_observer.rb

@@ -0,0 +1,15 @@
+class ActorObserver < Mongoid::Observer
+  attr_reader :last_after_create_record
+
+  def after_create(record)
+    @last_after_create_record = record
+  end
+
+  def after_custom(record)
+    record.after_custom_count += 1
+  end
+
+  def before_custom(record)
+    @after_custom_called = true
+  end
+end