activesupport_cache_database 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '029071110552b3cd5a259762e7b3a38b57c67cb30e19daca6d33b90c79963b38'
+  data.tar.gz: 96686b4c427b8eac4cb7a5c0474e8b2d5b867bf06654379594628620fbf7e27e
+SHA512:
+  metadata.gz: 02a282d23cf3b0c48022ffa23585e876d9c8a4fd64da959f9eedc1cbb86248e2463755dfb0de9f7b8f85ffa8b50461354a97809d37246a69b66d9bbe2345b288
+  data.tar.gz: 93b25ebd6d14d93cc3cc794fb785a94d61c25b10c56e8df08b33e13543b536ea6c93c9bd05b617eed793a7c6fcc5568195bdee85093ba30158e2760043ae764b

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

data/.gitignore

@@ -0,0 +1,3 @@
+.rubocop-*
+pkg/
+spec/*.sqlite*

data/.rubocop.yml

@@ -0,0 +1,7 @@
+inherit_from:
+  - https://gitlab.com/bsm/misc/raw/master/rubocop/default.yml
+
+AllCops:
+  TargetRubyVersion: "2.5"
+Security/MarshalLoad:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+rvm:
+  - 2.6
+  - 2.5
+before_install:
+  - gem install bundler
+  - mysql -e 'CREATE DATABASE ci_test;'
+  - psql -c 'CREATE DATABASE ci_test;' -U postgres
+services:
+  - postgresql
+  - mysql
+env:
+  - DATABASE_URL=sqlite3:///tmp/ci_test.sqlite3
+  - DATABASE_URL=mysql2://travis@127.0.0.1/ci_test
+  - DATABASE_URL=postgresql://127.0.0.1/ci_test

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    activesupport_cache_database (0.1.0)
+      activerecord (>= 5.0)
+      activesupport (>= 5.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.0.0)
+      activesupport (= 6.0.0)
+    activerecord (6.0.0)
+      activemodel (= 6.0.0)
+      activesupport (= 6.0.0)
+    activesupport (6.0.0)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.1, >= 2.1.8)
+    ast (2.4.0)
+    concurrent-ruby (1.1.5)
+    diff-lcs (1.3)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
+    jaro_winkler (1.5.3)
+    minitest (5.11.3)
+    mysql2 (0.5.2)
+    parallel (1.17.0)
+    parser (2.6.4.0)
+      ast (~> 2.4.0)
+    pg (1.1.4)
+    rainbow (3.0.0)
+    rake (12.3.3)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.2)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.2)
+    rubocop (0.74.0)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.6)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 1.7)
+    ruby-progressbar (1.10.1)
+    sqlite3 (1.4.1)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.6.0)
+    zeitwerk (2.1.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport_cache_database!
+  bundler
+  mysql2
+  pg
+  rake
+  rspec
+  rubocop
+  sqlite3
+
+BUNDLED WITH
+   2.0.2

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2019 Black Square Media Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,44 @@
+# ActiveSupport::Cache::DatabaseStore
+
+[![Build Status](https://travis-ci.org/bsm/activesupport-cache-database.png?branch=master)](https://travis-ci.org/bsm/activesupport-cache-database)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+ActiveSupport::Cache::Store implementation backed by a database via ActiveRecord.
+
+Tested with:
+
+- PostgreSQL
+- SQlite3
+- MySQL/MariaDB
+
+## Usage
+
+Include the data migration:
+
+```ruby
+# db/migrate/20190908102030_create_activesupport_cache_entries.rb
+require 'active_support/cache/database_store/migration'
+
+class CreateActivesupportCacheEntries < ActiveRecord::Migration[5.2]
+  def up
+    ActiveSupport::Cache::DatabaseStore::Migration.migrate(:up)
+  end
+
+  def down
+    ActiveSupport::Cache::DatabaseStore::Migration.migrate(:down)
+  end
+end
+```
+
+Open and use the new cache instance:
+
+```ruby
+cache = ActiveSupport::Cache::DatabaseStore.new namespace: 'my-scope'
+value = cache.fetch('some-key') { 'default' }
+```
+
+To use as a Rails cache store (not recommended!), simply use a new instance.
+
+```ruby
+config.cache_store = ActiveSupport::Cache::DatabaseStore.new
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop)
+
+task default: %i[spec rubocop]

data/activesupport_cache_database.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |s|
+  s.name          = 'activesupport_cache_database'
+  s.version       = '0.1.0'
+  s.authors       = ['Black Square Media Ltd']
+  s.email         = ['info@blacksquaremedia.com']
+  s.summary       = %(ActiveSupport::Cache::Store implementation backed by ActiveRecord.)
+  s.description   = %(Use your DB as a cache store)
+  s.homepage      = 'https://github.com/bsm/record-cache-store'
+  s.license       = 'Apache-2.0'
+
+  s.files         = `git ls-files -z`.split("\x0").reject {|f| f.match(%r{^spec/}) }
+  s.test_files    = `git ls-files -z -- spec/*`.split("\x0")
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 2.5'
+
+  s.add_dependency 'activerecord', '>= 5.0'
+  s.add_dependency 'activesupport', '>= 5.0'
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'mysql2'
+  s.add_development_dependency 'pg'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'sqlite3'
+end

data/lib/active_support/cache/database_store.rb

@@ -0,0 +1,111 @@
+require 'active_support/cache'
+require 'active_record'
+
+module ActiveSupport
+  module Cache
+    # A cache store implementation which stores everything in the database, using ActiveRecord as the backend.
+    #
+    # DatabaseStore implements the Strategy::LocalCache strategy which implements
+    # an in-memory cache inside of a block.
+    class DatabaseStore < Store
+      prepend Strategy::LocalCache
+
+      autoload :Model, 'active_support/cache/database_store/model'
+      autoload :Migration, 'active_support/cache/database_store/migration'
+
+      # param [Hash] options options
+      # option options [Class] :model model class. Default: ActiveSupport::Cache::DatabaseStore::Model
+      def initialize(options=nil)
+        @model = (options || {}).delete(:model) || Model
+        super(options)
+      end
+
+      # Preemptively iterates through all stored keys and removes the ones which have expired.
+      def cleanup(options=nil)
+        options = merged_options(options)
+        scope = @model.expired
+        if (namespace = options[:namespace])
+          scope = scope.namespaced(namespace)
+        end
+        scope.delete_all
+      end
+
+      # Clears the entire cache. Be careful with this method.
+      def clear(options=nil)
+        options = merged_options(options)
+        if (namespace = options[:namespace])
+          @model.namespaced(namespace).delete_all
+        else
+          @model.truncate!
+        end
+        true
+      end
+
+      # Calculates the number of entries in the cache.
+      def count(options=nil)
+        options = merged_options(options)
+        scope = @model.all
+        if (namespace = options[:namespace])
+          scope = scope.namespaced(namespace)
+        end
+        scope = scope.fresh unless options[:all]
+        scope.count
+      end
+
+      private
+
+      def normalize_key(name, options=nil)
+        key = super.to_s
+        raise ArgumentError, 'Namespaced key exceeds the length limit' if key && key.bytesize > 255
+
+        key
+      end
+
+      def read_entry(key, _options=nil)
+        from_record @model.where(key: key).first
+      end
+
+      def write_entry(key, entry, _options=nil)
+        record = @model.where(key: key).first_or_initialize
+        expires_at = Time.zone.at(entry.expires_at) if entry.expires_at
+        record.update! value: Marshal.dump(entry.value), version: entry.version.presence, expires_at: expires_at
+      end
+
+      def delete_entry(key, _options=nil)
+        @model.where(key: key).destroy_all
+      end
+
+      def read_multi_entries(names, options)
+        keyed = {}
+        names.each do |name|
+          version = normalize_version(name, options)
+          keyed[normalize_key(name, options)] = { name: name, version: version }
+        end
+
+        results = {}
+        @model.where(key: keyed.keys).find_each do |rec|
+          name, version = keyed[rec.key].values_at(:name, :version)
+          entry = from_record(rec)
+          next if entry.nil?
+
+          if entry.expired?
+            delete_entry(rec.key, options)
+          elsif entry.mismatched?(version)
+            # Skip mismatched versions
+          else
+            results[name] = entry.value
+          end
+        end
+        results
+      end
+
+      def from_record(record)
+        return unless record
+
+        entry = Entry.new Marshal.load(record.value), version: record.version
+        entry.expires_at = record.expires_at
+        entry
+      end
+    end
+  end
+end

data/lib/active_support/cache/database_store/migration.rb

@@ -0,0 +1,18 @@
+require 'active_support/cache/database_store'
+
+module ActiveSupport
+  module Cache
+    class DatabaseStore < Store
+      class Migration < ::ActiveRecord::Migration[5.2]
+        def change
+          create_table :activesupport_cache_entries, primary_key: 'key', id: :binary, limit: 255 do |t|
+            t.binary :value, null: false
+            t.string :version, index: true
+            t.timestamp :created_at, null: false, index: true
+            t.timestamp :expires_at, index: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_support/cache/database_store/model.rb

@@ -0,0 +1,24 @@
+require 'active_support/cache/database_store'
+
+module ActiveSupport
+  module Cache
+    class DatabaseStore < Store
+      class Model < ActiveRecord::Base
+        self.table_name = 'activesupport_cache_entries'
+
+        def self.truncate!
+          connection.truncate(table_name)
+        end
+
+        scope :fresh, -> { where(arel_table[:expires_at].gt(Time.zone.now)) }
+        scope :expired, -> { where(arel_table[:expires_at].lteq(Time.zone.now)) }
+
+        def self.namespaced(namespace)
+          prefix = "#{namespace}:"
+          clause = ::Arel::Nodes::NamedFunction.new('SUBSTR', [arel_table[:key], 1, prefix.bytesize])
+          where clause.eq(prefix)
+        end
+      end
+    end
+  end
+end

data/lib/activesupport_cache_database.rb

@@ -0,0 +1 @@
+require 'active_support/cache/database_store'

data/spec/active_support/cache/database_store_spec.rb

@@ -0,0 +1,328 @@
+require 'spec_helper'
+
+RSpec.describe ActiveSupport::Cache::DatabaseStore do
+  subject do
+    described_class.new expires_in: 60
+  end
+
+  it 'should read and write strings' do
+    expect(subject.write('foo', 'bar')).to be_truthy
+    expect(subject.read('foo')).to eq('bar')
+  end
+
+  it 'should read and write hash' do
+    expect(subject.write('foo', a: 'b')).to be_truthy
+    expect(subject.read('foo')).to eq(a: 'b')
+  end
+
+  it 'should read and write integer' do
+    expect(subject.write('foo', 1)).to be_truthy
+    expect(subject.read('foo')).to eq(1)
+  end
+
+  it 'should read and write nil' do
+    expect(subject.write('foo', nil)).to be_truthy
+    expect(subject.read('foo')).to eq(nil)
+  end
+
+  it 'should read and write false' do
+    expect(subject.write('foo', false)).to be_truthy
+    expect(subject.read('foo')).to eq(false)
+  end
+
+  it 'should overwrite' do
+    expect(subject.write('foo', 'bar')).to be_truthy
+    expect(subject.write('foo', 'baz')).to be_truthy
+    expect(subject.read('foo')).to eq('baz')
+  end
+
+  it 'should support exist?' do
+    subject.write('foo', 'bar')
+    expect(subject.exist?('foo')).to be_truthy
+    expect(subject.exist?('bar')).to be_falsey
+  end
+
+  it 'should support nil exist?' do
+    subject.write('foo', nil)
+    expect(subject.exist?('foo')).to be_truthy
+  end
+
+  it 'should support delete' do
+    subject.write('foo', 'bar')
+    expect(subject.exist?('foo')).to be_truthy
+    expect(subject.delete('foo')).to be_truthy
+    expect(subject.exist?('foo')).to be_falsey
+  end
+
+  it 'should support expires_in' do
+    time = Time.local(2008, 4, 24)
+    allow(Time).to receive(:now).and_return(time)
+
+    subject.write('foo', 'bar')
+    expect(subject.read('foo')).to eq('bar')
+
+    allow(Time).to receive(:now).and_return(time + 30)
+    expect(subject.read('foo')).to eq('bar')
+
+    allow(Time).to receive(:now).and_return(time + 61)
+    expect(subject.read('foo')).to be_nil
+  end
+
+  it 'should support long keys' do
+    key = 'x' * 255
+    expect(subject.write(key, 'bar')).to be_truthy
+    expect(subject.read(key)).to eq('bar')
+    expect(subject.fetch(key)).to eq('bar')
+    expect(subject.read(key[0..-2])).to be_nil
+    expect(subject.read_multi(key)).to eq(key => 'bar')
+    expect(subject.delete(key)).to be_truthy
+
+    expect { subject.write("#{key}x", 'bar') }.to raise_error(ArgumentError, /exceeds the length limit/)
+    expect { subject.read("#{key}x") }.to raise_error(ArgumentError, /exceeds the length limit/)
+  end
+
+  describe '#cleanup' do
+    it 'should delete expired' do
+      time = Time.now
+      subject.write('foo', 'bar', expires_in: 10)
+      subject.write('fud', 'biz', expires_in: 20)
+
+      allow(Time).to receive(:now).and_return(time + 9)
+      expect(subject.cleanup).to eq(0)
+
+      allow(Time).to receive(:now).and_return(time + 19)
+      expect(subject.cleanup).to eq(1)
+      expect(subject.read('foo')).to be_nil
+      expect(subject.read('fud')).to eq('biz')
+    end
+
+    it 'should support namespace' do
+      time = Time.now
+      subject.write('foo', 'bar', expires_in: 10, namespace: 'x')
+      subject.write('foo', 'biz', expires_in: 10, namespace: 'y')
+
+      allow(Time).to receive(:now).and_return(time + 11)
+      expect(subject.count).to eq(0)
+      expect(subject.count(all: true)).to eq(2)
+
+      expect(subject.cleanup(namespace: 'x')).to eq(1)
+      expect(subject.count).to eq(0)
+      expect(subject.count(all: true)).to eq(1)
+    end
+  end
+
+  describe '#clear' do
+    it 'should remove all entries' do
+      subject.write('foo', 'bar')
+      subject.write('fud', 'biz')
+      expect(subject.clear).to be_truthy
+      expect(subject.read('foo')).to be_nil
+      expect(subject.read('fud')).to be_nil
+    end
+
+    it 'should support namespace' do
+      subject.write('foo', 'bar', namespace: 'x')
+      subject.write('foo', 'biz', namespace: 'y')
+      expect(subject.count).to eq(2)
+
+      expect(subject.clear(namespace: 'x')).to be_truthy
+      expect(subject.count).to eq(1)
+    end
+  end
+
+  describe '#fetch' do
+    it 'should support cache hit' do
+      subject.write('foo', 'bar')
+      expect(subject).not_to receive(:write)
+
+      expect(subject.fetch('foo') { 'baz' }).to eq('bar')
+    end
+
+    it 'should support cache miss' do
+      expect(subject).to receive(:write).with('foo', 'baz', instance_of(Hash))
+      expect(subject.fetch('foo') { 'baz' }).to eq('baz')
+    end
+
+    it 'should pass key to block on cache miss' do
+      cache_miss = false
+      expect(subject.fetch('foo') {|key| cache_miss = true; key.length }).to eq(3)
+      expect(cache_miss).to be_truthy
+
+      cache_miss = false
+      expect(subject.fetch('foo') {|key| cache_miss = true; key.length }).to eq(3)
+      expect(cache_miss).to be_falsey
+    end
+
+    it 'should support forced cache miss' do
+      subject.write('foo', 'bar')
+      expect(subject).not_to receive(:read)
+
+      expect(subject.fetch('foo', force: true) { 'baz' }).to eq('baz')
+    end
+
+    it 'should support nil values' do
+      subject.write('foo', nil)
+      expect(subject).not_to receive(:write)
+
+      expect(subject.fetch('foo') { 'baz' }).to be_nil
+    end
+
+    it 'should support skip_nil option' do
+      expect(subject).not_to receive(:write)
+      expect(subject.fetch('foo', skip_nil: true) { nil }).to be_nil
+      expect(subject.exist?('foo')).to be_falsey
+    end
+
+    it 'should support forced cache miss with block' do
+      subject.write('foo', 'bar')
+      expect(subject.fetch('foo', force: true) { 'baz' }).to eq('baz')
+    end
+
+    it 'should support forced cache miss without block' do
+      subject.write('foo', 'bar')
+      expect { subject.fetch('foo', force: true) }.to raise_error(ArgumentError)
+      expect(subject.read('foo')).to eq('bar')
+    end
+  end
+
+  describe '#read_multi' do
+    it 'should support read_multi' do
+      subject.write('foo', 'bar')
+      subject.write('fu', 'baz')
+      subject.write('fud', 'biz')
+      expect(subject.read_multi('foo', 'fu')).to eq('foo' => 'bar', 'fu' => 'baz')
+    end
+
+    it 'should support expires' do
+      time = Time.now
+      subject.write('foo', 'bar', expires_in: 10)
+      subject.write('fu', 'baz')
+      subject.write('fud', 'biz')
+
+      allow(Time).to receive(:now).and_return(time + 11)
+      expect(subject.read_multi('foo', 'fu')).to eq('fu' => 'baz')
+    end
+  end
+
+  describe '#fetch_multi' do
+    it 'should support fetch_multi' do
+      subject.write('foo', 'bar')
+      subject.write('fud', 'biz')
+      values = subject.fetch_multi('foo', 'fu', 'fud') {|v| v * 2 }
+
+      expect(values).to eq('foo' => 'bar', 'fu' => 'fufu', 'fud' => 'biz')
+      expect(subject.read('fu')).to eq('fufu')
+    end
+
+    it 'should support without expires_in' do
+      subject.write('foo', 'bar')
+      subject.write('fud', 'biz')
+      values = subject.fetch_multi('foo', 'fu', 'fud', expires_in: nil) {|v| v * 2 }
+
+      expect(values).to eq('foo' => 'bar', 'fu' => 'fufu', 'fud' => 'biz')
+      expect(subject.read('fu')).to eq('fufu')
+    end
+
+    it 'should support with objects' do
+      cache_struct = Struct.new(:cache_key, :title)
+      foo = cache_struct.new('foo', 'FOO!')
+      bar = cache_struct.new('bar')
+
+      subject.write('bar', 'BAM!')
+      values = subject.fetch_multi(foo, bar, &:title)
+      expect(values).to eq(foo => 'FOO!', bar => 'BAM!')
+    end
+
+    it 'should support ordered names' do
+      subject.write('bam', 'BAM')
+      values = subject.fetch_multi('foo', 'bar', 'bam', &:upcase)
+      expect(values.keys).to eq(%w[foo bar bam])
+    end
+
+    it 'should raise without block' do
+      expect { subject.fetch_multi('foo') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'cache key' do
+    it 'should support cache keys' do
+      obj = Object.new
+      def obj.cache_key
+        :foo
+      end
+      subject.write(obj, 'bar')
+      expect(subject.read('foo')).to eq('bar')
+    end
+
+    it 'should support to_param keys' do
+      obj = Object.new
+      def obj.to_param
+        :foo
+      end
+      subject.write(obj, 'bar')
+      expect(subject.read('foo')).to eq('bar')
+    end
+
+    it 'should support unversioned keys' do
+      obj = Object.new
+      def obj.cache_key
+        :foo
+      end
+
+      def obj.cache_key_with_version
+        'foo-v1'
+      end
+      subject.write(obj, 'bar')
+      expect(subject.read('foo')).to eq('bar')
+    end
+
+    it 'should support array keys' do
+      subject.write([:fu, 'foo'], 'bar')
+      expect(subject.read('fu/foo')).to eq('bar')
+    end
+
+    it 'should support hash keys' do
+      subject.write({ foo: 1, fu: 2 }, 'bar')
+      expect(subject.read('foo=1/fu=2')).to eq('bar')
+    end
+
+    it 'should be case sensitive' do
+      subject.write('foo', 'bar')
+      expect(subject.read('FOO')).to be_nil
+    end
+  end
+
+  describe 'with version' do
+    it 'should support fetch/read' do
+      subject.fetch('foo', version: 1) { 'bar' }
+      expect(subject.read('foo', version: 1)).to eq('bar')
+      expect(subject.read('foo', version: 2)).to be_nil
+    end
+
+    it 'should support write/read' do
+      subject.write('foo', 'bar', version: 1)
+      expect(subject.read('foo', version: 1)).to eq('bar')
+      expect(subject.read('foo', version: 2)).to be_nil
+    end
+
+    it 'should support exists' do
+      subject.write('foo', 'bar', version: 1)
+      expect(subject.exist?('foo', version: 1)).to be_truthy
+      expect(subject.exist?('foo', version: 2)).to be_falsey
+    end
+
+    it 'should cache/version keys' do
+      m1v1 = ModelWithKeyAndVersion.new('model/1', 1)
+      m1v2 = ModelWithKeyAndVersion.new('model/1', 2)
+
+      subject.write(m1v1, 'bar')
+      expect(subject.read(m1v1)).to eq('bar')
+      expect(subject.read(m1v2)).to be_nil
+    end
+
+    it 'should normalise' do
+      subject.write('foo', 'bar', version: 1)
+      expect(subject.read('foo', version: '1')).to eq('bar')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+ENV['RACK_ENV'] ||= 'test'
+
+require 'rspec'
+require 'fileutils'
+require 'activesupport_cache_database'
+
+Time.zone_default = Time.find_zone!('UTC')
+
+database_url = ENV.fetch('DATABASE_URL') do
+  path = File.expand_path('./test.sqlite3', __dir__)
+  FileUtils.rm_f(path)
+  "sqlite3://#{path}"
+end
+ActiveRecord::Base.configurations = { 'test' => { 'url' => database_url, 'pool' => 20 } }
+
+ActiveRecord::Base.establish_connection :test
+ActiveRecord::Base.connection.instance_eval do
+  drop_table 'activesupport_cache_entries', if_exists: true
+end
+ActiveRecord::Migration.suppress_messages do
+  ActiveSupport::Cache::DatabaseStore::Migration.migrate(:up)
+end
+
+RSpec.configure do |c|
+  c.after :each do
+    ActiveSupport::Cache::DatabaseStore::Model.truncate!
+  end
+end
+
+ModelWithKeyAndVersion = Struct.new(:cache_key, :cache_version)

metadata

@@ -0,0 +1,187 @@
+--- !ruby/object:Gem::Specification
+name: activesupport_cache_database
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Black Square Media Ltd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use your DB as a cache store
+email:
+- info@blacksquaremedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- activesupport_cache_database.gemspec
+- lib/active_support/cache/database_store.rb
+- lib/active_support/cache/database_store/migration.rb
+- lib/active_support/cache/database_store/model.rb
+- lib/activesupport_cache_database.rb
+- spec/active_support/cache/database_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bsm/record-cache-store
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ActiveSupport::Cache::Store implementation backed by ActiveRecord.
+test_files:
+- spec/active_support/cache/database_store_spec.rb
+- spec/spec_helper.rb