mongoid_monkey 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5814ac5f6752cc4afee52c517ed3996b7d4373f
-  data.tar.gz: 5c42d28b26b8a8c5aa7d1ca71c29397d3392560c
+  metadata.gz: 214e7694779c183b25d31b4a3acd022b6d197883
+  data.tar.gz: ba65a452be5ef5778673fb790872ad7e879e368e
 SHA512:
-  metadata.gz: 858f9e0888815dcebe7974e7ddd3737e3c5ce9a5117d47dc0436c9e87626e68ad639722207760dda09202f56ec7a8180325799ba7bc39cd7aaf1dc76824bc40b
-  data.tar.gz: d0c827a916d331114e8b36a75a12d118c83284d491fb055ec80d670c3924856765621a514f1b4acfe7df63505ec42239488704e782bf5d4a9145158aa0b6d275
+  metadata.gz: 9c3906fb7a21840e4e1688bc1f9f9bcbfa608d3083533d52b87cb8caf31783dfe6aea1ae462b85c6908cb9d9b05ec35cd5e04e6d83e2e0750dbcb2f231d96c1b
+  data.tar.gz: 9c0dc36cb5537f059791b16d43ba2dd5fb3337d3597e3dfc4600c469d3717166a6761a5d8a335731dae3e6810340aad0e7a1b51bea69136af6a78bbab17d1864

data/lib/patches/atomic.rb

@@ -111,4 +111,228 @@ module Atomic
 end
 end
 end
-end
+
+module Mongoid
+module Persistence
+module Atomic
+
+  # push_all is deprecated so not supported
+
+  def add_to_set_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      adds = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(adds) do |field, value|
+          existing = send(field) || (attributes[field] ||= [])
+          values = [ value ].flatten(1)
+          values.each do |val|
+            existing.push(val) unless existing.include?(val)
+          end
+          ops[atomic_attribute_name(field)] = { "$each" => values }
+        end
+        { "$addToSet" => ops }
+      end
+    else
+      add_to_set_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :add_to_set, :mongoid4
+
+  def bit_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      operations = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(operations) do |field, values|
+          value = attributes[field]
+          values.each do |op, val|
+            value = value & val if op.to_s == "and"
+            value = value | val if op.to_s == "or"
+          end
+          attributes[field] = value
+          ops[atomic_attribute_name(field)] = values
+        end
+        { "$bit" => ops }
+      end
+    else
+      bit_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :bit, :mongoid4
+
+  def inc_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      increments = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(increments) do |field, value|
+          increment = value.__to_inc__
+          current = attributes[field]
+          attributes[field] = (current || 0) + increment
+          ops[atomic_attribute_name(field)] = increment
+        end
+        { "$inc" => ops }
+      end
+    else
+      inc_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :inc, :mongoid4
+
+  def pop_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      pops = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(pops) do |field, value|
+          values = send(field)
+          value > 0 ? values.pop : values.shift
+          ops[atomic_attribute_name(field)] = value
+        end
+        { "$pop" => ops }
+      end
+    else
+      pop_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pop, :mongoid4
+
+  def pull_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      pulls = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(pulls) do |field, value|
+          (send(field) || []).delete(value)
+          ops[atomic_attribute_name(field)] = value
+        end
+        { "$pull" => ops }
+      end
+    else
+      pull_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pull, :mongoid4
+
+  def pull_all_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      pulls = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(pulls) do |field, value|
+          existing = send(field) || []
+          value.each{ |val| existing.delete(val) }
+          ops[atomic_attribute_name(field)] = value
+        end
+        { "$pullAll" => ops }
+      end
+    else
+      pull_all_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :pull_all, :mongoid4
+
+  def push_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      pushes = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(pushes) do |field, value|
+          existing = send(field) || (attributes[field] ||= [])
+          values = [ value ].flatten(1)
+          values.each{ |val| existing.push(val) }
+          ops[atomic_attribute_name(field)] = { "$each" => values }
+        end
+        { "$push" => ops }
+      end
+    else
+      push_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :push, :mongoid4
+
+  def rename_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      renames = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(renames) do |old_field, new_field|
+          new_name = new_field.to_s
+          attributes[new_name] = attributes.delete(old_field)
+          ops[atomic_attribute_name(old_field)] = atomic_attribute_name(new_name)
+        end
+        { "$rename" => ops }
+      end
+    else
+      rename_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :rename, :mongoid4
+
+  def set_with_mongoid4(*args)
+    if args.length == 1 && args.first.is_a?(Hash)
+      setters = args.first
+      prepare_atomic_operation do |ops|
+        process_atomic_operations(setters) do |field, value|
+          process_attribute(field.to_s, value)
+          ops[atomic_attribute_name(field)] = attributes[field]
+        end
+        { "$set" => ops }
+      end
+    else
+      set_without_mongoid4(*args)
+    end
+  end
+  alias_method_chain :set, :mongoid4
+
+  # unset params are consistent, however it returns self in Mongoid 4
+  # def unset_with_mongoid4(*args)
+  #   unset_without_mongoid4(*args)
+  #   self
+  # end
+  # alias_method_chain :unset, :mongoid4
+
+  private
+
+  def executing_atomically?
+    !@atomic_updates_to_execute.nil?
+  end
+
+  def post_process_persist(result, options = {})
+    post_persist unless result == false
+    errors.clear unless performing_validations?(options)
+    true
+  end
+
+  def prepare_atomic_operation
+    operations = yield({})
+    persist_or_delay_atomic_operation(operations)
+    self
+  end
+
+  def process_atomic_operations(operations)
+    operations.each do |field, value|
+      unless attribute_writable?(field)
+        raise Errors::ReadonlyAttribute.new(field, value)
+      end
+      normalized = database_field_name(field)
+      yield(normalized, value)
+      remove_change(normalized)
+    end
+  end
+
+  def persist_or_delay_atomic_operation(operation)
+    if executing_atomically?
+      operation.each do |(name, hash)|
+        @atomic_updates_to_execute[name] ||= {}
+        @atomic_updates_to_execute[name].merge!(hash)
+      end
+    else
+      persist_atomic_operations(operation)
+    end
+  end
+
+  def persist_atomic_operations(operations)
+    if persisted?
+      selector = atomic_selector
+      _root.collection.find(selector).update(operations)
+    end
+  end
+end
+end
+end
+
+end

