mongoid-versioning 0.2.0 → 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e909070135c192cc4bbdd0c62416daed6d33d837
+  data.tar.gz: 2481913b87525fa8e554283d395ef52f189319af
+SHA512:
+  metadata.gz: 1528b23826c4709c66b7ea37649408040d2eb2a3f0748fb03094459a3f2f1ed887d7234822bab9310c6677122b0581913c3b17b4de04f57fe5e6cd29634e3981
+  data.tar.gz: fffbba7feefc13c2f2298cc23b7e935c9bbca28059705507d908449c1eb0ebcd5b3e69f79f210b571851ac7526ba38e4a3022659df9f348c76a82dea4431f1e3

data/.travis.yml

@@ -0,0 +1,20 @@
+language: ruby
+
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+
+gemfile:
+  - Gemfile
+  - gemfiles/mongoid_master.gemfile
+
+branches:
+  only:
+    - master
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - gemfile: gemfiles/mongoid_master.gemfile

data/CHANGELOG.md

@@ -1,3 +1,6 @@
+# Upcoming
+* Fixes paths for Travis.
+
 # 0.2.0 (May 11, 2013)
 * Added info.
 * Fixed dependencies.

data/Gemfile

@@ -1,7 +1,8 @@
-ruby '1.9.3'
 source 'https://rubygems.org'
 
 gemspec
 
 gem 'rspec'
 gem 'rake'
+
+gem 'mongoid-paranoia', '1.0.0.beta1'

data/README.md

@@ -1,4 +1,5 @@
-# mongoid-versioning
+# mongoid-versioning [![Build Status](https://travis-ci.org/haihappen/mongoid-versioning.png)](https://travis-ci.org/haihappen/mongoid-versioning)
+
 **Important:** This gem is an extraction of [Mongoid::Versioning](http://mongoid.org/en/mongoid/docs/extras.html#versioning) from the official [mongoid](http://mongoid.org) gem. Since Mongoid::Versioning will be removed in the upcoming `4.0.0` release of mongoid, this gem re-enables the functionality of versioned documents.
 
 **Please submit only bug and security fixes**. Neighter I will accept new features nor changes to exiting APIs. Please consider forking the project if you want new features to appear! :)

data/Rakefile

@@ -1,7 +1,5 @@
-require 'rake/testtask'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new do |t|
-  t.test_files = FileList['spec/**/*_spec.rb']
-end
+RSpec::Core::RakeTask.new(:spec)
 
-task default: :test
+task default: :spec

data/gemfiles/mongoid_master.gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'mongoid', github: 'mongoid/mongoid'
+
+gem 'rspec'
+gem 'rake'

data/lib/mongoid/config/locales/en.yml

@@ -0,0 +1,11 @@
+en:
+  mongoid:
+    errors:
+      messages:
+        versioning_not_on_root:
+          message: "Versioning not allowed on embedded document: %{klass}."
+          summary: "Mongoid::Versioning behaviour is only allowed on documents
+            that are the root document in the hierarchy."
+          resolution: "Remove the versioning from the embedded %{klass} or
+            consider moving it to a root location in the hierarchy if
+            versioning is needed."

