lex-apollo 0.4.23 → 0.4.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af5cbbe35e69f28430c0c4d2862294024e465b79a7fdba279bb50562bc0d81d4
-  data.tar.gz: d2cf12984c06eb60752f7202935649a411377ca141e20d719d2faa2ec4c05b3b
+  metadata.gz: 2dceee29e5b2af12bab5833beac8b837d2366eaf9509c7e4ce04e88b44a5c28f
+  data.tar.gz: 97d62a6385f375b19a6f48b1881fef8525e5949c4348bfe0cd07581d9ff710f2
 SHA512:
-  metadata.gz: a2bf398b3f6df58ec0e84f810f7ba4e48e68991c88f95ae8e5614ba4510ae7ab9be3994dc757f34138073797cb2af99c795d532f4e24dc9fb2f09ffa0b18d13f
-  data.tar.gz: fad944b5457ef0574bb53b1d88251d5d4dce1a70b3cbe8ffadb25b3938877a0170cd36adbf41705d066d84f7036043914efa6b7473db5999daf24badde8a7f5d
+  metadata.gz: 90065729231f3322eeaaeaa0e44e03b9b79350157674bec30f174fa6447d74bc53b4794e3385eee9d617c13c62cb22198de39fc21ebece7d2d512e7b1dd09ba6
+  data.tar.gz: f1c1b607fd9d9d244c0937b654ea95ca361980f5732c6e513719a6163004595ce0aaa9baab4181db56c8e6e8d1c511c1d6695c9110905e2094a252ba06e5a2c6

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.4.24] - 2026-05-07
+
+### Fixed
+- Prevent zero-vector embeddings from being stored as valid semantic vectors when LLM embedding is unavailable.
+- Avoid self-referential corroboration relations, bound corroboration maintenance scans, and preserve valid decay age filtering.
+- Parse structured GAS LLM phase responses from `result[:data]` before falling back to JSON strings.
+- Make Apollo write-privilege memoization thread-safe.
+
 ## [0.4.23] - 2026-05-06
 
 ### Fixed

data/lib/legion/extensions/apollo/gaia_integration.rb

@@ -24,8 +24,9 @@ module Legion
           end
 
           def publishable?(insight)
-            (insight[:confidence] || 0) > PUBLISH_CONFIDENCE_THRESHOLD &&
-              (insight[:novelty] || 0) > PUBLISH_NOVELTY_THRESHOLD
+            confidence = (insight[:confidence] || 0).to_f
+            novelty = insight[:novelty] ? insight[:novelty].to_f : (1.0 - confidence)
+            confidence > PUBLISH_CONFIDENCE_THRESHOLD && novelty > PUBLISH_NOVELTY_THRESHOLD
           end
 
           def handle_mesh_departure(agent_id:)

data/lib/legion/extensions/apollo/helpers/capability.rb

@@ -9,6 +9,7 @@ module Legion
           extend Legion::Settings::Helper
 
           EMBEDDING_MODELS = %w[mxbai-embed-large bge-large snowflake-arctic-embed].freeze
+          PRIVILEGE_MUTEX = Mutex.new
 
           module_function
 
@@ -57,11 +58,13 @@ module Legion
           end
 
           def check_db_write_privilege
-            return @apollo_write_privilege unless @apollo_write_privilege.nil?
+            PRIVILEGE_MUTEX.synchronize do
+              return @apollo_write_privilege unless @apollo_write_privilege.nil?
 
-            @apollo_write_privilege = Legion::Data.connection
-                                                  .fetch("SELECT has_table_privilege(current_user, 'apollo_entries', 'INSERT') AS can_insert")
-                                                  .first[:can_insert] == true
+              @apollo_write_privilege = Legion::Data.connection
+                                                    .fetch("SELECT has_table_privilege(current_user, 'apollo_entries', 'INSERT') AS can_insert")
+                                                    .first[:can_insert] == true
+            end
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.capability.check_db_write_privilege')
             @apollo_write_privilege = false

data/lib/legion/extensions/apollo/runners/gas.rb

