iknow_cache 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 14a5fbfe4eb06e835259e354c8a8fdfb9bc82c2d34bfe6ea62fc8269144ca8a5
+  data.tar.gz: 22da19d2f809d5d092298d47d1b703a146ff6d143d7ac83c0191a8fae98eca36
+SHA512:
+  metadata.gz: 80d4ff3de7d25e388217e20922971d4378970591bc6a8c57672e1c4745e1451e57a2105f16a468c7845ce4103dae8b62a5f8abe5cf6ab66713a4fa9ec23aac8f
+  data.tar.gz: c23861a1464d8e2ea0c6d711eac3b8517253f745cda66bb9c612b4c67be11f669fff637c0e5eeb49c967600d38b050692895104c7d84500d5d8aa78a4f3c9cc0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2017 Chris Andreae
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,25 @@
+[![Build Status](https://travis-ci.org/iknow/iknow_cache.svg?branch=master)](https://travis-ci.org/iknow/iknow_cache)
+
+# IknowCache
+
+iKnow's versioned nested cache backed by Rails cache
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'iknow_cache'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install iknow_cache
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'IknowCache'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/iknow_cache.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+class IknowCache
+  def self.register_group(name, key_name, default_options: nil, static_version: 1)
+    group = CacheGroup.new(nil, name, key_name, default_options, static_version)
+    yield group if block_given?
+    group
+  end
+
+  class CacheGroup
+    attr_reader :parent, :default_options, :name, :key_name, :key
+
+    def initialize(parent, name, key_name, default_options, static_version)
+      @parent          = parent
+      @name            = name
+      @key_name        = key_name
+      @key             = Struct.new(*parent.try { |p| p.key.members }, key_name)
+      @default_options = IknowCache.merge_options(parent&.default_options, default_options).try { |x| x.dup.freeze }
+      @static_version  = static_version
+
+      @caches          = []
+      @children        = []
+    end
+
+    def register_child_group(name, key_name, default_options: nil, static_version: 1)
+      group = CacheGroup.new(self, name, key_name, default_options, static_version)
+      @children << group
+      yield group if block_given?
+      group
+    end
+
+    def register_cache(name, cache_options: nil)
+      c = Cache.new(self, name, cache_options)
+      @caches << c
+      c
+    end
+
+    # Clear this key in all Caches in this CacheGroup.
+    # It is an error to do this if this CacheGroup has an statically versioned child, as that child cannot be invalidated.
+    def delete_all(key, parent_path: nil)
+      @caches.each do |cache|
+        cache.delete(key, parent_path: parent_path)
+      end
+
+      @children.each do |child_group|
+        child_group.invalidate_cache_group(key)
+      end
+    end
+
+    # Clear all keys in this cache group (for the given parent),
+    # invalidating all caches in it and its children
+    def invalidate_cache_group(parent_key = nil)
+      parent_path = self.parent_path(parent_key)
+      Rails.cache.increment(version_path_string(parent_path))
+    end
+
+    # Fetch the path for this cache. We allow the parent_path to be precomputed
+    # to save hitting the cache multiple times for its version.
+    def path(key, parent_path = nil)
+      if key.nil? || key[self.key_name].nil?
+        raise ArgumentError.new("Missing required key '#{self.key_name}' for cache '#{self.name}'")
+      end
+
+      key_value     = key[self.key_name]
+      parent_path ||= self.parent_path(key)
+      version       = self.version(parent_path)
+      path_string(parent_path, version, key_value)
+    end
+
+    ROOT_PATH = 'IknowCache'
+
+    def parent_path(parent_key = nil)
+      if parent.nil?
+        ROOT_PATH
+      else
+        parent.path(parent_key)
+      end
+    end
+
+    def version(parent_path)
+      Rails.cache.fetch(version_path_string(parent_path), raw: true) { 1 }
+    end
+
+    # compute multiple paths at once: returns { key => path }
+    def path_multi(keys)
+      # compute parent path for each key
+      parent_paths = self.parent_path_multi(keys)
+
+      # and versions for each parent path
+      versions = self.version_multi(parent_paths.values.uniq)
+
+      # update parent_paths with our paths
+      keys.each do |key|
+        parent_path = parent_paths[key]
+        version     = versions[parent_path]
+        key_value   = key[self.key_name]
+
+        unless key_value
+          raise ArgumentError.new("Required cache key missing: #{self.key_name}")
+        end
+
+        parent_paths[key] = path_string(parent_path, version, key_value)
+      end
+
+      parent_paths
+    end
+
+    # look up multiple parent paths at once, returns { key => parent_path }
+    def parent_path_multi(parent_keys = nil)
+      if parent.nil?
+        parent_keys.each_with_object({}) { |k, h| h[k] = ROOT_PATH }
+      else
+        parent.path_multi(parent_keys)
+      end
+    end
+
+    # Look up multiple versions at once, returns { parent_path => version }
+    def version_multi(parent_paths)
+      # compute version paths
+      version_by_pp = parent_paths.each_with_object({}) { |pp, h| h[pp] = version_path_string(pp) }
+      version_paths = version_by_pp.values
+
+      # look up versions in cache
+      versions = Rails.cache.read_multi(*version_paths, raw: true)
+
+      version_paths.each do |vp|
+        next if versions.has_key?(vp)
+
+        versions[vp] = Rails.cache.fetch(vp, raw: true) { 1 }
+      end
+
+      # swap in the versions
+      parent_paths.each do |pp|
+        vp = version_by_pp[pp]
+        version = versions[vp]
+        version_by_pp[pp] = version
+      end
+
+      version_by_pp
+    end
+
+    private
+
+    def path_string(parent_path, version, value)
+      "#{parent_path}/#{name}/#{@static_version}/#{version}/#{value}"
+    end
+
+    def version_path_string(parent_path)
+      "#{parent_path}/#{name}/_version"
+    end
+  end
+
+  class Cache
+    DEBUG = false
+
+    attr_reader :name, :cache_options, :cache_group
+
+    def initialize(cache_group, name, cache_options)
+      @cache_group   = cache_group
+      @name          = name
+      @cache_options = IknowCache.merge_options(cache_group.default_options, cache_options).try { |x| x.dup.freeze }
+    end
+
+    def fetch(key, parent_path: nil, **options, &block)
+      p = path(key, parent_path)
+      Rails.logger.debug("Cache Fetch: #{p}") if DEBUG
+      v = Rails.cache.fetch(p, IknowCache.merge_options(cache_options, options), &block)
+      Rails.logger.debug("=> #{v.inspect}") if DEBUG
+      v
+    end
+
+    def read(key, parent_path: nil, **options)
+      p = path(key, parent_path)
+      Rails.logger.debug("Cache Read: #{p}") if DEBUG
+      v = Rails.cache.read(p, IknowCache.merge_options(cache_options, options))
+      Rails.logger.debug("=> #{v.inspect}") if DEBUG
+      v
+    end
+
+    def write(key, value, parent_path: nil, **options)
+      p = path(key, parent_path)
+      if DEBUG
+        Rails.logger.debug("Cache Store: #{p} (#{IknowCache.merge_options(cache_options, options).inspect})")
+        Rails.logger.debug("<= #{value.inspect}")
+      end
+      Rails.cache.write(p, value, IknowCache.merge_options(cache_options, options))
+    end
+
+    def delete(key, parent_path: nil, **options)
+      p = path(key, parent_path)
+      Rails.logger.debug("Cache Delete: #{p}") if DEBUG
+      Rails.cache.delete(p, IknowCache.merge_options(cache_options, options))
+    end
+
+    def read_multi(keys)
+      return {} if keys.blank?
+
+      key_paths = path_multi(keys)
+      path_keys = key_paths.invert
+
+      Rails.logger.debug("Cache Multi-Read: #{key_paths.values.inspect}") if DEBUG
+      raw = Rails.cache.read_multi(*key_paths.values)
+      vs = raw.each_with_object({}) do |(path, value), h|
+        h[path_keys[path]] = value
+      end
+      Rails.logger.debug("=> #{vs.inspect}") if DEBUG
+      vs
+    end
+
+    def write_multi(entries, options = nil)
+      return {} if entries.blank?
+
+      key_paths = path_multi(entries.keys)
+      options = IknowCache.merge_options(cache_options, options)
+
+      entries.each do |key, value|
+        Rails.logger.debug("Cache Multi-Write: #{key_paths[key]}") if DEBUG
+        Rails.cache.write(key_paths[key], value, options)
+      end
+    end
+
+    delegate :key, to: :cache_group
+
+    private
+
+    def path(key, parent_path = nil)
+      group_path = @cache_group.path(key, parent_path)
+      path_string(group_path)
+    end
+
+    def path_multi(keys)
+      @cache_group.path_multi(keys).each_with_object({}) do |(key, group_path), h|
+        h[key] = path_string(group_path)
+      end
+    end
+
+    def path_string(group_path)
+      "#{group_path}/#{self.name}"
+    end
+  end
+
+  def self.merge_options(parent_options, options)
+    if parent_options.blank?
+      options
+    elsif options.blank?
+      parent_options
+    else
+      parent_options.merge(options)
+    end
+  end
+end

data/lib/iknow_cache/version.rb

@@ -0,0 +1,3 @@
+class IknowCache
+  VERSION = '1.1.1'
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: iknow_cache
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Chris Andreae
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: 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'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  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: 
+email:
+- chris@bibo.com.ph
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/iknow_cache.rb
+- lib/iknow_cache/version.rb
+homepage: https://github.com/iknow/iknow_cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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: iKnow's versioned nested cache
+test_files: []