data/lib/mongoid/core_ext/errors/versioning_not_on_root.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid
+  module Errors
+
+    # This error is raised when attempting to version an embedded document.
+    class VersioningNotOnRoot < MongoidError
+
+      # Create the new error.
+      #
+      # @example Create the new error.
+      #   VersioningNotOnRoot.new(Address)
+      #
+      # @param [ Class ] klass The embedded class.
+      #
+      # @since 3.0.0
+      def initialize(klass)
+        super(
+          compose_message("versioning_not_on_root", { klass: klass })
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/fields/standard.rb

@@ -0,0 +1,17 @@
+module Mongoid
+  module Fields
+    class Standard
+      # Is this field included in versioned attributes?
+      #
+      # @example Is the field versioned?
+      #   field.versioned?
+      #
+      # @return [ true, false ] If the field is included in versioning.
+      #
+      # @since 2.1.0
+      def versioned?
+        @versioned ||= (options[:versioned].nil? ? true : options[:versioned])
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/fields/validators/macro.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module Fields
+    module Validators
+      module Macro
+        options = OPTIONS
+        send :remove_const, :OPTIONS
+        send :const_set, :OPTIONS, options + [:versioned]
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/hierarchy.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module Hierarchy
+    # Collect all the children of this document.
+    #
+    # @example Collect all the children.
+    #   document.collect_children
+    #
+    # @return [ Array<Document> ] The children.
+    #
+    # @since 2.4.0
+    def collect_children
+      children = []
+      embedded_relations.each_pair do |name, metadata|
+        without_autobuild do
+          child = send(name)
+          Array.wrap(child).each do |doc|
+            children.push(doc)
+            children.concat(doc._children) unless metadata.versioned?
+          end if child
+        end
+      end
+      children
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/bindings/embedded/many.rb

@@ -0,0 +1,31 @@
+module Mongoid
+  module Relations
+    module Bindings
+      module Embedded
+        class Many < Binding
+          # Binds a single document with the inverse relation. Used
+          # specifically when appending to the proxy.
+          #
+          # @example Bind one document.
+          #   person.addresses.bind_one(address)
+          #
+          # @param [ Document ] doc The single document to bind.
+          # @param [ Hash ] options The binding options.
+          #
+          # @option options [ true, false ] :continue Continue binding the inverse.
+          # @option options [ true, false ] :binding Are we in build mode?
+          #
+          # @since 2.0.0.rc.1
+          def bind_one(doc)
+            doc.parentize(base)
+            binding do
+              unless metadata.versioned?
+                doc.do_or_do_not(metadata.inverse_setter(target), base)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/cascading.rb

@@ -0,0 +1,23 @@
+module Mongoid
+  module Relations
+    module Cascading
+      # Perform all cascading deletes, destroys, or nullifies. Will delegate to
+      # the appropriate strategy to perform the operation.
+      #
+      # @example Execute cascades.
+      #   document.cascade!
+      #
+      # @since 2.0.0.rc.1
+      def cascade!
+        cascades.each do |name|
+          if !relation_metadata || !relation_metadata.versioned?
+            if meta = relations[name]
+              strategy = meta.cascade_strategy
+              strategy.new(self, meta).cascade if strategy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/embedded/batchable.rb

@@ -0,0 +1,36 @@
+module Mongoid
+  module Relations
+    module Embedded
+      module Batchable
+        # Pre process the batch removal.
+        #
+        # @api private
+        #
+        # @example Pre process the documents.
+        #   batchable.pre_process_batch_remove(docs, :delete)
+        #
+        # @param [ Array<Document> ] docs The documents.
+        # @param [ Symbol ] method Delete or destroy.
+        #
+        # @return [ Array<Hash> ] The documents as hashes.
+        #
+        # @since 3.0.0
+        def pre_process_batch_remove(docs, method)
+          docs.map do |doc|
+            self.path = doc.atomic_path unless path
+            execute_callback :before_remove, doc
+            if !_assigning? && !metadata.versioned?
+              doc.cascade!
+              doc.run_before_callbacks(:destroy) if method == :destroy
+            end
+            target.delete_one(doc)
+            _unscoped.delete_one(doc)
+            unbind_one(doc)
+            execute_callback :after_remove, doc
+            doc.as_document
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/embedded/many.rb

@@ -0,0 +1,24 @@
+module Mongoid
+  module Relations
+    module Embedded
+      class Many < Relations::Many
+        class << self
+          # Get the valid options allowed with this relation.
+          #
+          # @example Get the valid options.
+          #   Relation.valid_options
+          #
+          # @return [ Array<Symbol> ] The valid options.
+          #
+          # @since 2.1.0
+          def valid_options
+            [
+              :as, :cascade_callbacks, :cyclic, :order, :versioned, :store_as,
+              :before_add, :after_add, :before_remove, :after_remove
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/macros.rb

@@ -0,0 +1,39 @@
+module Mongoid
+  module Relations
+    module Macros
+      module ClassMethods
+        # Adds the relation back to the parent document. This macro is
+        # necessary to set the references from the child back to the parent
+        # document. If a child does not define this relation calling
+        # persistence methods on the child object will cause a save to fail.
+        #
+        # @example Define the relation.
+        #
+        #   class Person
+        #     include Mongoid::Document
+        #     embeds_many :addresses
+        #   end
+        #
+        #   class Address
+        #     include Mongoid::Document
+        #     embedded_in :person
+        #   end
+        #
+        # @param [ Symbol ] name The name of the relation.
+        # @param [ Hash ] options The relation options.
+        # @param [ Proc ] block Optional block for defining extensions.
+        def embedded_in(name, options = {}, &block)
+          if ancestors.include?(Mongoid::Versioning)
+            raise Errors::VersioningNotOnRoot.new(self)
+          end
+          meta = characterize(name, Embedded::In, options, &block)
+          self.embedded = true
+          relate(name, meta)
+          builder(name, meta).creator(name, meta)
+          add_counter_cache_callbacks(meta) if meta.counter_cached?
+          meta
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/metadata.rb

@@ -0,0 +1,63 @@
+module Mongoid
+  module Relations
+    class Metadata < Hash
+      # Since a lot of the information from the metadata is inferred and not
+      # explicitly stored in the hash, the inspection needs to be much more
+      # detailed.
+      #
+      # @example Inspect the metadata.
+      #   metadata.inspect
+      #
+      # @return [ String ] Oodles of information in a nice format.
+      #
+      # @since 2.0.0.rc.1
+      def inspect
+%Q{#<Mongoid::Relations::Metadata
+  autobuild:    #{autobuilding?}
+  class_name:   #{class_name}
+  cyclic:       #{cyclic.inspect}
+  counter_cache:#{counter_cached?}
+  dependent:    #{dependent.inspect}
+  inverse_of:   #{inverse_of.inspect}
+  key:          #{key}
+  macro:        #{macro}
+  name:         #{name}
+  order:        #{order.inspect}
+  polymorphic:  #{polymorphic?}
+  relation:     #{relation}
+  setter:       #{setter}
+  versioned:    #{versioned?}>
+}
+      end
+
+      # Is this relation using Mongoid's internal versioning system?
+      #
+      # @example Is this relation versioned?
+      #   metadata.versioned?
+      #
+      # @return [ true, false ] If the relation uses Mongoid versioning.
+      #
+      # @since 2.1.0
+      def versioned?
+        !!self[:versioned]
+      end
+
+      # Get the inverse relation candidates.
+      #
+      # @api private
+      #
+      # @example Get the inverse relation candidates.
+      #   metadata.inverse_relation_candidates
+      #
+      # @return [ Array<Metdata> ] The candidates.
+      #
+      # @since 3.0.0
+      def inverse_relation_candidates
+        relations_metadata.select do |meta|
+          next if meta.versioned? || meta.name == name
+          meta.class_name == inverse_class_name
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/relations/options.rb

@@ -0,0 +1,9 @@
+module Mongoid
+  module Relations
+    module Options
+      common = COMMON
+      send :remove_const, :COMMON
+      send :const_set, :COMMON, common + [:versioned]
+    end
+  end
+end

data/lib/mongoid/core_ext/threaded/lifecycle.rb

@@ -0,0 +1,37 @@
+module Mongoid
+  module Threaded
+    module Lifecycle
+      private
+      # Execute a block in loading revision mode.
+      #
+      # @example Execute in loading revision mode.
+      #   _loading_revision do
+      #     load_revision
+      #   end
+      #
+      # @return [ Object ] The return value of the block.
+      #
+      # @since 2.3.4
+      def _loading_revision
+        Threaded.begin_execution("load_revision")
+        yield
+      ensure
+        Threaded.exit_execution("load_revision")
+      end
+
+      module ClassMethods
+        # Is the current thread in loading revision mode?
+        #
+        # @example Is the current thread in loading revision mode?
+        #   proxy._loading_revision?
+        #
+        # @return [ true, false ] If the thread is loading a revision.
+        #
+        # @since 2.3.4
+        def _loading_revision?
+          Threaded.executing?("load_revision")
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/core_ext/versioning.rb

@@ -0,0 +1,218 @@
+# 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
+        )
+        new_version._id = nil
+        if version_max.present? && versions.length > version_max
+          deleted = versions.first
+          if deleted.respond_to?(:paranoid?) && 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
+      )
+      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.
+          with(self.mongo_session.options).
+          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

@@ -1,5 +1,5 @@
 module Mongoid
   module Versioning
-    VERSION = '0.2.0'
+    VERSION = '1.0.0.beta1'
   end
 end