mongoid 6.4.8 → 7.5.4

data/spec/mongoid/criteria/queryable/extensions/range_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Range do
@@ -11,151 +13,115 @@ describe Range do
 
   describe "#__evolve_date__" do
 
-    context "when the range are dates" do
+    subject(:evolved) { (min..max).__evolve_date__ }
 
-      let(:min) do
-        Date.new(2010, 1, 1)
-      end
-
-      let(:max) do
-        Date.new(2010, 1, 3)
-      end
-
-      let(:evolved) do
-        (min..max).__evolve_date__
-      end
-
-      let(:expected_min) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
-      end
-
-      let(:expected_max) do
-        Time.utc(2010, 1, 3, 0, 0, 0, 0)
-      end
+    context "when the range are dates" do
+      let(:min) { Date.new(2010, 1, 1) }
+      let(:max) { Date.new(2010, 1, 3) }
+      let(:expected_min) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:expected_max) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => expected_min, "$lte" => expected_max }
-        )
+        is_expected.to eq("$gte" => expected_min, "$lte" => expected_max)
       end
     end
 
     context "when the range are strings" do
+      let(:min) { Date.new(2010, 1, 1).to_s }
+      let(:max) { Date.new(2010, 1, 3).to_s }
+      let(:expected_min) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:expected_max) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
 
-      let(:min) do
-        Date.new(2010, 1, 1)
-      end
-
-      let(:max) do
-        Date.new(2010, 1, 3)
-      end
-
-      let(:evolved) do
-        (min.to_s..max.to_s).__evolve_date__
-      end
-
-      let(:expected_min) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => expected_min, "$lte" => expected_max)
       end
+    end
 
-      let(:expected_max) do
-        Time.utc(2010, 1, 3, 0, 0, 0, 0)
-      end
+    context "when the range is floats" do
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:min) { min_time.to_f }
+      let(:max) { max_time.to_f }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => expected_min, "$lte" => expected_max }
-        )
+        is_expected.to eq("$gte" => min_time, "$lte" => max_time)
       end
     end
 
-    context "when the range is floats" do
+    context "when the range is integers" do
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:min) { min_time.to_i }
+      let(:max) { max_time.to_i }
 
-      let(:min_time) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => min_time, "$lte" => max_time)
       end
+    end
 
-      let(:max_time) do
-        Time.utc(2010, 1, 3, 0, 0, 0, 0)
-      end
+    context "when the range is not inclusive" do
+      subject(:evolved) { (min...max).__evolve_date__ }
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:min) { min_time.to_i }
+      let(:max) { max_time.to_i }
 
-      let(:min) do
-        min_time.to_f
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => min_time, "$lt" => max_time)
       end
+    end
 
-      let(:max) do
-        max_time.to_f
-      end
+    context "when the range is endless" do
+      ruby_version_gte '2.7'
 
-      let(:evolved) do
-        (min..max).__evolve_date__
-      end
+      subject(:evolved) { eval('(min..)').__evolve_date__ }
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:min) { min_time.to_i }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => min_time, "$lte" => max_time }
-        )
+        is_expected.to eq("$gte" => min_time)
       end
     end
 
-    context "when the range is integers" do
-
-      let(:min_time) do
-        Time.utc(2010, 1, 1, 0, 0, 0, 0)
-      end
+    context "when the range is beginning-less" do
+      ruby_version_gte '2.7'
 
-      let(:max_time) do
-        Time.utc(2010, 1, 3, 0, 0, 0, 0)
-      end
+      subject(:evolved) { eval('(..max)').__evolve_date__ }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:max) { max_time.to_i }
 
-      let(:min) do
-        min_time.to_i
+      it "returns a selection of times" do
+        is_expected.to eq("$lte" => max_time)
       end
+    end
 
-      let(:max) do
-        max_time.to_i
-      end
+    context "when the range is beginning-less not inclusive" do
+      ruby_version_gte '2.7'
 
-      let(:evolved) do
-        (min..max).__evolve_date__
-      end
+      subject(:evolved) { eval('(...max)').__evolve_date__ }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:max) { max_time.to_i }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => min_time, "$lte" => max_time }
-        )
+        is_expected.to eq("$lt" => max_time)
       end
     end
   end
 
   describe "#__evolve_time__" do
 
