mongoid 7.1.6 → 7.2.0.rc1

data/lib/mongoid/matchable/nor.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Matchable
-
-    # Defines behavior for handling $nor expressions in embedded documents.
-    class Nor < Default
-
-      # Does the supplied query match the attribute?
-      #
-      # Note: an empty array as an argument to $nor is prohibited by
-      # MongoDB server. Mongoid does allow this and returns false in this case.
-      #
-      # @example Does this match?
-      #   matcher._matches?("$nor" => [ { field => value } ])
-      #
-      # @param [ Array ] conditions The or expression.
-      #
-      # @return [ true, false ] True if matches, false if not.
-      #
-      # @since 7.1.0
-      def _matches?(conditions)
-        if conditions.length == 0
-          # MongoDB does not allow $nor array to be empty, but
-          # Mongoid accepts an empty array for $or which MongoDB also
-          # prohibits
-          return false
-        end
-        conditions.none? do |condition|
-          condition.all? do |key, value|
-            document._matches?(key => value)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/matchable/or.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Matchable
-
-    # Defines behavior for handling $or expressions in embedded documents.
-    class Or < Default
-
-      # Does the supplied query match the attribute?
-      #
-      # @example Does this match?
-      #   matcher._matches?("$or" => [ { field => value } ])
-      #
-      # @param [ Array ] conditions The or expression.
-      #
-      # @return [ true, false ] True if matches, false if not.
-      #
-      # @since 2.0.0.rc.7
-      def _matches?(conditions)
-        conditions.each do |condition|
-          res = true
-          condition.keys.each do |k|
-            key = k
-            value = condition[k]
-            res &&= document._matches?(key => value)
-            break unless res
-          end
-          return res if res
-        end
-        return false
-      end
-    end
-  end
-end

data/lib/mongoid/matchable/regexp.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Matchable
-
-    # Defines behavior for handling regular expressions in embedded documents.
-    class Regexp < Default
-
-      # Does the supplied query match the attribute?
-      #
-      # @example Does this match?
-      #   matcher._matches?(/\AEm/)
-      #   matcher._matches?(BSON::Regex::Raw.new("\\AEm"))
-      #
-      # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
-      #
-      # @return [ true, false ] True if matches, false if not.
-      #
-      # @since 5.2.1
-      def _matches?(regexp)
-        if native_regexp = regexp.try(:compile)
-          super(native_regexp)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/mongoid/matchable/size.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-module Mongoid
-  module Matchable
-
-    # Performs size checking.
-    class Size < Default
-
-      # Return true if the attribute size is equal to the first value.
-      #
-      # @example Do the values match?
-      #   matcher._matches?({ :key => 10 })
-      #
-      # @param [ Hash ] value The values to check.
-      #
-      # @return [ true, false ] If a value exists.
-      def _matches?(value)
-        @attribute.size == value.values.first
-      end
-    end
-  end
-end

data/spec/app/models/publication.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'app/models/publication/encyclopedia'
-require 'app/models/publication/review'

data/spec/integration/associations/embeds_many_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'embeds_many associations' do
-
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:canvas) do
-        Canvas.create!(shapes: [Shape.new])
-      end
-
-      let!(:shape) { canvas.shapes.first }
-
-      it 'does not destroy the dependent object' do
-        canvas.shapes = [shape]
-        canvas.save!
-        canvas.reload
-        canvas.shapes.should == [shape]
-      end
-    end
-  end
-end

