mongoid 7.0.4 → 7.0.10

data/lib/mongoid/matchable/default.rb

@@ -20,52 +20,99 @@ module Mongoid
         @attribute, @document = attribute, document
       end
 
-      # Return true if the attribute and value are equal, or if it is an array
-      # if the value is included.
+      # Checks whether the attribute matches the value, using the default
+      # MongoDB matching logic (i.e., when no operator is specified in the
+      # criteria).
       #
-      # @example Does this value match?
-      #   default._matches?("value")
+      # If attribute and value are both of basic types like string or number,
+      # this method returns true if and only if the attribute equals the value.
       #
-      # @param [ Object ] value The value to check if it matches.
+      # Value can also be of a type like Regexp or Range which defines
+      # more complex matching/inclusion behavior via the === operator.
+      # If so, and attribute is still of a basic type like string or number,
+      # this method returns true if and only if the value's === operator
+      # returns true for the attribute. For example, this method returns true
+      # if attribute is a string and value is a Regexp and attribute matches
+      # the value, of if attribute is a number and value is a Range and
+      # the value includes the attribute.
       #
-      # @return [ true, false ] True if matches, false if not.
+      # If attribute is an array and value is not an array, the checks just
+      # described (i.e. the === operator invocation) are performed on each item
+      # of the attribute array. If any of the items in the attribute match
+      # the value according to the value type's === operator, this method
+      # returns true.
+      #
+      # If attribute and value are both arrays, this method returns true if and
+      # only if the arrays are equal (including the order of the elements).
+      #
+      # @param [ Object ] value The value to check.
+      #
+      # @return [ true, false ] True if attribute matches the value, false if not.
       #
       # @since 1.0.0
       def _matches?(value)
-        attribute.is_a?(Array) && !value.is_a?(Array) ? attribute.any? { |_attribute| value === _attribute } : value === attribute
+        if attribute.is_a?(Array) && !value.is_a?(Array)
+          attribute.any? { |_attribute| value === _attribute }
+        else
+          value === attribute
+        end
       end
 
       protected
 
-      # Convenience method for getting the first value in a hash.
+      # Given a condition, which is a one-element hash consisting of an
+      # operator and a value like {'$gt' => 1}, return the value.
       #
-      # @example Get the first value.
-      #   matcher.first(:test => "value")
+      # @example Get the condition value.
+      #   matcher.condition_value({'$gt' => 1})
+      #   # => 1
       #
-      # @param [ Hash ] hash The has to pull from.
+      # @param [ Hash ] condition The condition.
       #
-      # @return [ Object ] The first value.
+      # @return [ Object ] The value of the condition.
       #
       # @since 1.0.0
-      def first(hash)
-        hash.values.first
+      def condition_value(condition)
+        unless condition.is_a?(Hash)
+          raise ArgumentError, 'Condition must be a hash'
+        end
+
+        unless condition.length == 1
+          raise ArgumentError, 'Condition must have one element'
+        end
+
+        condition.values.first
       end
 
-      # If object exists then compare the two, otherwise return false
+      # Determines whether the attribute value stored in this matcher
+      # satisfies the provided condition using the provided operator.
+      #
+      # For example, given an instance of Gt matcher with the @attribute of
+      # 2, the matcher is set up to answer whether the attribute is
+      # greater than some input value. This input value is provided in
+      # the condition, which could be {"$gt" => 1}, and the operator is
+      # provided (somewhat in a duplicate fashion) in the operator argument,
+      # in this case :>.
       #
-      # @example Determine if we can compare.
-      #   matcher.determine("test", "$in")
+      # @example
+      #   matcher = Matchable::Gt.new(2)
+      #   matcher.determine({'$gt' => 1}, :>)
+      #   # => true
       #
-      # @param [ Object ] value The value to compare with.
-      # @param [ Symbol, String ] operator The comparison operation.
+      # @param [ Hash ] condition The condition to evaluate. This must be
+      #   a one-element hash; the key is ignored, and the value is passed
+      #   as the argument to the operator.
+      # @param [ Symbol, String ] operator The comparison operator or method.
+      #   The operator is invoked on the attribute stored in the matcher
+      #   instance.
       #
-      # @return [ true, false ] The comparison or false.
+      # @return [ true, false ] Result of condition evaluation.
       #
       # @since 1.0.0
-      def determine(value, operator)
-        attribute.__array__.any? {|attr|
-          attr ? attr.send(operator, first(value)) : false
-        }
+      def determine(condition, operator)
+        attribute.__array__.any? do |attr|
+          attr && attr.send(operator, condition_value(condition))
+        end
       end
     end
   end

