mongoid-cached-json 1.6.0 → 1.7.0

data/spec/all_fields_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Declaring all stored fields' do
+  before do
+    class AllFieldsDocument
+      include Mongoid::Document
+      include Mongoid::CachedJson
+      field :name
+      field :secret
+
+      def display_name
+        name.upcase
+      end
+
+      json_fields :all, secret: { properties: :all }, display_name: {}
+      field :added_later
+    end
+  end
+
+  after do
+    AllFieldsDocument.delete_all
+    Object.send(:remove_const, :AllFieldsDocument)
+  end
+
+  it 'expands fields at declaration time and adds computed fields' do
+    document = AllFieldsDocument.create!(name: 'example', secret: 'hidden', added_later: 'not declared')
+    expected = { _id: document.id, name: 'example', display_name: 'EXAMPLE' }
+    expect(document.as_json).to eq(expected)
+    expect([document].as_json).to eq([expected])
+    expect(document.as_json(properties: :all)).to eq(expected.merge(secret: 'hidden'))
+  end
+
+  it 'retains the normal field cache and invalidation behavior' do
+    document = AllFieldsDocument.create!(name: 'example')
+    document.as_json
+    document.name = 'unsaved'
+    expect(document.as_json[:name]).to eq('example')
+    document.save!
+    expect(document.as_json[:name]).to eq('unsaved')
+  end
+
+  it 'does not expose extra fields for ordinary explicit declarations' do
+    document = JsonFoobar.create!(foo: 'visible', bar: 'private')
+    expect(document.as_json).not_to have_key(:bar)
+    expect(document.as_json).not_to have_key(:_id)
+  end
+end

data/spec/cache_version_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe 'Schema cache versions' do
+  before do
+    class VersionedDocument
+      include Mongoid::Document
+      include Mongoid::CachedJson
+      field :value
+      json_fields cache_version: 1, value: {}
+    end
+  end
+
+  after do
+    VersionedDocument.delete_all
+    Object.send(:remove_const, :VersionedDocument)
+  end
+
+  [true, false].each do |bulk|
+    context "with bulk reads #{bulk}" do
+      before do
+        @store = ActiveSupport::Cache::MemoryStore.new
+        @store.singleton_class.send(:undef_method, :read_multi) unless bulk
+        Mongoid::CachedJson.config.cache = @store
+      end
+
+      it 'separates new schema fragments without changing the API version' do
+        document = VersionedDocument.create!(value: 'old')
+        expect(document.as_json).to eq(value: 'old')
+        document.value = 'new'
+        expect(document.as_json).to eq(value: 'old')
+        VersionedDocument.cached_json_cache_version = 2
+        expect(document.as_json).to eq(value: 'new')
+        VersionedDocument.cached_json_cache_version = 1
+        expect(document.as_json).to eq(value: 'old')
+      end
+
+      it 'invalidates the current namespace on a model update' do
+        document = VersionedDocument.create!(value: 'old')
+        [1, 2].each do |version|
+          VersionedDocument.cached_json_cache_version = version
+          document.as_json
+        end
+        document.update_attributes!(value: 'new')
+        expect(document.as_json).to eq(value: 'new')
+        VersionedDocument.cached_json_cache_version = 1
+        expect(document.as_json).to eq(value: 'old')
+      end
+
+      it 'uses the schema version for child fragments too' do
+        document = VersionedDocument.create!(value: 'old')
+        options = { properties: :short, version: :unspecified, is_top_level_json: false }
+        key = VersionedDocument.cached_json_key(options, VersionedDocument, document.id)
+        expect(key).to end_with('/false/schema/1')
+        expect([document].as_json).to eq([{ value: 'old' }])
+      end
+    end
+  end
+end

data/spec/cached_json_spec.rb

@@ -6,7 +6,7 @@ describe Mongoid::CachedJson do
     expect(Mongoid::CachedJson::VERSION.to_f).to be > 0
   end
 
-  [:dalli_store, :memory_store].each do |cache_store|
+  [MEMCACHE_STORE, :memory_store].each do |cache_store|
     context "#{cache_store}" do
       before :each do
         @cache = Mongoid::CachedJson::Config.cache