data/spec/integration/associations/embeds_one_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe 'embeds_one associations' do
-
-  context 're-associating the same object' do
-    context 'with dependent: destroy' do
-      let(:canvas) do
-        Canvas.create!(palette: Palette.new)
-      end
-
-      let!(:palette) { canvas.palette }
-
-      it 'does not destroy the dependent object' do
-        canvas.palette = canvas.palette
-        canvas.save!
-        canvas.reload
-        canvas.palette.should == palette
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/all_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::All do
-
-  let(:matcher) do
-    described_class.new(["first", "second", "third"])
-  end
-
-  describe "#_matches?" do
-
-    context "when the attribute includes all of the values" do
-
-      it "returns true" do
-        expect(matcher._matches?("$all" => ["first", /\Asec.*\z/])).to be true
-      end
-    end
-
-    context "when the attributes doesn't include all of the values" do
-
-      it "returns false" do
-        expect(matcher._matches?("$all" => ["second", "third", "fourth"])).to be false
-      end
-    end
-
-    context "when the value is empty" do
-      it "returns false" do
-        expect(matcher._matches?("$all" => [])).to be false
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/and_spec.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::And do
-
-  let(:person) do
-    Person.new
-  end
-
-  let(:matcher) do
-    described_class.new("value", person)
-  end
-
-  describe "#_matches?" do
-
-    context "when provided a simple expression" do
-
-      context "when only one expression provided" do
-
-        context "when the value matches" do
-
-          let(:matches) do
-            matcher._matches?([ { title: "Sir" } ])
-          end
-
-          before do
-            person.title = "Sir"
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context "when the expression is a $not" do
-
-          let(:matches) do
-            matcher._matches?([ { title: {:$not => /Foobar/ } }])
-          end
-
-          context "when the value matches" do
-
-            it "returns true" do
-              expect(matches).to be true
-            end
-          end
-
-          context "when the value does not match" do
-
-            before do
-              person.title = "Foobar baz"
-            end
-
-            it "returns false" do
-              expect(matches).to be false
-            end
-          end
-        end
-
-        context "when the value does not match" do
-
-          let(:matches) do
-            matcher._matches?([ { title: "Sir" } ])
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-      end
-
-      context "when multiple expressions provided" do
-
-        context "when all of the values are equal" do
-
-          let(:matches) do
-            matcher._matches?(
-              [ { title: "Sir" }, { _id: person.id } ]
-            )
-          end
-
-          before do
-            person.title = "Sir"
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-
-        context "when one of the values does not match" do
-
-          let(:matches) do
-            matcher._matches?(
-              [ { title: "Sir" }, { _id: BSON::ObjectId.new } ]
-            )
-          end
-
-          before do
-            person.title = "Sir"
-          end
-
-          it "returns false" do
-            expect(matches).to be false
-          end
-        end
-
-        context "when provided no expressions" do
-
-          let(:matches) do
-            matcher._matches?([])
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-      end
-    end
-
-    context "when provided a complex expression" do
-
-      context "when all of the values are equal" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Sir", "Madam" ] } },
-              { _id: person.id }
-            ]
-          )
-        end
-
-        before do
-          person.title = "Sir"
-        end
-
-        it "returns true" do
-          expect(matches).to be true
-        end
-      end
-
-      context "when one of the values does not match" do
-
-        let(:matches) do
-          matcher._matches?(
-            [
-              { title: { "$in" => [ "Prince", "Madam" ] } },
-              { _id: BSON::ObjectId.new }
-            ]
-          )
-        end
-
-        before do
-          person.title = "Sir"
-        end
-
-        it "returns false" do
-          expect(matches).to be false
-        end
-      end
-
-      context "when expression contain multiple fields" do
-
-        context "when all the expressions match" do
-
-          let(:matches) do
-            matcher._matches?(
-              [
-                { title: "Sir", age: 23 },
-                { _id: person.id }
-              ]
-            )
-          end
-
-          before do
-            person.title = "Sir"
-            person.age = 23
-          end
-
-          it "returns true" do
-            expect(matches).to be true
-          end
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/matchable/default_spec.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-# encoding: utf-8
-
-require "spec_helper"
-
-describe Mongoid::Matchable::Default do
-
-  describe "#_matches?" do
-
-    context "when comparing strings" do
-
-      let(:matcher) do
-        described_class.new("Testing")
-      end
-
-      context "when the values are equal" do
-
-        it "returns true" do
-          expect(matcher._matches?("Testing")).to be true
-        end
-      end
-
-      context "when the values are not equal" do
-
-        it "returns false" do
-          expect(matcher._matches?("Other")).to be false
-        end
-      end
-    end
-
-    context "when comparing object ids" do
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:matcher) do
-        described_class.new(object_id)
-      end
-
-      context "when the values are equal" do
-
-        it "returns true" do
-          expect(matcher._matches?(object_id)).to be true
-        end
-      end
-
-      context "when the values are not equal" do
-
-        it "returns false" do
-          expect(matcher._matches?(BSON::ObjectId.new)).to be false
-        end
-      end
-    end
-
-    context "when comparing a string to an array" do
-
-      let(:matcher) do
-        described_class.new(["Test1", "Test2", "Test3"])
-      end
-
-      context "when the attribute contains the value" do
-
-        context "when the value is a string" do
-
-          it "returns true" do
-            expect(matcher._matches?("Test1")).to be true
-          end
-        end
-
-        context "when the value is a regexp" do
-
-          it "returns true" do
-            expect(matcher._matches?(/\ATest[3-5]\z/)).to be true
-          end
-        end
-      end
-
-      context "when the attribute does not contain the value" do
-
-        it "returns false" do
-          expect(matcher._matches?("Test4")).to be false
-        end
-      end
-    end
-
-    context "when comparing an object id to an array" do
-
-      let(:object_id) do
-        BSON::ObjectId.new
-      end
-
-      let(:matcher) do
-        described_class.new([ object_id, BSON::ObjectId.new ])
-      end
-
-      context "when the attribute contains the value" do
-
-        it "returns true" do
-          expect(matcher._matches?(object_id)).to be true
-        end
-      end
-
-      context "when the attribute does not contain the value" do
-
-        it "returns false" do
-          expect(matcher._matches?(BSON::ObjectId.new)).to be false
-        end
-      end
-    end
-
-    context "when comparing an array to an array" do
-
-      let(:matcher) do
-        described_class.new(["Test1", "Test2", "Test3"])
-      end
-
-      context "when the attribute equals the value" do
-
-        it "returns true" do
-          expect(matcher._matches?(["Test1", "Test2", "Test3"])).to be true
-        end
-      end
-
-      context "when the value contains same items as attribute but in different order" do
-
-        it "returns false" do
-          expect(matcher._matches?(["Test1", "Test3", "Test2"])).to be false
-        end
-      end
-
-      context "when the value is a subset of attribute" do
-
-        it "returns false" do
-          expect(matcher._matches?(["Test1", "Test2"])).to be false
-        end
-      end
-    end
-  end
-end