@@ -212,7 +212,7 @@ module Legion
             { from_content: fact[:content], to_id: entry[:id], relation_type: 'similar_to', confidence: fallback_confidence }
           end
 
-          def llm_classify_relation(fact, entry)
+          def llm_classify_relation(fact, entry) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
             prompt = <<~PROMPT
               Classify the relationship between these two knowledge entries.
               Valid types: #{RELATION_TYPES.join(', ')}
@@ -245,9 +245,13 @@ module Legion
               phase:   'gas_relate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            rels = parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+            rels = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                     result[:data][:relations] || result.dig(:data, 'relations') || []
+                   else
+                     content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                     parsed = json_load(content)
+                     parsed.is_a?(Hash) ? (parsed[:relations] || parsed['relations'] || []) : []
+                   end
             best = rels.max_by { |r| r[:confidence] || r['confidence'] || 0 }
 
             return fallback_relation(fact, entry) unless best
@@ -302,9 +306,13 @@ module Legion
               phase:   'gas_synthesize'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            items = parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+            items = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                      result[:data][:synthesis] || result.dig(:data, 'synthesis') || []
+                    else
+                      content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                      parsed = json_load(content)
+                      parsed.is_a?(Hash) ? (parsed[:synthesis] || parsed['synthesis'] || []) : []
+                    end
 
             items.map { |item| build_synthesis_entry(item, facts) }
           rescue StandardError => e
@@ -358,9 +366,13 @@ module Legion
               phase:   'gas_anticipate'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            questions = parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+            questions = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                          result[:data][:questions] || result.dig(:data, 'questions') || []
+                        else
+                          content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                          parsed = json_load(content)
+                          parsed.is_a?(Hash) ? (parsed[:questions] || parsed['questions'] || []) : []
+                        end
             questions = questions.first(max_anticipations)
 
             questions.map do |q|
@@ -426,9 +438,13 @@ module Legion
               phase:   'gas_comprehend'
             )
 