data/lib/mongoid/matchable/regexp.rb

@@ -7,8 +7,8 @@ module Mongoid
       # Does the supplied query match the attribute?
       #
       # @example Does this match?
-      #   matcher._matches?(/^Em/)
-      #   matcher._matches?(BSON::Regex::Raw.new("^Em"))
+      #   matcher._matches?(/\AEm/)
+      #   matcher._matches?(BSON::Regex::Raw.new("\\AEm"))
       #
       # @param [ BSON::Regexp::Raw, Regexp ] regexp The regular expression object.
       #

data/lib/mongoid/persistable/pushable.rb

@@ -22,7 +22,13 @@ module Mongoid
       def add_to_set(adds)
         prepare_atomic_operation do |ops|
           process_atomic_operations(adds) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || attributes[field]
+            if existing.nil?
+              attributes[field] = []
+              # Read the value out of attributes:
+              # https://jira.mongodb.org/browse/MONGOID-4874
+              existing = attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each do |val|
               existing.push(val) unless existing.include?(val)
@@ -49,7 +55,10 @@ module Mongoid
       def push(pushes)
         prepare_atomic_operation do |ops|
           process_atomic_operations(pushes) do |field, value|
-            existing = send(field) || (attributes[field] ||= [])
+            existing = send(field) || begin
+              attributes[field] ||= []
+              attributes[field]
+            end
             values = [ value ].flatten(1)
             values.each{ |val| existing.push(val) }
             ops[atomic_attribute_name(field)] = { "$each" => values }

data/lib/mongoid/persistence_context.rb

@@ -116,6 +116,12 @@ module Mongoid
                     client.with(client_options))
     end
 
+    def client_name
+      @client_name ||= options[:client] ||
+                         Threaded.client_override ||
+                         storage_options && __evaluate__(storage_options[:client])
+    end
+
     # Determine if this persistence context is equal to another.
     #
     # @example Compare two persistence contexts.
@@ -133,12 +139,6 @@ module Mongoid
 
     private
 
-    def client_name
-      @client_name ||= options[:client] ||
-                         Threaded.client_override ||
-                         storage_options && __evaluate__(storage_options[:client])
-    end
-
     def set_options!(opts)
       @options ||= opts.each.reduce({}) do |_options, (key, value)|
                      unless VALID_OPTIONS.include?(key.to_sym)

data/lib/mongoid/positional.rb

@@ -64,7 +64,7 @@ module Mongoid
       matches = position.scan(/\.\d+\./)
       if matches.size == 1
         keys.each do |kk|
-          if position =~ /^#{kk}\.\d+\.(.*)/
+          if position =~ /\A#{kk}\.\d+\.(.*)\z/
             return "#{kk}.$.#{$1}"
           end
         end

data/lib/mongoid/query_cache.rb

@@ -166,7 +166,8 @@ module Mongoid
         @coll_name ||= result.namespace.sub("#{database.name}.", '') if result.namespace
         documents = result.documents
         if @cursor_id.zero? && !@after_first_batch
-          (@cached_documents ||= []).concat(documents)
+          @cached_documents ||= []
+          @cached_documents.concat(documents)
         end
         @after_first_batch = true
         documents
@@ -229,14 +230,29 @@ module Mongoid
           unless cursor = cached_cursor
             read_with_retry do
               server = server_selector.select_server(cluster)
-              cursor = CachedCursor.new(view, send_initial_query(server), server)
-              QueryCache.cache_table[cache_key] = cursor
+              result = send_initial_query(server)
+              if result.cursor_id == 0 || result.cursor_id.nil?
+                cursor = CachedCursor.new(view, result, server)
+                QueryCache.cache_table[cache_key] = cursor
+              else
+                cursor = Mongo::Cursor.new(view, result, server)
+              end
             end
           end
-          cursor.each do |doc|
-            yield doc
-          end if block_given?
-          cursor
+
+          if block_given?
+            if limit && limit != -1
+              cursor.to_a[0...limit].each do |doc|
+                yield doc
+              end
+            else
+              cursor.each do |doc|
+                yield doc
+              end
+            end
+          else
+            cursor
+          end
         end
       end
 
@@ -246,9 +262,6 @@ module Mongoid
         if limit
           key = [ collection.namespace, selector, nil, skip, sort, projection, collation  ]
           cursor = QueryCache.cache_table[key]
-          if cursor
-            cursor.to_a[0...limit.abs]
-          end
         end
         cursor || QueryCache.cache_table[cache_key]
       end