data/lib/version.rb

@@ -1,3 +1,3 @@
 module MongoidMonkey
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/spec/app/models/address.rb

@@ -1,7 +1,24 @@
 
 class Address
   include Mongoid::Document
+  field :address_type
+  field :number, type: Integer
+  field :no, type: Integer
+  field :h, as: :house, type: Integer
   field :street
+  field :city
+  field :state
+  field :post_code
+  field :parent_title
+  field :services, type: Array
+  field :aliases, as: :a, type: Array
+  field :test, type: Array
+  field :latlng, type: Array
+  field :map, type: Hash
+  field :move_in, type: DateTime
+  field :end_date, type: Date
+  field :s, type: String, as: :suite
   field :name, localize: true
+
   embedded_in :addressable, polymorphic: true
 end

data/spec/app/models/name.rb

@@ -0,0 +1,14 @@
+class Name
+  include Mongoid::Document
+
+  field :first_name, type: String
+  field :last_name, type: String
+  field :parent_title, type: String
+  field :middle, type: String
+
+  embedded_in :namable, polymorphic: true
+
+  def set_parent=(set = false)
+    self.parent_title = namable.title if set
+  end
+end

data/spec/app/models/person.rb

@@ -8,4 +8,43 @@ class Person
   index name: 1
   index title: 1
   index({ ssn: 1 }, { unique: true })
+  field :username, default: -> { "arthurnn#{rand(0..10)}" }
+  field :title
+  field :terms, type: Boolean
+  field :pets, type: Boolean, default: false
+  field :age, type: Integer, default: "100"
+  field :dob, type: Date
+  field :employer_id
+  field :lunch_time, type: Time
+  field :aliases, type: Array
+  field :map, type: Hash
+  field :map_with_default, type: Hash, default: {}
+  field :score, type: Integer
+  field :blood_alcohol_content, type: Float, default: ->{ 0.0 }
+  field :last_drink_taken_at, type: Date, default: ->{ 1.day.ago.in_time_zone("Alaska") }
+  field :ssn
+  field :owner_id, type: Integer
+  field :security_code
+  field :reading, type: Object
+  field :pattern, type: Regexp
+  field :override_me, type: Integer
+  field :at, as: :aliased_timestamp, type: Time
+  field :t, as: :test, type: String
+  field :i, as: :inte, type: Integer
+  field :a, as: :array, type: Array
+  field :desc, localize: true
+  field :test_array, type: Array
+  field :overridden_setter, type: String
+  field :arrays, type: Array
+  field :range, type: Range
+
+  embeds_many :addresses, as: :addressable, validate: false
+  embeds_one :name, as: :namable, validate: false do
+    def extension
+      "Testing"
+    end
+    def dawkins?
+      first_name == "Richard" && last_name == "Dawkins"
+    end
+  end
 end