-            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
-            parsed = json_load(content)
-            facts_array = parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+            facts_array = if result.is_a?(Hash) && result[:data].is_a?(Hash)
+                            result[:data][:facts] || result.dig(:data, 'facts') || []
+                          else
+                            content = result.respond_to?(:message) ? result.message[:content] : result.to_s
+                            parsed = json_load(content)
+                            parsed.is_a?(Hash) ? (parsed[:facts] || parsed['facts'] || []) : Array(parsed)
+                          end
             facts_array.map do |f|
               {
                 content:      f[:content] || f['content'],

data/lib/legion/extensions/apollo/runners/knowledge.rb

@@ -133,7 +133,7 @@ module Legion
             { success: false, error: e.message }
           end
 
-          def handle_query(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: UNSET, tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Layout/LineLength
+          def handle_query(query:, limit: Helpers::GraphQuery.default_query_limit, min_confidence: Helpers::GraphQuery.default_query_min_confidence, status: UNSET, tags: nil, domain: nil, agent_id: 'unknown', **) # rubocop:disable Layout/LineLength, Metrics/CyclomaticComplexity
             return { success: false, error: 'apollo_data_not_available' } unless Helpers::DataModels.apollo_entry_available?
 
             entry_model = Helpers::DataModels.apollo_entry
@@ -147,6 +147,12 @@ module Legion
             end
 
             embedding = embed_text(query)
+            if embedding.nil?
+              log.warn('Apollo Knowledge.handle_query embedding unavailable; falling back to browse query')
+              return list_entries_chronologically(query: query, limit: limit, status: requested_status,
+                                                  status_defaulted: status_defaulted, tags: tags, domain: domain)
+            end
+
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
               statuses: Array(requested_status).map(&:to_s), tags: tags, domain: domain
@@ -255,6 +261,11 @@ module Legion
             return { success: true, entries: [], count: 0 } if query.nil? || query.to_s.strip.empty?
 
             embedding = embed_text(query)
+            if embedding.nil?
+              log.warn('Apollo Knowledge.retrieve_relevant embedding unavailable; returning empty result')
+              return { success: true, entries: [], count: 0, degraded: :no_embedding }
+            end
+
             sql = Helpers::GraphQuery.build_semantic_search_sql(
               limit: limit, min_confidence: min_confidence,
               statuses: %w[confirmed candidate], tags: tags, domain: domain
@@ -354,12 +365,6 @@ module Legion
               return { success: false, error: 'content is required' }
             end
 
-            if content_type.nil?
-              log.warn('[apollo][handle_ingest] early-return: content_type is required ' \
-                       "content_length=#{content.to_s.length}")
-              return { success: false, error: 'content_type is required' }
-            end
-
             return nil if Helpers::DataModels.apollo_entry_available?
 
             log.warn('[apollo][handle_ingest] early-return: apollo_data_not_available ' \
@@ -378,16 +383,16 @@ module Legion
             log.debug("Apollo Knowledge.embed_text text_length=#{text.length}")
             result = Legion::LLM::Call::Embeddings.generate(text: text)
             vector = result.is_a?(Hash) ? result[:vector] : result
-            if vector.is_a?(Array) && vector.any?
+            if vector.is_a?(Array) && vector.any? && vector.any? { |v| v != 0.0 }
               log.debug("Apollo Knowledge.embed_text vector_dimensions=#{vector.length}")
               vector
             else
-              log.warn('Apollo Knowledge.embed_text returned no vector; using zero-vector fallback')
-              Array.new(1024, 0.0)
+              log.warn('Apollo Knowledge.embed_text returned no usable vector; skipping embedding')
+              nil
             end
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'apollo.knowledge.embed_text')
-            Array.new(1024, 0.0)
+            nil
           end
 
           def normalize_text_input(value)
@@ -460,7 +465,7 @@ module Legion
               submitted_by:     metadata[:submitted_by],
               submitted_from:   metadata[:submitted_from],
               content_hash:     content_hash,
-              embedding:        Sequel.lit("'[#{embedding.join(',')}]'::vector")
+              embedding:        embedding ? Sequel.lit("'[#{embedding.join(',')}]'::vector") : nil
             )
             log.info("Apollo Knowledge.handle_ingest created entry_id=#{new_entry.id} status=candidate domain=#{metadata[:domain]} source_agent=#{metadata[:source_agent]}") # rubocop:disable Layout/LineLength
             new_entry.id
@@ -584,6 +589,8 @@ module Legion
           end
 
           def find_corroboration(embedding, content_type_sym, source_agent, source_channel = nil)
+            return [false, nil] unless embedding
+
             scan_limit = Helpers::Confidence.apollo_setting(:corroboration, :scan_limit, default: 50)
             log.debug("Apollo Knowledge.find_corroboration content_type=#{content_type_sym} source_agent=#{source_agent} source_channel=#{source_channel || 'nil'} scan_limit=#{scan_limit}") # rubocop:disable Layout/LineLength
             existing = Helpers::DataModels.apollo_entry
@@ -611,13 +618,6 @@ module Legion
                 confidence: Helpers::Confidence.apply_corroboration_boost(confidence: entry.confidence, weight: weight),
                 updated_at: Time.now
               )
-              Helpers::DataModels.apollo_relation.create(
-                from_entry_id: entry.id,
-                to_entry_id:   entry.id,
-                relation_type: 'similar_to',
-                source_agent:  source_agent,
-                weight:        sim
-              )
               log.info("Apollo Knowledge.find_corroboration matched entry_id=#{entry.id} source_agent=#{source_agent} similarity=#{sim}")
               return [true, entry.id]
             end

data/lib/legion/extensions/apollo/runners/maintenance.rb

@@ -43,7 +43,8 @@ module Legion
             )
 
             min_age_filter = Sequel.lit(
-              "COALESCE(updated_at, created_at) < NOW() - INTERVAL '? hours'", min_age_hours
+              "COALESCE(updated_at, created_at) < NOW() - (? * INTERVAL '1 hour')",
+              min_age_hours
             )
 
             decayed = conn[:apollo_entries]