@@ -258,7 +271,7 @@ module Mongoid
       end
 
       def system_collection?
-        collection.namespace =~ /^system./
+        collection.namespace =~ /\Asystem./
       end
     end
 

data/lib/mongoid/validatable/macros.rb

@@ -48,7 +48,7 @@ module Mongoid
       #     include Mongoid::Document
       #     field :title
       #
-      #     validates_format_of :title, with: /^[a-z0-9 \-_]*$/i
+      #     validates_format_of :title, with: /\A[a-z0-9 \-_]*\z/i
       #   end
       #
       # @param [ Array ] args The names of the fields to validate.

data/lib/mongoid/validatable/uniqueness.rb

@@ -148,7 +148,7 @@ module Mongoid
       #
       # @since 2.3.0
       def filter(value)
-        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}$/i : value
+        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}\z/i : value
       end
 
       # Scope the criteria to the scope options provided.

data/lib/mongoid/version.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 module Mongoid
-  VERSION = "7.0.4"
+  VERSION = "7.0.10"
 end

data/lib/rails/generators/mongoid/model/templates/model.rb.tt

@@ -13,7 +13,7 @@ class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent]
   field :<%= attribute.name %>, type: <%= attribute.type_class %>
 <% end -%>
 <% attributes.select{|attr| attr.reference? }.each do |attribute| -%>
-  embedded_in :<%= attribute.name%>
+  belongs_to :<%= attribute.name%>
 <% end -%>
 end
 <% end -%>

data/spec/README.md

@@ -0,0 +1,18 @@
+# Running Mongoid Tests
+
+## Overview
+### Quick Start
+Spin up a MongoDB deployment against which to run the Mongoid specs. Mongoid specs support a variety of MongoDB topologies, but the simplest is a single MongoDB instance:
+
+    # Launch mongod in one terminal
+    mkdir /tmp/mdb
+    mongod --dbpath /tmp/mdb
+
+Run the test suite in a separate terminal:
+
+    rake
+
+
+## Caveats
+### "Too many open files" error
+On MacOS, you may encounter a "Too many open files" error on the MongoDB server when running the tests. If this happens, stop the server, run the command `ulimit -n 10000` in the same terminal session as the server, and restart the server. This will increase the number of files that can be opened. Then, re-run the tests.

data/spec/app/models/delegating_patient.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+class DelegatingPatient
+  include Mongoid::Document
+
+  embeds_one :email
+
+  # Instance level delegation
+  delegate :address, to: :email
+
+  class << self
+    # Class level delegation
+    delegate :default_client, to: ::Mongoid
+  end
+end