data/spec/unit/atomic/mongoid3_style/atomic/add_to_set_spec.rb

@@ -0,0 +1,266 @@
+require "spec_helper"
+
+if Mongoid::VERSION =~ /\A3\./
+
+describe Mongoid::Persistence::Atomic::AddToSet do
+
+  describe "#persist" do
+
+    context "when the document is new" do
+
+      let(:person) do
+        Person.new
+      end
+
+      context "when adding a single value" do
+
+        let!(:added) do
+          person.add_to_set(:aliases, "Bond")
+        end
+
+        it "adds the value onto the array" do
+          person.aliases.should eq([ "Bond" ])
+        end
+
+        it "does not reset the dirty flagging" do
+          person.changes["aliases"].should eq([nil, ["Bond"]])
+        end
+
+        it "returns the new array value" do
+          added.should eq([ "Bond" ])
+        end
+      end
+
+      context "when adding multiple values" do
+
+        let!(:added) do
+          person.add_to_set(:aliases, [ "Bond", "James" ])
+        end
+
+        it "adds the value onto the array" do
+          person.aliases.should eq([ "Bond", "James" ])
+        end
+
+        it "does not reset the dirty flagging" do
+          person.changes["aliases"].should eq([nil, ["Bond", "James"]])
+        end
+
+        it "returns the new array value" do
+          added.should eq([ "Bond", "James" ])
+        end
+      end
+    end
+
+    context "when the field exists" do
+
+      context "when the value is unique" do
+
+        let(:person) do
+          Person.create(aliases: [ "007" ])
+        end
+
+        context "when adding a single value" do
+
+          let!(:added) do
+            person.add_to_set(:aliases, "Bond")
+          end
+
+          let(:reloaded) do
+            person.reload
+          end
+
+          it "adds the value onto the array" do
+            person.aliases.should eq([ "007", "Bond" ])
+          end
+
+          it "persists the data" do
+            reloaded.aliases.should eq([ "007", "Bond" ])
+          end
+
+          it "removes the field from the dirty attributes" do
+            person.changes["aliases"].should be_nil
+          end
+
+          it "resets the document dirty flag" do
+            person.should_not be_changed
+          end
+
+          it "returns the new array value" do
+            added.should eq([ "007", "Bond" ])
+          end
+        end
+
+        context "when adding a multiple values" do
+
+          let!(:added) do
+            person.add_to_set(:aliases, [ "Bond", "James" ])
+          end
+
+          let(:reloaded) do
+            person.reload
+          end
+
+          it "adds the value onto the array" do
+            person.aliases.should eq([ "007", "Bond", "James" ])
+          end
+
+          it "persists the data" do
+            reloaded.aliases.should eq([ "007", "Bond", "James" ])
+          end
+
+          it "removes the field from the dirty attributes" do
+            person.changes["aliases"].should be_nil
+          end
+
+          it "resets the document dirty flag" do
+            person.should_not be_changed
+          end
+
+          it "returns the new array value" do
+            added.should eq([ "007", "Bond", "James" ])
+          end
+        end
+      end
+
+      context "when the value is not unique" do
+
+        let(:person) do
+          Person.create(aliases: [ "Bond" ])
+        end
+
+        context "when adding a single value" do
+
+          let!(:added) do
+            person.add_to_set(:aliases, "Bond")
+          end
+
+          let(:reloaded) do
+            person.reload
+          end
+
+          it "does not add the value" do
+            person.aliases.should eq([ "Bond" ])
+          end
+
+          it "persists the data" do
+            reloaded.aliases.should eq([ "Bond" ])
+          end
+
+          it "removes the field from the dirty attributes" do
+            person.changes["aliases"].should be_nil
+          end
+
+          it "resets the document dirty flag" do
+            person.should_not be_changed
+          end
+
+          it "returns the array value" do
+            added.should eq([ "Bond" ])
+          end
+        end
+
+        context "when adding multiple values" do
+
+          let!(:added) do
+            person.add_to_set(:aliases, [ "Bond", "James" ])
+          end
+
+          let(:reloaded) do
+            person.reload
+          end
+
+          it "does not add the duplicate value" do
+            person.aliases.should eq([ "Bond", "James" ])
+          end
+
+          it "persists the data" do
+            reloaded.aliases.should eq([ "Bond", "James" ])
+          end
+
+          it "removes the field from the dirty attributes" do
+            person.changes["aliases"].should be_nil
+          end
+
+          it "resets the document dirty flag" do
+            person.should_not be_changed
+          end
+
+          it "returns the array value" do
+            added.should eq([ "Bond", "James" ])
+          end
+        end
+      end
+    end
+
+    context "when the field does not exist" do
+
+      let(:person) do
+        Person.create
+      end
+
+      context "when adding a single value" do
+
+        let!(:added) do
+          person.add_to_set(:aliases, "Bond")
+        end
+
+        let(:reloaded) do
+          person.reload
+        end
+
+        it "adds the value onto the array" do
+          person.aliases.should eq([ "Bond" ])
+        end
+
+        it "persists the data" do
+          reloaded.aliases.should eq([ "Bond" ])
+        end
+
+        it "removes the field from the dirty attributes" do
+          person.changes["aliases"].should be_nil
+        end
+
+        it "resets the document dirty flag" do
+          person.should_not be_changed
+        end
+
+        it "returns the new array value" do
+          added.should eq([ "Bond" ])
+        end
+      end
+
+      context "when adding multiple values" do
+
+        let!(:added) do
+          person.add_to_set(:aliases, [ "Bond", "James" ])
+        end
+
+        let(:reloaded) do
+          person.reload
+        end
+
+        it "adds the value onto the array" do
+          person.aliases.should eq([ "Bond", "James" ])
+        end
+
+        it "persists the data" do
+          reloaded.aliases.should eq([ "Bond", "James" ])
+        end
+
+        it "removes the field from the dirty attributes" do
+          person.changes["aliases"].should be_nil
+        end
+
+        it "resets the document dirty flag" do
+          person.should_not be_changed
+        end
+
+        it "returns the new array value" do
+          added.should eq([ "Bond", "James" ])
+        end
+      end
+    end
+  end
+end
+
+end