@@ -95,7 +95,7 @@ describe Mongoid::CachedJson do
           3.times do
             3.times do
               manager_short_json = manager.as_json(properties: :short)
-              expect(manager_short_json.length).to eq(2)
+              expect(manager_short_json.length).to eq(3)
               expect(manager_short_json[:name]).to eq('Boss')
               expect(manager_short_json[:employees].member?(name: 'Peon')).to be_truthy
               expect(manager_short_json[:employees].member?(name: 'Indentured servant')).to be_truthy
@@ -104,7 +104,7 @@ describe Mongoid::CachedJson do
             end
             3.times do
               manager_public_json = manager.as_json(properties: :public)
-              expect(manager_public_json.length).to eq(2)
+              expect(manager_public_json.length).to eq(3)
               expect(manager_public_json[:name]).to eq('Boss')
               expect(manager_public_json[:employees].member?(name: 'Peon')).to be_truthy
               expect(manager_public_json[:employees].member?(name: 'Indentured servant')).to be_truthy
@@ -113,7 +113,7 @@ describe Mongoid::CachedJson do
             end
             3.times do
               manager_all_json = manager.as_json(properties: :all)
-              expect(manager_all_json.length).to eq(3)
+              expect(manager_all_json.length).to eq(4)
               expect(manager_all_json[:name]).to eq('Boss')
               expect(manager_all_json[:ssn]).to eq('123-45-6789')
               expect(manager_all_json[:employees].member?(name: 'Peon', nickname: 'My Favorite')).to be_truthy
@@ -132,15 +132,15 @@ describe Mongoid::CachedJson do
           manager = JsonManager.create!(name: 'JsonManager')
           employee = manager.json_employees.create!(name: 'JsonEmployee')
           3.times do
-            expect(manager.as_json(properties: :short)).to eq(name: 'JsonManager', employees: [{ name: 'JsonEmployee' }])
+            expect(manager.as_json(properties: :short)).to eq(name: 'JsonManager', employees: [{ name: 'JsonEmployee' }], has_left_handed_employee: false)
             expect(employee.as_json(properties: :short)).to eq(name: 'JsonEmployee')
           end
           manager.name = 'New JsonManager'
           manager.save
-          3.times { expect(manager.as_json(properties: :short)).to eq(name: 'New JsonManager', employees: [{ name: 'JsonEmployee' }]) }
+          3.times { expect(manager.as_json(properties: :short)).to eq(name: 'New JsonManager', employees: [{ name: 'JsonEmployee' }], has_left_handed_employee: false) }
           employee.name = 'New JsonEmployee'
           employee.save
-          3.times { expect(manager.as_json(properties: :short)).to eq(name: 'New JsonManager', employees: [{ name: 'New JsonEmployee' }]) }
+          3.times { expect(manager.as_json(properties: :short)).to eq(name: 'New JsonManager', employees: [{ name: 'New JsonEmployee' }], has_left_handed_employee: false) }
         end
         context 'reference_properties' do
           it 'limits the json fields of a child relationship' do
@@ -220,6 +220,7 @@ describe Mongoid::CachedJson do
         end
         it 'should yield JSON without an instance of a child' do
           p = SecretParent.create(name: 'Parent')
+          expect(p.as_json(properties: :short)).to eq(name: 'Parent', child: nil)
           expect(p.as_json(properties: :all)[:child]).to be_nil
         end
         it 'should yield child JSON when as_json is called on the parent and hide_as_child_json_when returns false on an instance' do
@@ -230,8 +231,8 @@ describe Mongoid::CachedJson do
         it 'should not yield child JSON when as_json is called on the parent and hide_as_child_json_when returns true on an instance' do
           p = SecretParent.create(name: 'Parent')
           p.create_sometimes_secret(should_tell_secret: false)
-          expect(p.as_json(properties: :short)).to eq(name: 'Parent', child: nil)
-          expect(p.as_json(properties: :short)[:child]).to be_nil
+          expect(p.as_json(properties: :short)).to eq(name: 'Parent')
+          expect(p.as_json(properties: :short)).not_to have_key(:child)
         end
       end
       context 'relationships with a multi-level hierarchy' do
