documentrix 0.0.4 → 0.1.0

data/lib/documentrix/documents/cache/sqlite_cache.rb

@@ -3,6 +3,14 @@ require 'sqlite3'
 require 'sqlite_vec'
 require 'digest/md5'
 
+# SQLiteCache is a cache implementation that uses SQLite database for storing
+# document embeddings and related metadata.
+#
+# This class provides a persistent cache storage solution for document
+# embeddings, leveraging SQLite's capabilities to store both the embedding
+# vectors and associated text data, tags, and source information.
+# It supports efficient vector similarity searches using the sqlite_vec
+# extension for fast nearest neighbor queries.
 class Documentrix::Documents::Cache::SQLiteCache
   include Documentrix::Documents::Cache::Common
 
@@ -135,20 +143,45 @@ class Documentrix::Documents::Cache::SQLiteCache
       keys = '(%s)' % records.transpose.first.map { "'%s'" % quote(_1) }.join(?,)
       execute(%{DELETE FROM records WHERE key IN #{keys}})
     else
-      clear
+      clear_all_with_prefix
     end
     self
   end
 
-  # The clear method deletes all records for prefix `prefix` from the cache by
-  # executing a SQL query.
+  # The clear_all_with_prefix method deletes all records for prefix `prefix`
+  # from the cache by executing a SQL query.
   #
   # @return [ Documentrix::Documents::RedisBackedMemoryCache ] self
-  def clear
+  def clear_all_with_prefix
     execute(%{DELETE FROM records WHERE key LIKE ?}, [ "#@prefix%" ])
     self
   end
 
+  # Move a key prefix in the cache.
+  #
+  # This operation updates every record whose key starts with +old_prefix+,
+  # rewriting the prefix to +new_prefix+. It uses SQLite’s built‑in `replace()`
+  # string function, which means the change is atomic and performed entirely
+  # inside the database engine—no Ruby‑side iteration or temporary data
+  # structures are needed.
+  #
+  # @param old_prefix [String] the current prefix to replace (must match the
+  #        beginning of the keys you want to move).
+  # @param new_prefix [String] the new prefix that should take its place.
+  #
+  # @return [Documentrix::Documents::Cache::SQLiteCache] the cache instance,
+  #         enabling method chaining.
+  def move_prefix(old_prefix, new_prefix)
+    execute(
+      %{
+        UPDATE records
+          SET key = replace(key, '#{quote(old_prefix)}', '#{quote(new_prefix)}')
+          WHERE key LIKE ?
+      },
+      old_prefix + '%'
+    )
+  end
+
   # The each method iterates over records matching the given prefix and yields
   # them to the block.
   #
@@ -160,6 +193,8 @@ class Documentrix::Documents::Cache::SQLiteCache
   #     puts "#{key}: #{value}"
   #   end
   def each(prefix: "#@prefix%", &block)
+    block or return enum_for(__method__, prefix:)
+
     execute(%{
       SELECT records.key, records.text, records.norm, records.source,
         records.tags, embeddings.embedding
@@ -174,7 +209,6 @@ class Documentrix::Documents::Cache::SQLiteCache
     end
     self
   end
-  include Enumerable
 
   # The full_each method iterates over all keys and values in the cache,
   # regardless of their prefix.
@@ -183,6 +217,8 @@ class Documentrix::Documents::Cache::SQLiteCache
   #
   # @return [ Documentrix::Documents::Cache::SQLiteCache ] self
   def full_each(&block)
+    block or return enum_for(__method__)
+
     each(prefix: ?%, &block)
   end
 

data/lib/documentrix/documents.rb

@@ -4,22 +4,63 @@ require 'kramdown/ansi'
 
 class Documentrix::Documents
 end
+# Module for managing document caches in Documentrix
+#
+# This module provides the foundational cache interface and implementations for
+# storing and retrieving document embeddings and related metadata. It supports
+# multiple cache backends including memory, Redis, and SQLite, enabling
+# flexible storage options for vector databases.
+#
+# The cache system handles operations such as setting, retrieving, and deleting
+# cached entries, as well as querying and filtering cached data based on tags
+# and similarity searches. It includes common functionality for managing cache
+# prefixes, enumerating collections, extracting tags, and clearing cache entries.
 module Documentrix::Documents::Cache
 end
 require 'documentrix/documents/cache/records'
 require 'documentrix/documents/cache/memory_cache'
 require 'documentrix/documents/cache/redis_cache'
-require 'documentrix/documents/cache/redis_backed_memory_cache'
 require 'documentrix/documents/cache/sqlite_cache'
+
+# Module for text splitting operations in Documentrix
+#
+# This module provides functionality for splitting text into smaller chunks
+# using various strategies. It includes both simple character-based splitting
+# and more sophisticated semantic splitting that considers the meaning
+# and structure of the text when determining split points.
+#
+# The splitters are designed to work with the Documentrix::Documents class
+# to prepare text data for embedding and storage in vector databases.
 module Documentrix::Documents::Splitters
 end
 require 'documentrix/documents/splitters/character'
 require 'documentrix/documents/splitters/semantic'
 
+# Documentrix::Documents is a class that provides functionality for building
+# and querying vector databases for natural language processing and large
+# language model applications.
+#
+# It allows users to store and retrieve dense vector embeddings for text
+# strings, supporting various cache backends including memory, Redis, and
+# SQLite for efficient data management.
+#
+# The class handles the complete workflow of adding documents, computing their
+# embeddings using a specified model, storing them in a cache, and performing
+# similarity searches to find relevant documents based on query text.
+#
+# @example
+#   documents = Documentrix::Documents.new(
+#     ollama: ollama_client,
+#     model: 'mxbai-embed-large',
+#     collection: 'my-collection'
+#   )
+#   documents.add(['text1', 'text2'])
+#   results = documents.find('search query')
 class Documentrix::Documents
   include Kramdown::ANSI::Width
   include Documentrix::Documents::Cache
 
+  # Shortcut for Documentrix::Documents::Cache::Records::Record
   Record = Class.new Documentrix::Documents::Cache::Records::Record
 
   # The initialize method sets up the Documentrix::Documents instance by
@@ -229,6 +270,21 @@ class Documentrix::Documents
     ([ default_collection ] + @cache.collections('%s-' % class_prefix)).uniq
   end
 
+  # Rename the current collection, moving all keys from the old prefix to a new
+  # one. After the rename the instance’s `collection` attribute points to
+  # `new_collection`, and the cache keys are updated accordingly.
+  #
+  # @param new_collection [Symbol] The name of the collection to rename to.
+  # @return [Documentrix::Documents] Returns `self` to allow method chaining.
+  def rename_collection(new_collection)
+    new_collection = new_collection.to_sym
+    collections.member?(new_collection) and
+      raise ArgumentError, "new collection #{new_collection} already exists!"
+    new_prefix = '%s-%s-' % [ class_prefix, new_collection ]
+    @cache.move_prefix(prefix, new_prefix)
+    self.collection = new_collection
+  end
+
   # The tags method returns an array of unique tags from the cache.
   #
   # @return [Documentrix::Utils::Tags] A set of unique tags
@@ -269,11 +325,6 @@ class Documentrix::Documents
     end
   ensure
     cache ||= MemoryCache.new(prefix:,)
-    cache.respond_to?(:find_records) or cache.extend(Records::FindRecords)
-    cache.extend(Records::Tags)
-    if cache.respond_to?(:redis)
-      cache.extend(Records::RedisFullEach)
-    end
     return cache
   end
 
@@ -305,6 +356,11 @@ class Documentrix::Documents
     @ollama.embed(model:, input:, options:).embeddings
   end
 
+  # Returns the base prefix string used for cache keys.
+  # This string is prefixed to the collection name to form the full key
+  # namespace.
+  #
+  # @return [String] the prefix identifier for Documentrix documents.
   def class_prefix
     'Documents'
   end

data/lib/documentrix/utils/colorize_texts.rb

@@ -1,6 +1,17 @@
 require 'term/ansicolor'
 require 'kramdown/ansi'
 
+# A utility class for colorizing and formatting text output with ANSI color
+# codes and size information.
+#
+# The ColorizeTexts class takes an array of text strings and formats them with
+# different ANSI colors for visual distinction. It also appends the size of each
+# text block to the output, making it useful for debugging or displaying
+# information about text chunks in a visually appealing way.
+#
+# @example
+#   colorizer = Documentrix::Utils::ColorizeTexts.new('foo', 'bar')
+#   puts colorizer.to_s
 class Documentrix::Utils::ColorizeTexts
   include Math
   include Term::ANSIColor

data/lib/documentrix/utils/math.rb

@@ -1,3 +1,8 @@
+# A module that provides mathematical utilities for vector operations.
+#
+# This module includes methods for calculating vector norms, computing cosine
+# similarity between vectors, and converting arrays into Numo::NArray objects
+# for numerical computations.
 module Documentrix::Utils::Math
   # Returns the cosine similarity between two vectors `a` and `b`, 1.0 is
   # exactly the same, 0.0 means decorrelated.

data/lib/documentrix/utils/tags.rb

@@ -1,10 +1,31 @@
 require 'term/ansicolor'
 
+# A collection of tags with optional source tracking and formatting
+# capabilities.
+#
+# The Tags class manages a collection of unique tags, ensuring no duplicates while maintaining sorted order.
+# Each tag can optionally be associated with a source URL for tracking origins.
+# The class provides methods for adding, iterating, and formatting tags for display.
+#
+# @example
+#   tags = Documentrix::Utils::Tags.new(%w[ foo bar ])
+#   tags.add('baz')
+#   tags.to_s # => "bar baz foo"
 class Documentrix::Utils::Tags
   # Matches tags with optional leading # characters and at least one non-space
   # character by default:
   DEFAULT_VALID_TAG = /\A#*(\S+)/
 
+  # A tag string that includes optional source tracking functionality.
+  #
+  # The Tag class extends String and adds the ability to track the source URL
+  # where the tag originated. It provides methods for formatting the tag string
+  # for output, including the option to include a hyperlink to the source.
+  #
+  # @example
+  #   tag = Documentrix::Utils::Tags::Tag.new('example')
+  #   tag.source = 'https://example.com'
+  #   tag.to_s # => "\e]8;;https://example.com\e\\\\#example\e]8;;\e\\\\"
   class Tag < String
     include Term::ANSIColor
 
@@ -61,6 +82,19 @@ class Documentrix::Utils::Tags
 
   attr_reader :valid_tag # the regular expression capturing a valid tag's content
 
+  # The add method adds a tag to the collection, ensuring uniqueness and
+  # maintaining sorted order.
+  #
+  # If the tag is not already a Tag instance, it creates one using the provided
+  # source. The method uses binary search to find the correct insertion point
+  # to maintain the sorted order.
+  # Duplicate tags are not added, and the method returns self to allow for
+  # method chaining.
+  #
+  # @param tag [ String, Documentrix::Utils::Tags::Tag ] the tag to be added
+  # @param source [ String, nil ] the source URL associated with the tag (optional)
+  #
+  # @return [ Documentrix::Utils::Tags ] self
   def add(tag, source: nil)
     unless tag.is_a?(Tag)
       tag = Tag.new(tag, valid_tag:, source:)

data/lib/documentrix/utils.rb

@@ -1,3 +1,13 @@
+# A module that provides utility classes and methods for Documentrix
+#
+# The Utils module contains helper classes and modules that support various
+# functionalities within Documentrix, including mathematical operations,
+# text processing, and tag management.
+#
+# @example
+#   Documentrix::Utils::Math
+#   Documentrix::Utils::Tags
+#   Documentrix::Utils::ColorizeTexts
 module Documentrix::Utils
 end
 require 'documentrix/utils/colorize_texts'

data/lib/documentrix/version.rb

@@ -1,6 +1,6 @@
 module Documentrix
   # Documentrix version
-  VERSION         = '0.0.4'
+  VERSION         = '0.1.0'
   VERSION_ARRAY   = VERSION.split('.').map(&:to_i) # :nodoc:
   VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
   VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:

data/lib/documentrix.rb

@@ -1,8 +1,14 @@
+# Documentrix is a Ruby library designed to facilitate the creation and
+# querying of vector databases for natural language processing and large
+# language model applications. It provides functionality for storing and
+# retrieving dense vector embeddings of text strings, supporting various cache
+# backends including memory, Redis, and SQLite for efficient data management.
 module Documentrix
   module Utils
   end
 end
 
+require 'set'
 require 'json'
 require 'infobar'
 require 'tins'

data/spec/documentrix/documents/cache/interface_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+describe 'Documentrix::Documents::Cache Interface' do
+  describe 'MemoryCache Interface' do
+    let(:cache) { Documentrix::Documents::MemoryCache.new(prefix: 'test-') }
+
+    it 'has proper method resolution' do
+      # Basic cache operations
+      expect(cache).to respond_to(:[])
+      expect(cache.method(:[]).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:[]=)
+      expect(cache.method(:[]=).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:key?)
+      expect(cache.method(:key?).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:delete)
+      expect(cache.method(:delete).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:size)
+      expect(cache.method(:size).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:clear_all_with_prefix)
+      expect(cache.method(:clear_all_with_prefix).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:each)
+      expect(cache.method(:each).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:full_each)
+      expect(cache.method(:full_each).owner).to eq Documentrix::Documents::MemoryCache
+
+      expect(cache).to respond_to(:move_prefix)
+      expect(cache.method(:move_prefix).owner).to eq Documentrix::Documents::MemoryCache
+
+      # Common methods from Cache::Common
+      expect(cache).to respond_to(:collections)
+      expect(cache.method(:collections).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:pre)
+      expect(cache.method(:pre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:unpre)
+      expect(cache.method(:unpre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:find_records)
+      expect(cache.method(:find_records).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:tags)
+      expect(cache.method(:tags).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:clear_for_tags)
+      expect(cache.method(:clear_for_tags).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:clear)
+      expect(cache.method(:clear).owner).to eq Documentrix::Documents::Cache::Common
+    end
+  end
+
+  describe 'RedisCache Interface' do
+    let(:cache) { Documentrix::Documents::RedisCache.new(prefix: 'test-', url: 'redis://localhost:6379') }
+
+    it 'has proper method resolution' do
+      # Basic cache operations
+      expect(cache).to respond_to(:[])
+      expect(cache.method(:[]).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:[]=)
+      expect(cache.method(:[]=).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:key?)
+      expect(cache.method(:key?).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:delete)
+      expect(cache.method(:delete).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:size)
+      expect(cache.method(:size).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:clear_all_with_prefix)
+      expect(cache.method(:clear_all_with_prefix).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:each)
+      expect(cache.method(:each).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:full_each)
+      expect(cache.method(:full_each).owner).to eq Documentrix::Documents::RedisCache
+
+      expect(cache).to respond_to(:move_prefix)
+      expect(cache.method(:move_prefix).owner).to eq Documentrix::Documents::RedisCache
+
+      # Common methods from Cache::Common
+      expect(cache).to respond_to(:collections)
+      expect(cache.method(:collections).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:pre)
+      expect(cache.method(:pre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:unpre)
+      expect(cache.method(:unpre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:find_records)
+      expect(cache.method(:find_records).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:tags)
+      expect(cache.method(:tags).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:clear_for_tags)
+      expect(cache.method(:clear_for_tags).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:clear)
+      expect(cache.method(:clear).owner).to eq Documentrix::Documents::Cache::Common
+
+      # Redis-specific methods
+      expect(cache).to respond_to(:redis)
+      expect(cache.method(:redis).owner).to eq Documentrix::Documents::RedisCache
+    end
+  end
+
+  describe 'SQLiteCache Interface' do
+    let(:cache) { Documentrix::Documents::Cache::SQLiteCache.new(prefix: 'test-') }
+
+    it 'has proper method resolution' do
+      # Basic cache operations
+      expect(cache).to respond_to(:[])
+      expect(cache.method(:[]).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:[]=)
+      expect(cache.method(:[]=).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:key?)
+      expect(cache.method(:key?).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:delete)
+      expect(cache.method(:delete).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:size)
+      expect(cache.method(:size).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:clear_all_with_prefix)
+      expect(cache.method(:clear_all_with_prefix).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:each)
+      expect(cache.method(:each).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:full_each)
+      expect(cache.method(:full_each).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:move_prefix)
+      expect(cache.method(:move_prefix).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      # Common methods from Cache::Common
+      expect(cache).to respond_to(:collections)
+      expect(cache.method(:collections).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:pre)
+      expect(cache.method(:pre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:unpre)
+      expect(cache.method(:unpre).owner).to eq Documentrix::Documents::Cache::Common
+
+      expect(cache).to respond_to(:find_records)
+      expect(cache.method(:find_records).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:tags)
+      expect(cache.method(:tags).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:clear_for_tags)
+      expect(cache.method(:clear_for_tags).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:clear)
+      expect(cache.method(:clear).owner).to eq Documentrix::Documents::Cache::Common
+
+      # SQLite-specific methods
+      expect(cache).to respond_to(:filename)
+      expect(cache.method(:filename).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:embedding_length)
+      expect(cache.method(:embedding_length).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:convert_to_vector)
+      expect(cache.method(:convert_to_vector).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+
+      expect(cache).to respond_to(:find_records_for_tags)
+      expect(cache.method(:find_records_for_tags).owner).to eq Documentrix::Documents::Cache::SQLiteCache
+    end
+  end
+end

data/spec/documentrix/documents/cache/memory_cache_spec.rb

@@ -51,6 +51,21 @@ describe Documentrix::Documents::MemoryCache do
     expect(s).to eq 2
   end
 
+  it 'can move prefixes' do
+    key, value = 'foo', { test1: true }
+    cache[key] = value
+    cache.prefix = 'test2-'
+    key, value = 'bar', { test2: true }
+    cache[key] = value
+    expect(cache.full_each.to_a).to eq(
+      [["test-foo", {test1: true}], ["test2-bar", {test2: true}]]
+    )
+    cache.move_prefix('test-', 'test3-')
+    expect(cache.full_each.to_a).to eq(
+      [["test2-bar", {test2: true}], ["test3-foo", {test1: true}]]
+    )
+  end
+
   it 'can delete' do
     key, value = 'foo', { test: true }
     expect(cache.delete(key)).to be_falsy
@@ -70,6 +85,20 @@ describe Documentrix::Documents::MemoryCache do
       expect(k).to eq prefix + key
       expect(v).to eq value
     end
+    expect(cache.each.to_a).to eq [ ["test-foo", {test: true}] ]
+    expect(cache.to_a).to eq [ ["test-foo", {test: true}] ]
+  end
+
+  it "can iterate over the full cache's keys, values" do
+    key, value = 'foo', { test: true }
+    cache[key] = value
+    cache.prefix = 'test2-'
+    key, value = 'bar', { test2: true }
+    cache[key] = value
+    expect(cache.full_each.to_a).to eq [
+      ["test-foo", {test: true}],
+      ["test2-bar", {test2: true}],
+    ]
   end
 
   it 'returns size' do

data/spec/documentrix/documents/cache/redis_cache_spec.rb

@@ -50,19 +50,10 @@ describe Documentrix::Documents::RedisCache do
 
     it 'can set a value for a key' do
       key, value = 'foo', { test: true }
-      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: nil)
+      expect(redis).to receive(:set).with(prefix + key, JSON(value))
       cache[key] = value
     end
 
-    it 'can set a value for a key with ttl' do
-      cache = described_class.new prefix:, url: 'something', ex: 3_600
-      key, value = 'foo', { test: true }
-      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: 3_600)
-      cache[key] = value
-      expect(redis).to receive(:ttl).with(prefix + key).and_return 3_600
-      expect(cache.ttl(key)).to eq 3_600
-    end
-
     it 'can determine if key exists' do
       key = 'foo'
       expect(redis).to receive(:exists?).with(prefix + key).and_return(false, true)
@@ -70,6 +61,17 @@ describe Documentrix::Documents::RedisCache do
       expect(cache.key?('foo')).to eq true
     end
 
+    it 'can move prefixes' do
+      expect(redis).to receive(:get).with(prefix + 'foo').and_return(JSON(foo: true))
+      expect(redis).to receive(:get).with('test2-bar').and_return(JSON(foo: true))
+      expect(redis).to receive(:set).with('test3-foo', '{"foo":true}')
+      expect(redis).to receive(:del).with('test-foo')
+      expect(redis).to receive(:scan_each).with(match: ?*).
+        and_yield("#{prefix}foo").
+        and_yield("test2-bar")
+      cache.move_prefix('test-', 'test3-')
+    end
+
     it 'can delete' do
       key = 'foo'
       expect(redis).to receive(:del).with(prefix + key).and_return 1
@@ -80,7 +82,7 @@ describe Documentrix::Documents::RedisCache do
 
     it 'can iterate over keys, values' do
       key, value = 'foo', { 'test' => true }
-      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: nil)
+      expect(redis).to receive(:set).with(prefix + key, JSON(value))
       cache[key] = value
       expect(redis).to receive(:scan_each).with(match: "#{prefix}*").
         and_yield("#{prefix}foo")

data/spec/documentrix/documents/cache/sqlite_cache_spec.rb

@@ -75,6 +75,27 @@ describe Documentrix::Documents::SQLiteCache do
     expect(s).to eq 2
   end
 
+  it 'can move prefixes' do
+    key, value = 'foo', test_value
+    cache[key] = value
+    cache.prefix = 'test2-'
+    key, value = 'bar', test_value
+    cache[key] = value
+    expect(cache.full_each.to_a).to eq(
+      [
+        ["test-foo", Documentrix::Documents::Record[test_value]],
+        ["test2-bar", Documentrix::Documents::Record[test_value]],
+      ]
+    )
+    cache.move_prefix('test-', 'test3-')
+    expect(cache.full_each.to_a).to eq(
+      [
+        ["test3-foo", Documentrix::Documents::Record[test_value]],
+        ["test2-bar", Documentrix::Documents::Record[test_value]],
+      ]
+    )
+  end
+
   it 'can delete' do
     key, value = 'foo', test_value
     expect(cache.delete(key)).to be_falsy
@@ -136,6 +157,19 @@ describe Documentrix::Documents::SQLiteCache do
 
   it 'can iterate over keys under a prefix' do
     cache['foo'] = test_value
+    expect(cache.each.to_a).to eq [ [ 'test-foo', Documentrix::Documents::Record[test_value] ] ]
     expect(cache.to_a).to eq [ [ 'test-foo', Documentrix::Documents::Record[test_value] ] ]
   end
+
+  it "can iterate over the full cache's keys, values" do
+    key, value = 'foo', test_value
+    cache[key] = value
+    cache.prefix = 'test2-'
+    key, value = 'bar', test_value
+    cache[key] = value
+    expect(cache.full_each.to_a).to eq [
+      ["test-foo", Documentrix::Documents::Record[test_value] ],
+      ["test2-bar", Documentrix::Documents::Record[test_value] ],
+    ]
+  end
 end

data/spec/documents_spec.rb

@@ -162,6 +162,28 @@ describe Documentrix::Documents do
       expect(documents.collections).to eq [ :default ]
     end
 
+    it 'can rename collections' do
+      documents.collection = :foo
+      documents << 'foo'
+      expect(documents.collections).to eq %i[ default foo ]
+      documents.rename_collection(:bar)
+      expect(documents.collection).to eq :bar
+      expect(documents.collections).to eq %i[ default bar ]
+      expect(documents.exist?('foo')).to be true
+    end
+
+    it 'cannot rename collections into already existing ones' do
+      documents.collection = :foo
+      documents << 'foo'
+      expect(documents.collections).to eq %i[ default foo ]
+      documents.collection = :bar
+      documents << 'foo'
+      expect(documents.collections).to eq %i[ default foo bar ]
+      expect {
+        documents.rename_collection(:foo)
+      }.to raise_error(ArgumentError, 'new collection foo already exists!')
+    end
+
     it 'can change collection' do
       expect(documents.instance_eval { @cache }).to receive(:prefix=).
         with(/#@collection/).and_call_original