data/spec/unit/atomic/mongoid3_style/atomic/bit_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+if Mongoid::VERSION =~ /\A3\./
+
+describe Mongoid::Persistence::Atomic::Bit do
+
+  describe "#bit" do
+
+    let(:person) do
+      Person.create(age: 60)
+    end
+
+    let(:reloaded) do
+      person.reload
+    end
+
+    context "when performing a bitwise and" do
+
+      let!(:bit) do
+        person.bit(:age, { and: 13 })
+      end
+
+      it "performs the bitwise operation" do
+        person.age.should eq(12)
+      end
+
+      it "returns the new value" do
+        bit.should eq(12)
+      end
+
+      it "persists the changes" do
+        reloaded.age.should eq(12)
+      end
+
+      it "resets the dirty attributes" do
+        person.changes["age"].should be_nil
+      end
+    end
+
+    context "when performing a bitwise or" do
+
+      let!(:bit) do
+        person.bit(:age, { or: 13 })
+      end
+
+      it "performs the bitwise operation" do
+        person.age.should eq(61)
+      end
+
+      it "returns the new value" do
+        bit.should eq(61)
+      end
+
+      it "persists the changes" do
+        reloaded.age.should eq(61)
+      end
+
+      it "resets the dirty attributes" do
+        person.changes["age"].should be_nil
+      end
+    end
+
+    context "when chaining bitwise operations" do
+
+      let(:hash) do
+        { and: 13, or: 10 }
+      end
+
+      let!(:bit) do
+        person.bit(:age, hash)
+      end
+
+      it "performs the bitwise operation" do
+        person.age.should eq(14)
+      end
+
+      it "returns the new value" do
+        bit.should eq(14)
+      end
+
+      it "persists the changes" do
+        reloaded.age.should eq(14)
+      end
+
+      it "resets the dirty attributes" do
+        person.changes["age"].should be_nil
+      end
+    end
+  end
+end
+
+end