-    context "when the range are dates" do
-
-      let(:min) do
-        Time.new(2010, 1, 1, 12, 0, 0)
-      end
-
-      let(:max) do
-        Time.new(2010, 1, 3, 12, 0, 0)
-      end
-
-      let(:evolved) do
-        (min..max).__evolve_time__
-      end
-
-      let(:expected_min) do
-        Time.new(2010, 1, 1, 12, 0, 0).utc
-      end
+    subject(:evolved) do
+      (min..max).__evolve_time__
+    end
 
-      let(:expected_max) do
-        Time.new(2010, 1, 3, 12, 0, 0).utc
-      end
+    context "when the range are dates" do
+      let(:min) { Time.new(2010, 1, 1, 12, 0, 0) }
+      let(:max) { Time.new(2010, 1, 3, 12, 0, 0) }
+      let(:expected_min) { Time.new(2010, 1, 1, 12, 0, 0).utc }
+      let(:expected_max) { Time.new(2010, 1, 3, 12, 0, 0).utc }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => expected_min, "$lte" => expected_max }
-        )
+        is_expected.to eq("$gte" => expected_min, "$lte" => expected_max)
       end
 
       it "returns the times in utc" do
@@ -164,23 +130,11 @@ describe Range do
     end
 
     context "when the range are strings" do
-
-      let(:min) do
-        Time.new(2010, 1, 1, 12, 0, 0)
-      end
-
-      let(:max) do
-        Time.new(2010, 1, 3, 12, 0, 0)
-      end
-
-      let(:evolved) do
-        (min.to_s..max.to_s).__evolve_time__
-      end
+      let(:min) { Time.new(2010, 1, 1, 12, 0, 0).to_s }
+      let(:max) { Time.new(2010, 1, 3, 12, 0, 0).to_s }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => min.to_time, "$lte" => max.to_time }
-        )
+        is_expected.to eq("$gte" => min.to_time, "$lte" => max.to_time)
       end
 
       it "returns the times in utc" do
@@ -189,31 +143,28 @@ describe Range do
     end
 
     context "when the range is floats" do
+      let(:min) { 1331890719.1234 }
+      let(:max) { 1332890719.7651 }
+      let(:expected_min) { Time.at(min).utc }
+      let(:expected_max) { Time.at(max).utc }
 
-      let(:min) do
-        1331890719.1234
-      end
-
-      let(:max) do
-        1332890719.7651
-      end
-
-      let(:evolved) do
-        (min..max).__evolve_time__
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => expected_min, "$lte" => expected_max)
       end
 
-      let(:expected_min) do
-        Time.at(min).utc
+      it "returns the times in utc" do
+        expect(evolved["$gte"].utc_offset).to eq(0)
       end
+    end
 
-      let(:expected_max) do
-        Time.at(max).utc
-      end
+    context "when the range is integers" do
+      let(:min) { 1331890719 }
+      let(:max) { 1332890719 }
+      let(:expected_min) { Time.at(min).utc }
+      let(:expected_max) { Time.at(max).utc }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => expected_min, "$lte" => expected_max }
-        )
+        is_expected.to eq("$gte" => expected_min, "$lte" => expected_max)
       end
 
       it "returns the times in utc" do
@@ -221,89 +172,199 @@ describe Range do
       end
     end
 
-    context "when the range is integers" do
+    context "when the range is not inclusive" do
+      subject(:evolved) { (min...max).__evolve_time__ }
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:min) { min_time.to_i }
+      let(:max) { max_time.to_i }
 
-      let(:min) do
-        1331890719
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => min_time, "$lt" => max_time)
       end
+    end
 
-      let(:max) do
-        1332890719
-      end
+    context "when the range is endless" do
+      ruby_version_gte '2.7'
 
-      let(:evolved) do
-        (min..max).__evolve_time__
-      end
+      subject(:evolved) { eval('(min..)').__evolve_time__ }
+      let(:min_time) { Time.utc(2010, 1, 1, 0, 0, 0, 0) }
+      let(:min) { min_time.to_i }
 
-      let(:expected_min) do
-        Time.at(min).utc
+      it "returns a selection of times" do
+        is_expected.to eq("$gte" => min_time)
       end
+    end
 