data/spec/integration/app_spec.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+BASE = File.join(File.dirname(__FILE__), '../..')
+TMP_BASE = File.join(BASE, 'tmp')
+
+describe 'Mongoid application tests' do
+  before(:all) do
+    unless SpecConfig.instance.app_tests?
+      skip 'Set APP_TESTS=1 in environment to run application tests'
+    end
+
+    require 'fileutils'
+    require 'support/child_process_helper'
+    require 'open-uri'
+
+    FileUtils.mkdir_p(TMP_BASE)
+  end
+
+  context 'demo application - sinatra' do
+    it 'runs' do
+      clone_application(
+        'https://github.com/mongoid/mongoid-demo',
+        subdir: 'sinatra-minimal',
+      ) do
+
+        process = ChildProcess.build(*%w(bundle exec ruby app.rb))
+        process.environment.update(clean_env)
+        process.io.inherit!
+        process.start
+
+        begin
+          # JRuby needs a long timeout
+          wait_for_port(4567, 20)
+          sleep 1
+
+          uri = URI.parse('http://localhost:4567/posts')
+          resp = JSON.parse(uri.open.read)
+        ensure
+          Process.kill('TERM', process.pid)
+          status = process.wait
+        end
+
+        resp.should == []
+
+        status.should == 0
+      end
+    end
+  end
+
+  context 'demo application - rails-api' do
+    ['~> 6.0.0'].each do |rails_version|
+      context "with rails #{rails_version}" do
+        it 'runs' do
+          clone_application(
+            'https://github.com/mongoid/mongoid-demo',
+            subdir: 'rails-api',
+            rails_version: rails_version,
+          ) do
+
+            process = ChildProcess.build(*%w(bundle exec rails s))
+            process.environment.update(clean_env)
+            process.io.inherit!
+            process.start
+
+            begin
+              # JRuby needs a long timeout
+              wait_for_port(3000, 30)
+              sleep 1
+
+              uri = URI.parse('http://localhost:3000/posts')
+              resp = JSON.parse(uri.open.read)
+            ensure
+              Process.kill('TERM', process.pid)
+              status = process.wait
+            end
+
+            resp.should == []
+
+            # 143 = 128 + 15
+            [0, 15, 143].should include(status)
+          end
+        end
+      end
+    end
+  end
+
+  context 'new application - rails' do
+    ['~> 5.1.0', '~> 5.2.0', '~> 6.0.0'].each do |rails_version|
+      context "with rails #{rails_version}" do
+        it 'creates' do
+          ChildProcessHelper.check_call(%w(gem uni rails -a))
+          ChildProcessHelper.check_call(%w(gem install rails --no-document -v) + [rails_version])
+
+          Dir.chdir(TMP_BASE) do
+            FileUtils.rm_rf('mongoid-test')
+            ChildProcessHelper.check_call(%w(rails new mongoid-test --skip-spring), env: clean_env)
+
+            Dir.chdir('mongoid-test') do
+              adjust_app_gemfile
+              ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+
+              ChildProcessHelper.check_call(%w(rails g model post), env: clean_env)
+              ChildProcessHelper.check_call(%w(rails g model comment post:belongs_to), env: clean_env)
+
+              # https://jira.mongodb.org/browse/MONGOID-4885
+              comment_text = File.read('app/models/comment.rb')
+              comment_text.should =~ /belongs_to :post/
+              comment_text.should_not =~ /embedded_in :post/
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def clone_application(repo_url, subdir: nil, rails_version: nil)
+    Dir.chdir(TMP_BASE) do
+      FileUtils.rm_rf(File.basename(repo_url))
+      ChildProcessHelper.check_call(%w(git clone) + [repo_url])
+      Dir.chdir(File.join(*[File.basename(repo_url), subdir].compact)) do
+        adjust_app_gemfile(rails_version: rails_version)
+        ChildProcessHelper.check_call(%w(bundle install), env: clean_env)
+        puts `git diff`
+
+        config = {'development' => {'clients' => {'default' => {'uri' => SpecConfig.instance.uri_str}}}}
+        File.open('config/mongoid.yml', 'w') do |f|
+          f << YAML.dump(config)
+        end
+
+        yield
+      end
+    end
+  end
+
+  def adjust_app_gemfile(rails_version: nil)
+    lock_lines = IO.readlines('Gemfile.lock')
+    # Get rid of the bundled with line so that whatever bundler is installed
+    # on the system is usable with the application.
+    if i = lock_lines.index("BUNDLED WITH\n")
+      lock_lines.slice!(i, 2)
+      File.open('Gemfile.lock', 'w') do |f|
+        f << lock_lines.join
+      end
+    end
+
+    gemfile_lines = IO.readlines('Gemfile')
+    gemfile_lines.delete_if do |line|
+      line =~ /mongoid/
+    end
+    gemfile_lines << "gem 'mongoid', path: '#{File.expand_path(BASE)}'\n"
+    if rails_version
+      gemfile_lines.delete_if do |line|
+        line =~ /rails/
+      end
+      gemfile_lines << "gem 'rails', '#{rails_version}'\n"
+    end
+    File.open('Gemfile', 'w') do |f|
+      f << gemfile_lines.join
+    end
+  end
+
+  def remove_spring
+    # Spring produces this error in Evergreen:
+    # /data/mci/280eb2ecf4fd69208e2106cd3af526f1/src/rubies/ruby-2.7.0/lib/ruby/gems/2.7.0/gems/spring-2.1.0/lib/spring/client/run.rb:26:
+    # in `initialize': too long unix socket path (126bytes given but 108bytes max) (ArgumentError)
+    # Is it trying to create unix sockets in current directory?
+    # https://stackoverflow.com/questions/30302021/rails-runner-without-spring
+    ChildProcessHelper.check_call(%w(bin/spring binstub --remove --all), env: clean_env)
+  end
+
+  def clean_env
+    @clean_env ||= Hash[ENV.keys.grep(/BUNDLE|RUBYOPT/).map { |k| [k, nil ] }]
+  end
+
+  def wait_for_port(port, timeout)
+    deadline = Time.now + timeout
+    loop do
+      begin
+        Socket.tcp('localhost', port, nil, nil, connect_timeout: 0.5) do |socket|
+          return
+        end
+      rescue IOError, SystemCallError
+        if Time.now > deadline
+          raise
+        end
+      end
+    end
+  end
+end