@@ -353,9 +354,9 @@ describe Mongoid::CachedJson do
           example = JsonFoobar.create(foo: 'FOO', baz: 'BAZ', bar: 'BAR')
           key = "as_json/unspecified/JsonFoobar/#{example.id}/short/true"
           case cache_store
-          when :memory_store then
+          when :memory_store
             expect(Mongoid::CachedJson.config.cache).to receive(:fetch).with(key, force: true).twice
-          when :dalli_store then
+          when :dalli_store, :mem_cache_store
             expect(Mongoid::CachedJson.config.cache).not_to receive(:write)
           else
             fail ArgumentError, "invalid cache store: #{cache_store}"
@@ -496,6 +497,14 @@ describe Mongoid::CachedJson do
           expect(@image.as_json(properties: :all)).to eq(name: 'Image', urls: [])
         end
       end
+      context 'evaluating a false-y value in a reference type' do
+        it 'correctly returns false instead of nil' do
+          manager = JsonManager.create!(name: 'Boss')
+          manager.json_employees.create!(name: 'Matt')
+          manager_short_json = manager.as_json(properties: :short)
+          expect(manager_short_json[:has_left_handed_employee]).to eq(false)
+        end
+      end
     end
   end
 end

data/spec/dalli_spec.rb

@@ -1,18 +1,17 @@
 require 'spec_helper'
-require 'active_support/cache/dalli_store'
 
-describe ActiveSupport::Cache::DalliStore do
+describe MEMCACHE_STORE_CLASS do
   before :each do
     @cache = Mongoid::CachedJson::Config.cache
     Mongoid::CachedJson.configure do |config|
-      config.cache = ActiveSupport::Cache.lookup_store(:dalli_store)
+      config.cache = ActiveSupport::Cache.lookup_store(MEMCACHE_STORE)
     end
   end
   after :each do
     Mongoid::CachedJson::Config.cache = @cache
   end
   it 'uses dalli_store' do
-    expect(Mongoid::CachedJson.config.cache).to be_a ActiveSupport::Cache::DalliStore
+    expect(Mongoid::CachedJson.config.cache).to be_a MEMCACHE_STORE_CLASS
   end
   context 'read_multi' do
     context 'array' do

data/spec/field_cache_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'Per-field cache policy' do
+  before do
+    class FieldCacheDocument
+      include Mongoid::Document
+      include Mongoid::CachedJson
+
+      field :stored
+      field :live
+
+      json_fields stored: {}, live: { cache: false }
+    end
+
+    class FieldCacheChild
+      include Mongoid::Document
+      include Mongoid::CachedJson
+
+      field :value
+
+      json_fields value: {}
+    end
+
+    class FieldCacheParent
+      include Mongoid::Document
+      include Mongoid::CachedJson
+
+      field :name
+      attr_accessor :child
+
+      json_fields name: {}, child: { type: :reference, cache: false }
+    end
+  end
+
+  after do
+    [FieldCacheDocument, FieldCacheChild, FieldCacheParent].each(&:delete_all)
+    [:FieldCacheDocument, :FieldCacheChild, :FieldCacheParent].each { |name| Object.send(:remove_const, name) }
+  end
+
+  [true, false].each do |bulk|
+    context "with bulk reads #{bulk}" do
+      before do
+        @store = ActiveSupport::Cache::MemoryStore.new
+        @store.singleton_class.send(:undef_method, :read_multi) unless bulk
+        Mongoid::CachedJson.config.cache = @store
+      end
+
+      it 'recomputes an individual callable field without refreshing cached siblings' do
+        document = FieldCacheDocument.create!(stored: 'stored', live: 'first')
+        expect(document.as_json).to eq(stored: 'stored', live: 'first')
+
+        document.stored = 'unsaved'
+        document.live = 'second'
+        expect(document.as_json).to eq(stored: 'stored', live: 'second')
+      end
+
+      it 'bypasses the referenced model cache only for this field' do
+        parent = FieldCacheParent.create!(name: 'parent')
+        child = FieldCacheChild.create!(value: 'first')
+        parent.child = child
+        options = { properties: :short, version: :unspecified, is_top_level_json: false }
+        key = FieldCacheChild.cached_json_key(options, FieldCacheChild, child.id)
+
+        expect(parent.as_json).to eq(name: 'parent', child: { value: 'first' })
+        expect(@store.read(key)).to be_nil
+
+        child.value = 'second'
+        expect(parent.as_json).to eq(name: 'parent', child: { value: 'second' })
+        expect(@store.read(key)).to be_nil
+      end
+    end
+  end
+end