-      let(:expected_max) do
-        Time.at(max).utc
-      end
+    context "when the range is beginning-less" do
+      ruby_version_gte '2.7'
+
+      subject(:evolved) { eval('(..max)').__evolve_time__ }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:max) { max_time.to_i }
 
       it "returns a selection of times" do
-        expect(evolved).to eq(
-          { "$gte" => expected_min, "$lte" => expected_max }
-        )
+        is_expected.to eq("$lte" => max_time)
       end
+    end
 
-      it "returns the times in utc" do
-        expect(evolved["$gte"].utc_offset).to eq(0)
+    context "when the range is beginning-less not inclusive" do
+      ruby_version_gte '2.7'
+
+      subject(:evolved) { eval('(...max)').__evolve_time__ }
+      let(:max_time) { Time.utc(2010, 1, 3, 0, 0, 0, 0) }
+      let(:max) { max_time.to_i }
+
+      it "returns a selection of times" do
+        is_expected.to eq("$lt" => max_time)
       end
     end
   end
 
-  describe ".evolve" do
-
+  shared_examples_for "evolve_range" do
     context "when provided a range" do
 
       context "when the range is inclusive" do
+        let(:range) { 1..3 }
 
-        let(:range) do
-          1..3
+        it "returns the inclusive range criterion" do
+          is_expected.to eq("$gte" => 1, "$lte" => 3)
         end
+      end
 
-        it "returns the inclusize range criterion" do
-          expect(described_class.evolve(range)).to eq(
-            { "$gte" => 1, "$lte" => 3 }
-          )
+      context "when the range is not inclusive" do
+        let(:range) { 1...3 }
+
+        it "returns the non inclusive range criterion" do
+          is_expected.to eq("$gte" => 1, "$lt" => 3)
         end
       end
 
-      context "when the range is not inclusve" do
+      context "when the range is endless" do
+        ruby_version_gte '2.7'
 
-        let(:range) do
-          1...3
+        let(:range) { eval('1..') }
+
+        it "returns the endless range criterion" do
+          is_expected.to eq("$gte" => 1)
         end
+      end
 
-        it "returns the non inclusive range criterion" do
-          expect(described_class.evolve(range)).to eq(
-            { "$gte" => 1, "$lte" => 2 }
-          )
+      context "when the range is endless not inclusive" do
+        ruby_version_gte '2.7'
+
+        let(:range) { eval('1...') }
+
+        it "returns the endless range criterion" do
+          is_expected.to eq("$gte" => 1)
         end
       end
 
-      context "when the range is characters" do
+      context "when the range is beginning-less" do
+        ruby_version_gte '2.7'
 
-        let(:range) do
-          "a".."z"
+        let(:range) { eval('..1') }
+
+        it "returns the endless range criterion" do
+          is_expected.to eq("$lte" => 1)
         end
+      end
+
+      context "when the range is beginning-less not inclusive" do
+        ruby_version_gte '2.7'
+
+        let(:range) { eval('...1') }
+
+        it "returns the endless range criterion" do
+          is_expected.to eq("$lt" => 1)
+        end
+      end
+
+      context "when the range is characters" do
+        let(:range) { "a".."z" }
 
         it "returns the character range" do
-          expect(described_class.evolve(range)).to eq(
-            { "$gte" => "a", "$lte" => "z" }
-          )
+          is_expected.to eq("$gte" => "a", "$lte" => "z")
         end
       end
     end
 
-    context "when provided a string" do
+    context "when provided Float objects" do
+      let(:range) { 1.3..4.5 }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq("$gte" => 1.3, "$lte" => 4.5)
+      end
+    end
+
+    context "when provided Date objects" do
+      let(:range) { Date.new(2010, 1, 1)..Date.new(2010, 1, 3) }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.utc(2010, 1, 1, 0, 0, 0, 0), "$lte" => Time.utc(2010, 1, 3, 0, 0, 0, 0) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
+      end
+    end
+
+    context "when provided Time objects" do
+      let(:range) { Time.at(0)..Time.at(1) }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.at(0), "$lte" => Time.at(1) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
+      end
+    end
+
+    context "when provided ActiveSupport::TimeWithZone objects" do
+      let(:range) { Time.at(0).in_time_zone..Time.at(1).in_time_zone }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.at(0), "$lte" => Time.at(1) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
+      end
+    end
+
+    context "when provided Date objects" do
+      let(:range) { Date.new(2010, 1, 1)..Date.new(2010, 1, 3) }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.utc(2010, 1, 1, 0, 0, 0, 0), "$lte" => Time.utc(2010, 1, 3, 0, 0, 0, 0) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
+      end
+    end
+
+    context "when provided mixed Time and Date objects" do
+      let(:range) { Time.at(0)..Date.new(2010, 1, 3) }
+
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.at(0), "$lte" => Time.utc(2010, 1, 3, 0, 0, 0, 0) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
+      end
+    end
+
+    context "when provided mixed Date and Time objects" do
+      let(:range) { Time.at(0).in_time_zone..Time.at(1).in_time_zone }
 
