mongoid_relations_dirty_tracking 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 9bd7befbb1f28738d4b2466c5fee8a4f73f82eb2
-  data.tar.gz: 5f86d528912d3a3a90e3306ac8b60069a90cea37
+SHA256:
+  metadata.gz: b6043c61085a0af72034235ae1c4f3b886c08d6c4c913878a21fe3233e5f90dc
+  data.tar.gz: 20772362d9765d4a3138ce1324421fc427071102ded5facb7f0ebec35d4237e6
 SHA512:
-  metadata.gz: f5f28400a832ca7b5627ce13b4aea1c2c7ba91a885c8b23ab71b76034ba8a59fb4df070f713b6d2430e5abf494c76cb6bd57dfb06f368423dc50bd106306bea2
-  data.tar.gz: 3d61e3f9e0a3461996150562c9321545d8cb9c3f9ea8bace95d28c709645126360cb4571ef8f244535b34d16adf7963f3fd2e8c8b1aecd8d3a2c82fd4fba4d42
+  metadata.gz: 17563973f5795355ae46f49a7dd304b9c24c72107d0c7f6e45220a5e106b35810342916ae7948be6dc7da5ec9aed6b433da55b09db3f49077243d224e134b4ed
+  data.tar.gz: 7a9f3391196fe7333d7a0ff08047fdce013d626159eaea8013d2a243e3ebd3aced43d080046419aec5e77f234145e3ca120084558a25b81d8d29d1b6ab968842

data/{LICENSE.txt → LICENSE}

@@ -1,22 +1,22 @@
-Copyright (c) 2013 David Sevcik
-
-MIT License
-
-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.
+Copyright (c) 2013 David Sevcik
+
+MIT License
+
+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