data/spec/model_cache_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe 'Per-model cache policy' do
+  before do
+    class UncachedDocument
+      include Mongoid::Document
+      include Mongoid::CachedJson
+      field :value
+      json_fields disable_caching: true, value: {}
+    end
+
+    class CachedContainer
+      include Mongoid::Document
+      include Mongoid::CachedJson
+      field :value
+      attr_accessor :child
+
+      json_fields value: {}, child: { type: :reference }
+    end
+  end
+
+  after do
+    [UncachedDocument, CachedContainer].each(&:delete_all)
+    [:UncachedDocument, :CachedContainer].each { |name| Object.send(:remove_const, name) }
+  end
+
+  [true, false].each do |bulk|
+    context "with bulk reads #{bulk}" do
+      before do
+        @store = ActiveSupport::Cache::MemoryStore.new
+        @store.singleton_class.send(:undef_method, :read_multi) unless bulk
+        Mongoid::CachedJson.config.cache = @store
+      end
+
+      it 'does not read or write shared cache for a disabled model' do
+        document = UncachedDocument.create!(value: 'first')
+        expect(@store).not_to receive(:read_multi)
+        expect(@store).not_to receive(:fetch)
+        expect(@store).not_to receive(:write)
+        expect(document.as_json).to eq(value: 'first')
+        document.value = 'second'
+        expect([document].as_json).to eq([{ value: 'second' }])
+      end
+
+      it 'keeps the parent cached while recomputing a disabled child' do
+        parent = CachedContainer.create!(value: 'parent')
+        child = UncachedDocument.create!(value: 'first')
+        parent.child = child
+        expect(parent.as_json).to eq(value: 'parent', child: { value: 'first' })
+        parent.value = 'not saved'
+        child.value = 'second'
+        expect(parent.as_json).to eq(value: 'parent', child: { value: 'second' })
+      end
+
+      it 'does not disable caching on other models' do
+        expect(CachedContainer.cached_json_disable_caching).to be_falsey
+        document = CachedContainer.create!(value: 'first')
+        document.as_json
+        document.value = 'second'
+        expect(document.as_json[:value]).to eq('first')
+      end
+    end
+  end
+end

data/spec/mongoid_criteria_spec.rb

@@ -68,7 +68,8 @@ describe Mongoid::Criteria do
       )
       # read_multi returned only 2 of 3 things, don't call fetch, just store the third value
       expect(Mongoid::CachedJson.config.cache).not_to receive(:fetch)