-      it "returns the string" do
-        expect(described_class.evolve("testing")).to eq("testing")
+      it "returns the range as Time objects" do
+        is_expected.to eq({ "$gte" => Time.at(0), "$lte" => Time.at(1) })
+        expect(subject["$gte"].utc?).to be(true)
+        expect(subject["$lte"].utc?).to be(true)
       end
     end
   end
+
+  describe "#__evolve_range__" do
+    subject { range.__evolve_range__ }
+    it_behaves_like 'evolve_range'
+  end
+
+  describe ".evolve" do
+    subject { described_class.evolve(range) }
+    it_behaves_like 'evolve_range'
+  end
 end

data/spec/mongoid/criteria/queryable/extensions/regexp_raw_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
-describe Mongoid::Criteria::Queryable::Extensions::Regexp::Raw do
+describe Mongoid::Criteria::Queryable::Extensions::Regexp::Raw_ do
 
   describe ".evolve" do
 

data/spec/mongoid/criteria/queryable/extensions/regexp_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 
@@ -8,7 +10,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
     context "when provided a regexp" do
 
       let(:regexp) do
-        /^[123]/
+        /\A[123]/
       end
 
       let(:evolved) do
@@ -23,7 +25,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
     context "when provided a string" do
 
       let(:regexp) do
-        "^[123]"
+        "\\A[123]"
       end
 
       let(:evolved) do
@@ -31,7 +33,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       end
 
       it "returns the converted regexp" do
-        expect(evolved).to eq(/^[123]/)
+        expect(evolved).to eq(/\A[123]/)
       end
     end
 
@@ -40,7 +42,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       context "when the elements are regexps" do
 
         let(:regexp) do
-          /^[123]/
+          /\A[123]/
         end
 
         let(:array) do
@@ -63,7 +65,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
       context "when the elements are strings" do
 
         let(:regexp) do
-          "^[123]"
+          "\\A[123]"
         end
 
         let(:evolved) do
@@ -71,7 +73,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
         end
 
         it "returns the regexps" do
-          expect(evolved).to eq([ /^[123]/ ])
+          expect(evolved).to eq([ /\A[123]/ ])
         end
       end
     end
@@ -80,7 +82,7 @@ describe Mongoid::Criteria::Queryable::Extensions::Regexp do
   describe "#regexp?" do
 
     let(:regexp) do
-      /^[123]/
+      /\A[123]/
     end
 
     it "returns true" do

data/spec/mongoid/criteria/queryable/extensions/set_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Set do

data/spec/mongoid/criteria/queryable/extensions/string_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe String do
@@ -66,6 +68,49 @@ describe String do
         expect(evolved).to eq(Time.new(2010, 1, 1, 11, 0, 0, 0).utc)
       end
     end
+
+    context "when the string without timezone" do
+
+      context "when using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = true
+          ::Time.zone = "Tokyo"
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using active support's time zone" do
+          expect(evolved).to eq(Time.zone.parse(date).utc)
+        end
+      end
+
+      context "when not using active support's time zone" do
+
+        before do
+          Mongoid.use_activesupport_time_zone = false
+          ::Time.zone = nil
+        end
+
+        let(:date) do
+          "2010-01-01 5:00:00"
+        end
+
+        let(:evolved) do
+          date.__evolve_time__
+        end
+
+        it "parses string using system time zone" do
+          expect(evolved).to eq(Time.parse(date).utc)
+        end
+      end
+    end
   end
 
   describe "#__sort_option__" do
@@ -272,7 +317,7 @@ describe String do
     context "when provided a regex" do
 
       let(:regex) do
-        /^[123]/
+        /\A[123]/.freeze
       end
 
       let(:evolved) do