@@ -1,51 +1,80 @@
-# Mongoid::RelationsDirtyTracking
-
-Mongoid extension for tracking changes on document relations.
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'mongoid_relations_dirty_tracking', github: 'versative/mongoid_relations_dirty_tracking'
-
-And then execute:
-
-    $ bundle
-
-## Usage
-
-```ruby
-class SampleDocument
-  include Mongoid::Document
-  include Mongoid::RelationsDirtyTracking
-
-  embeds_one  :foo
-  has_many    :bars
-
-  field :title, type: String
-end
-
-doc = SampleDocument.create
-doc.foo = Foo.new(title: 'foo')
-doc.bars << Bar.new(title: 'bar')
-doc.title = 'New title'
-
-doc.relations_changed?  # => true
-doc.relation_changes    # => {"foo" => [nil, {"_id"=>"524c35ad1ac1c23084000040", "title" => "foo"}], "bars" => [nil, [{"_id"=>"524c35ad1ac1c23084000083"}]]}
-doc.changed?            # => true
-doc.changes             # => {"title" => [nil, "New title"], "foo" => [nil, {"_id"=>"524c35ad1ac1c23084000040", "title" => "foo"}], "bars" => [nil, [{"_id"=>"524c35ad1ac1c23084000083"}]]}
-
-doc.save
-doc.relations_changed?  # => false
-doc.relation_changes    # => {}
-doc.changed?            # => false
-doc.changes             # => {}
-```
-
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+# Mongoid::RelationsDirtyTracking
+
+Mongoid extension for tracking changes on document relations.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongoid_relations_dirty_tracking'
+```
+
+## Version Support
+
+This gem is CI tested using:
+
+- Rails 5.1, 5.2, and 6.0
+- Mongoid 7.0 and 7.1
+
+## Usage
+
+```ruby
+class SampleDocument
+  include Mongoid::Document
+  include Mongoid::RelationsDirtyTracking
+
+  embeds_one  :foo
+  has_many    :bars
+
+  field :title, type: String
+end
+
+doc = SampleDocument.create
+doc.foo = Foo.new(title: 'foo')
+doc.bars << Bar.new(title: 'bar')
+doc.title = 'New title'
+
+doc.relations_changed?      # => true
+doc.relation_changes        # => {"foo" => [nil, {"_id"=>"524c35ad1ac1c23084000040", "title" => "foo"}], "bars" => [nil, [{"_id"=>"524c35ad1ac1c23084000083"}]]}
+doc.changed_with_relations? # => true
+doc.changes_with_relations  # => {"title" => [nil, "New title"], "foo" => [nil, {"_id"=>"524c35ad1ac1c23084000040", "title" => "foo"}], "bars" => [nil, [{"_id"=>"524c35ad1ac1c23084000083"}]]}
+
+doc.save
+doc.relations_changed?      # => false
+doc.relation_changes        # => {}
+doc.changed_with_relations? # => false
+doc.changes_with_relations  # => {}
+```
+
+### Global Disable
+
+Relations dirty tracking can be resource intensive.
+You may disable it for a block scope. This is thread-safe
+and will use the [RequestStore gem](https://github.com/steveklabnik/request_store)
+if it is included in your project.
+
+```ruby
+Mongoid::RelationsDirtyTracking.disable do
+  doc = SampleDocument.create
+  doc.foo = Foo.new(title: 'foo')
+  doc.bars << Bar.new(title: 'bar')
+
+  doc.relations_changed?      # => false
+  doc.relation_changes        # => {}
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Attribution
+
+Created 2013 by David Sevcik
+
+Maintenance from 2020 onward provided by [TableCheck](https://www.tablecheck.com/en/company/)

data/lib/mongoid/relations_dirty_tracking.rb

@@ -1,108 +1,124 @@
-require 'mongoid'
-require 'active_support/concern'
-require 'active_support/core_ext/module/aliasing'
-
-
-module Mongoid
-  module RelationsDirtyTracking
-    extend ActiveSupport::Concern
-
-    included do
-      after_initialize  :store_relations_shadow
-      after_save        :store_relations_shadow
-
-      alias_method_chain :changes, :relations
-      alias_method_chain :changed?, :relations
-
-      cattr_accessor :relations_dirty_tracking_options
-      self.relations_dirty_tracking_options = { only: [], except: ['versions'] }
-
-      if self.include? Mongoid::Versioning
-        include Mongoid::RelationsDirtyTracking::Versioning
-      end
-    end
-
-
-    def store_relations_shadow
-      @relations_shadow = {}
-      self.class.tracked_relations.each do |rel_name|
-        @relations_shadow[rel_name] = tracked_relation_attributes(rel_name)
-      end
-    end
-
-
-    def relation_changes
-      changes = {}
-      @relations_shadow.each_pair do |rel_name, shadow_values|
-        current_values = tracked_relation_attributes(rel_name)
-        if current_values != shadow_values
-          changes[rel_name] = [shadow_values, current_values]
-        end
-      end
-      changes
-    end
-
-
-    def relations_changed?
-      !relation_changes.empty?
-    end
-
-
-    def changed_with_relations?
-      changed_without_relations? or relations_changed?
-    end
-
-
-    def changes_with_relations
-      (changes_without_relations || {}).merge relation_changes
-    end
-
-
-    def tracked_relation_attributes(rel_name)
-      rel_name = rel_name.to_s
-      values = nil
-      if meta = relations[rel_name]
-        values = if meta.relation == Mongoid::Relations::Embedded::One
-          send(rel_name) && send(rel_name).attributes.clone.delete_if {|key, _| key == 'updated_at' }
-        elsif meta.relation == Mongoid::Relations::Embedded::Many
-          send(rel_name) && send(rel_name).map {|child| child.attributes.clone.delete_if {|key, _| key == 'updated_at' } }
-        elsif meta.relation == Mongoid::Relations::Referenced::One
-          send(rel_name) && { "#{meta.key}" => send(rel_name)[meta.key] }
-        elsif meta.relation == Mongoid::Relations::Referenced::Many
-          send("#{rel_name.singularize}_ids").map {|id| { "#{meta.key}" => id } }
-        elsif meta.relation == Mongoid::Relations::Referenced::ManyToMany
-          send("#{rel_name.singularize}_ids").map {|id| { "#{meta.primary_key}" => id } }
-        elsif meta.relation == Mongoid::Relations::Referenced::In
-          send(meta.foreign_key) && { "#{meta.foreign_key}" => send(meta.foreign_key)}
-        end
-      end
-      values
-    end
-
-
-    module ClassMethods
-
-      def relations_dirty_tracking(options = {})
-        relations_dirty_tracking_options[:only] += [options[:only] || []].flatten.map(&:to_s)
-        relations_dirty_tracking_options[:except] += [options[:except] || []].flatten.map(&:to_s)
-      end
-
-
-      def track_relation?(rel_name)
-        rel_name = rel_name.to_s
-        options = relations_dirty_tracking_options
-        to_track = (!options[:only].blank? && options[:only].include?(rel_name)) \
-          || (options[:only].blank? && !options[:except].include?(rel_name))
-
-        to_track && [Mongoid::Relations::Embedded::One, Mongoid::Relations::Embedded::Many,
-          Mongoid::Relations::Referenced::One, Mongoid::Relations::Referenced::Many,
-          Mongoid::Relations::Referenced::ManyToMany, Mongoid::Relations::Referenced::In].include?(relations[rel_name].try(:relation))
-      end
-
-
-      def tracked_relations
-        @tracked_relations ||= relations.keys.select {|rel_name| track_relation?(rel_name) }
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'mongoid'
+require 'active_support/concern'
+
+module Mongoid
+  module RelationsDirtyTracking
+    extend ActiveSupport::Concern
+
+    class << self
+      DISABLED_KEY = 'mongoid/relations_dirty_tracking/disabled'
+
+      # Runs a block without invoking relations dirty tracking on the current thread.
+      # Returns the block return value.
+      def disable
+        thread_store[DISABLED_KEY] = true
+        yield
+      ensure
+        thread_store[DISABLED_KEY] = false
+      end
+
+      # Returns whether relations dirty tracking is enabled on the current thread.
+      def enabled?
+        !thread_store[DISABLED_KEY]
+      end
+
+      protected
+
+      def thread_store
+        defined?(RequestStore) ? RequestStore.store : Thread.current
+      end
+    end
+
+    module ClassMethods
+      def relations_dirty_tracking(options = {})
+        relations_dirty_tracking_options[:only]   += [options[:only]   || []].flatten.map(&:to_s)
+        relations_dirty_tracking_options[:except] += [options[:except] || []].flatten.map(&:to_s)
+      end
+
+      def track_relation?(rel_name)
+        rel_name = rel_name.to_s
+        options = relations_dirty_tracking_options
+        to_track = (!options[:only].blank? && options[:only].include?(rel_name)) ||
+                   (options[:only].blank? && !options[:except].include?(rel_name))
+
+        trackables = [Mongoid::Association::Embedded::EmbedsOne::Proxy,
+                      Mongoid::Association::Embedded::EmbedsMany::Proxy,
+                      Mongoid::Association::Referenced::HasOne::Proxy,
+                      Mongoid::Association::Referenced::HasMany::Proxy,
+                      Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy,
+                      Mongoid::Association::Referenced::BelongsTo::Proxy]
+        to_track && trackables.include?(relations[rel_name].try(:relation))
+      end
+
+      def tracked_relations
+        @tracked_relations ||= relations.keys.select { |rel_name| track_relation?(rel_name) }
+      end
+    end
+
+    included do
+      after_initialize :store_relations_shadow
+      after_save       :store_relations_shadow
+
+      cattr_accessor :relations_dirty_tracking_options
+      self.relations_dirty_tracking_options = { only: [], except: ['versions'] }
+
+      def store_relations_shadow
+        @relations_shadow = {}
+        return unless Mongoid::RelationsDirtyTracking.enabled?
+        self.class.tracked_relations.each do |rel_name|
+          @relations_shadow[rel_name] = tracked_relation_attributes(rel_name)
+        end
+      end
+
+      def relation_changes
+        return {} unless Mongoid::RelationsDirtyTracking.enabled?
+        changes = {}
+        @relations_shadow.each_pair do |rel_name, shadow_values|
+          current_values = tracked_relation_attributes(rel_name)
+          changes[rel_name] = [shadow_values, current_values] if current_values != shadow_values
+        end
+        changes
+      end
+
+      def relations_changed?
+        !relation_changes.empty?
+      end
+
+      def changed_with_relations?
+        changed? || relations_changed?
+      end
+
+      def changes_with_relations
+        (changes || {}).merge(relation_changes)
+      end
+
+      def tracked_relation_attributes(rel_name)
+        rel_name = rel_name.to_s
+        meta = relations[rel_name]
+        return nil unless meta
+        case meta
+        when Mongoid::Association::Embedded::EmbedsOne
+          val = send(rel_name)
+          val && val.attributes.clone.delete_if { |key, _| key == 'updated_at' }
+        when Mongoid::Association::Embedded::EmbedsMany
+          val = send(rel_name)
+          val && val.map { |child| child.attributes.clone.delete_if { |key, _| key == 'updated_at' } }
+        when Mongoid::Association::Referenced::HasOne
+          send(rel_name) && { meta.key.to_s => send(rel_name)[meta.key] }
+        when Mongoid::Association::Referenced::HasMany
+          send(rel_name).map { |child| { meta.key.to_s => child.id } }
+        when Mongoid::Association::Referenced::HasAndBelongsToMany
+          send(rel_name).map { |child| { meta.primary_key.to_s => child.id } }
+        when Mongoid::Association::Referenced::BelongsTo
+          begin
+            send(meta.foreign_key) && { meta.foreign_key.to_s => send(meta.foreign_key) }
+          rescue ActiveModel::MissingAttributeError
+            {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations_dirty_tracking/version.rb

@@ -1,5 +1,7 @@
-module Mongoid
-  module RelationsDirtyTracking
-    VERSION = "0.1.0"
-  end
-end
+# frozen_string_literal: true
+
+module Mongoid
+  module RelationsDirtyTracking
+    VERSION = '0.2.0'
+  end
+end

data/lib/mongoid_relations_dirty_tracking.rb

@@ -1,2 +1,3 @@
-require "mongoid/relations_dirty_tracking"
-require 'mongoid/relations_dirty_tracking/versioning'
+# frozen_string_literal: true
+
+require 'mongoid/relations_dirty_tracking'

data/spec/gemfiles/Gemfile.master

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec path: '../../'

data/spec/gemfiles/Gemfile.rails51

@@ -0,0 +1,6 @@
+source 'http://rubygems.org'
+
+gemspec path: '../../'
+
+gem 'activesupport', '~> 5.1.0'
+gem 'mongoid', '~> 7.0.0'