-      expect(Mongoid::CachedJson.config.cache).to receive(:write).with("as_json/unspecified/Tool/#{tool2.id}/all/true", name: 'screwdriver')
+      expected_json = { name: 'screwdriver' }
+      expect(Mongoid::CachedJson.config.cache).to receive(:write).with("as_json/unspecified/Tool/#{tool2.id}/all/true", expected_json)
       expect(tool_box.tools.as_json(properties: :all)).to eq([
         { tool_box: { x: :y }, x: :y },
         { tool_box: { x: :y }, name: 'screwdriver' }

data/spec/spec_helper.rb

@@ -1,3 +1,11 @@
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    track_files 'lib/**/*.rb'
+    add_filter '/spec/'
+  end
+end
+
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
@@ -11,8 +19,22 @@ end
 
 Mongoid.configure do |config|
   config.connect_to('cached_json_test')
+  if Mongoid::VERSION.to_i >= 5
+    config.clients['default']['hosts'] = [ENV.fetch('MONGODB_HOST', 'localhost:27017')]
+  else
+    config.sessions['default']['hosts'] = [ENV.fetch('MONGODB_HOST', 'localhost:27017')]
+  end
 end
 
+if ActiveSupport::VERSION::MAJOR >= 6
+  require 'active_support/cache/mem_cache_store'
+else
+  require 'active_support/cache/dalli_store'
+end
+
+MEMCACHE_STORE = ActiveSupport::VERSION::MAJOR >= 6 ? :mem_cache_store : :dalli_store
+MEMCACHE_STORE_CLASS = ActiveSupport::Cache.lookup_store(MEMCACHE_STORE).class
+
 RSpec.configure do |config|
   config.raise_errors_for_deprecations!
   config.after :each do

data/spec/support/json_employee.rb

@@ -4,6 +4,7 @@ class JsonEmployee
 
   field :name
   field :nickname, default: 'My Favorite'
+  field :is_left_handed, type: Boolean, default: false
   belongs_to :json_manager
 
   json_fields \

data/spec/support/json_manager.rb

@@ -12,8 +12,13 @@ class JsonManager
     belongs_to :supervisor, class_name: 'JsonSupervisor', required: false
   end
 
+  def has_left_handed_employee?
+    json_employees.any? { |e| e.is_left_handed? }
+  end
+
   json_fields \
     name: {},
     ssn: { properties: :all },
-    employees: { type: :reference, definition: :json_employees }
+    employees: { type: :reference, definition: :json_employees },
+    has_left_handed_employee: { type: :reference, definition: :has_left_handed_employee? }
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-cached-json
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Aaron Windsor
 - Daniel Doubrovkine
 - Frank Macreery
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-06-01 00:00:00.000000000 Z
+date: 2026-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -26,23 +26,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
-description: 
+description:
 email: dblock@dblock.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/danger-comment.yml"
+- ".github/workflows/danger.yml"
+- ".github/workflows/test.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
-- ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
+- Dangerfile
 - Gemfile
 - LICENSE.md
 - README.md
 - Rakefile
+- UPGRADING.md
 - lib/mongoid-cached-json.rb
 - lib/mongoid-cached-json/array.rb
 - lib/mongoid-cached-json/cached_json.rb
@@ -52,12 +56,16 @@ files:
 - lib/mongoid-cached-json/mongoid_criteria.rb
 - lib/mongoid-cached-json/version.rb
 - mongoid-cached-json.gemspec
+- spec/all_fields_spec.rb
 - spec/array_spec.rb
 - spec/benchmark_spec.rb
+- spec/cache_version_spec.rb
 - spec/cached_json_spec.rb
 - spec/config_spec.rb
 - spec/dalli_spec.rb
+- spec/field_cache_spec.rb
 - spec/hash_spec.rb
+- spec/model_cache_spec.rb
 - spec/mongoid_criteria_spec.rb
 - spec/spec_helper.rb
 - spec/support/awesome_artwork.rb
@@ -91,7 +99,7 @@ homepage: http://github.com/mongoid/mongoid-cached-json
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +114,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.5.16
+signing_key:
 specification_version: 4
 summary: Cached-json is a DSL for describing JSON representations of Mongoid models.
 test_files: []

data/.travis.yml

@@ -1,40 +0,0 @@
-sudo: false
-
-script: bundle exec rake spec
-
-services:
-  - mongodb
-  - memcache
-
-rvm:
-  - 2.0.0
-  - 2.1.10
-  - 2.2.10
-  - 2.3.7
-  - 2.4.6
-  - 2.5.5
-  - 2.6.3
-
-env:
-  - MONGOID_VERSION=3
-  - MONGOID_VERSION=4
-  - MONGOID_VERSION=5
-  - MONGOID_VERSION=6
-  - MONGOID_VERSION=7
-
-cache: bundler
-
-matrix:
-  include:
-    - rvm: 2.6.3
-      env: RUBOCOP=true
-      script: bundle exec rake rubocop
-  exclude:
-    - rvm: 2.0.0
-      env: MONGOID_VERSION=6
-    - rvm: 2.1.10
-      env: MONGOID_VERSION=6
-    - rvm: 2.0.0
-      env: MONGOID_VERSION=7
-    - rvm: 2.1.10
-      env: MONGOID_VERSION=7