@@ -71,8 +72,8 @@ module Legion
               return { success: false, error: 'apollo_data_not_available' }
             end
 
-            candidates = Helpers::DataModels.apollo_entry.where(status: 'candidate').exclude(embedding: nil).all
-            confirmed = Helpers::DataModels.apollo_entry.where(status: 'confirmed').exclude(embedding: nil).all
+            candidates = Helpers::DataModels.apollo_entry.where(status: 'candidate').exclude(embedding: nil).limit(100).all
+            confirmed = Helpers::DataModels.apollo_entry.where(status: 'confirmed').exclude(embedding: nil).limit(500).all
             log.debug("Apollo Maintenance.check_corroboration candidates=#{candidates.size} confirmed=#{confirmed.size}")
 
             promoted = 0

data/lib/legion/extensions/apollo/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Apollo
-      VERSION = '0.4.23'
+      VERSION = '0.4.24'
     end
   end
 end

data/spec/legion/extensions/apollo/runners/knowledge_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
   before do
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
     stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
@@ -159,7 +159,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
 
         # Corroboration lookup chain
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: empty_dataset)))
@@ -328,7 +328,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', Class.new)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(Legion::Data::Model::ApolloEntry).to receive(:where)
           .and_raise(Sequel::Error, 'connection lost')
       end
@@ -406,7 +406,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -441,7 +441,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
       end
@@ -555,7 +555,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Knowledge do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))

data/spec/legion/extensions/apollo/runners/maintenance_spec.rb

@@ -107,9 +107,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [])))
+                                                  .and_return(double(exclude: double(limit: double(all: []))))
       end
 
       it 'returns zero promoted and scanned' do
@@ -136,9 +136,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
         allow(mock_relation_class).to receive(:create)
       end
 
@@ -174,9 +174,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloRelation', mock_relation_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote even with different providers' do
@@ -198,9 +198,9 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Maintenance do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(mock_entry_class).to receive(:where).with(status: 'candidate')
-                                                  .and_return(double(exclude: double(all: [candidate])))
+                                                  .and_return(double(exclude: double(limit: double(all: [candidate]))))
         allow(mock_entry_class).to receive(:where).with(status: 'confirmed')
-                                                  .and_return(double(exclude: double(all: [confirmed_entry])))
+                                                  .and_return(double(exclude: double(limit: double(all: [confirmed_entry]))))
       end
 
       it 'does not promote' do

data/spec/legion/extensions/apollo/runners/request_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
 
     embeddings_mod = Module.new do
       def self.generate(*, **)
-        { vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
+        { vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 }
       end
     end
     stub_const('Legion::LLM::Call::Embeddings', embeddings_mod)
@@ -40,7 +40,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: sample_entries))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -104,7 +104,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
       before do
         stub_const('Legion::Data::Model::ApolloEntry', mock_entry_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:db).and_return(mock_db)
         allow(mock_db).to receive(:fetch).and_return(double(all: []))
         allow(mock_entry_class).to receive(:where).and_return(double(update: true))
@@ -143,7 +143,7 @@ RSpec.describe Legion::Extensions::Apollo::Runners::Request do
         stub_const('Legion::Data::Model::ApolloExpertise', mock_expertise_class)
         stub_const('Legion::Data::Model::ApolloAccessLog', mock_access_log_class)
         allow(Legion::LLM::Call::Embeddings).to receive(:generate)
-          .and_return({ vector: Array.new(1024, 0.0), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
+          .and_return({ vector: Array.new(1024, 0.1), model: 'test', provider: :ollama, dimensions: 1024, tokens: 0 })
         allow(mock_entry_class).to receive(:where).and_return(double(exclude: double(limit: double(each: nil), first: nil)))
         allow(mock_entry_class).to receive(:exclude)
           .and_return(double(exclude: double(limit: double(all: []))))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-apollo
 version: !ruby/object:Gem::Version
-  version: 0.4.23
+  version: 0.4.24
 platform: ruby
 authors:
 - Esity