hitnmiss 2.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "hitnmiss"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/hitnmiss.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hitnmiss/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hitnmiss"
+  spec.version       = Hitnmiss::VERSION
+  spec.authors       = ["Andrew De Ponte"]
+  spec.email         = ["cyphactor@gmail.com"]
+
+  spec.summary       = %q{Ruby read-through, write-behind caching using POROs}
+  spec.description   = %q{Ruby gem to support using the Repository pattern for read-through, write-behind caching using POROs}
+  spec.homepage      = "https://github.com/Acornsgrow/hitnmiss"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "timecop", "~> 0.8"
+  spec.add_development_dependency "simplecov", "~> 0.11"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 0.4"
+end

data/lib/hitnmiss.rb

@@ -0,0 +1,22 @@
+require "hitnmiss/version"
+require "hitnmiss/errors"
+require "hitnmiss/repository"
+require "hitnmiss/background_refresh_repository"
+require "hitnmiss/driver_registry"
+require "hitnmiss/entity"
+require "hitnmiss/driver"
+require "hitnmiss/in_memory_driver"
+
+module Hitnmiss
+  @driver_registry = DriverRegistry.new
+
+  def self.register_driver(name, driver)
+    @driver_registry.register(name, driver)
+  end
+
+  def self.driver(name)
+    @driver_registry.get(name)
+  end
+end
+
+Hitnmiss.register_driver(:in_memory, Hitnmiss::InMemoryDriver.new)

data/lib/hitnmiss/background_refresh_repository.rb

@@ -0,0 +1,78 @@
+require 'hitnmiss/repository/cache_management'
+require 'thread'
+
+module Hitnmiss
+  module BackgroundRefreshRepository
+    class RefreshIntervalRequired < StandardError; end
+
+    def self.included(mod)
+      mod.include(Repository::CacheManagement)
+      mod.extend(ClassMethods)
+      mod.include(InstanceMethods)
+    end
+
+    module ClassMethods
+      def refresh_interval(interval_in_seconds=nil)
+        if interval_in_seconds
+          @refresh_interval = interval_in_seconds
+        else
+          @refresh_interval
+        end
+      end
+    end
+
+    module InstanceMethods
+      def initialize
+        if self.class.refresh_interval.nil?
+          raise RefreshIntervalRequired, 'the refresh_interval must be set'
+        end
+      end
+
+      def stale?(*args)
+        true
+      end
+
+      def refresh(*args, swallow_exceptions: [])
+        if swallow_exceptions.empty?
+          if stale?(*args)
+            prime(*args)
+          end
+        else
+          begin
+            if stale?(*args)
+              prime(*args)
+            end
+          rescue *swallow_exceptions
+          end
+        end
+      end
+
+      def background_refresh(*args, swallow_exceptions: [])
+        @refresh_thread = Thread.new(self, args) do |repository, args|
+          while(true) do
+            refresh(*args, swallow_exceptions: swallow_exceptions)
+            sleep repository.class.refresh_interval
+          end
+        end
+        @refresh_thread.abort_on_exception = true
+      end
+
+      private
+
+      def strip_expiration(unstripped_entity)
+        if unstripped_entity.expiration
+          return Hitnmiss::Entity.new(unstripped_entity.value,
+                                      fingerprint: unstripped_entity.fingerprint,
+                                      last_modified: unstripped_entity.last_modified)
+        else
+          return unstripped_entity
+        end
+      end
+
+      def cache_entity(args, cacheable_entity)
+        entity = strip_expiration(cacheable_entity)
+        super(args, entity)
+      end
+    end
+  end
+end

data/lib/hitnmiss/driver.rb

@@ -0,0 +1,39 @@
+module Hitnmiss
+  module Driver
+    class Hit
+      attr_reader :value, :updated_at, :fingerprint, :last_modified
+
+      def initialize(value, updated_at: nil, fingerprint: nil,
+                     last_modified: nil)
+        @value = value
+        @updated_at = updated_at
+        @fingerprint = fingerprint
+        @last_modified = last_modified
+      end
+    end
+
+    class Miss; end
+
+    module Interface
+      def set(key, entity)
+        raise Hitnmiss::Errors::NotImplemented
+      end
+
+      def get(key)
+        raise Hitnmiss::Errors::NotImplemented
+      end
+
+      def all(keyspace)
+        raise Hitnmiss::Errors::NotImplemented
+      end
+
+      def delete(key)
+        raise Hitnmiss::Errors::NotImplemented
+      end
+
+      def clear(keyspace)
+        raise Hitnmiss::Errors::NotImplemented
+      end
+    end
+  end
+end

data/lib/hitnmiss/driver_registry.rb

@@ -0,0 +1,17 @@
+module Hitnmiss
+  class DriverRegistry
+    def initialize
+      @registry = {}
+    end
+
+    def register(name, driver)
+      @registry[name] = driver
+    end
+
+    def get(name)
+      @registry.fetch(name) do |name|
+        raise Errors::UnregisteredDriver.new("#{name} is not a registered driver")
+      end
+    end
+  end
+end

data/lib/hitnmiss/entity.rb

@@ -0,0 +1,12 @@
+module Hitnmiss
+  class Entity
+    attr_reader :value, :expiration, :fingerprint, :last_modified
+
+    def initialize(value, expiration: nil, fingerprint: nil, last_modified: nil)
+      @value = value
+      @expiration = expiration
+      @fingerprint = fingerprint
+      @last_modified = last_modified
+    end
+  end
+end

data/lib/hitnmiss/errors.rb

@@ -0,0 +1,9 @@
+module Hitnmiss
+  module Errors
+    class Error < StandardError; end
+
+    class NotImplemented < Error; end
+
+    class UnregisteredDriver < Error; end
+  end
+end

data/lib/hitnmiss/in_memory_driver.rb

@@ -0,0 +1,94 @@
+module Hitnmiss
+  class InMemoryDriver
+    include Hitnmiss::Driver::Interface
+
+    def initialize
+      @mutex = Mutex.new
+      @cache = {}
+    end
+
+    def set(key, entity)
+      if entity.expiration
+        expiration = Time.now.to_i + entity.expiration
+        @mutex.synchronize do
+          @cache[key] = { 'value' => entity.value, 'expiration' => expiration }
+          @cache[key]['fingerprint'] = entity.fingerprint if entity.fingerprint
+          @cache[key]['updated_at'] = internal_timestamp
+          @cache[key]['last_modified'] = entity.last_modified if entity.last_modified
+        end
+      else
+        @mutex.synchronize do
+          @cache[key] = { 'value' => entity.value }
+          @cache[key]['fingerprint'] = entity.fingerprint if entity.fingerprint
+          @cache[key]['updated_at'] = internal_timestamp
+          @cache[key]['last_modified'] = entity.last_modified if entity.last_modified
+        end
+      end
+    end
+
+    def get(key)
+      cached_entity = nil
+      @mutex.synchronize do
+        cached_entity = @cache[key].dup if @cache[key]
+      end
+
+      return Hitnmiss::Driver::Miss.new if cached_entity.nil?
+
+      if cached_entity.has_key?('expiration')
+        if Time.now.to_i >= cached_entity['expiration']
+          return Hitnmiss::Driver::Miss.new
+        end
+      end
+
+      return Hitnmiss::Driver::Hit.new(cached_entity['value'],
+                                       build_hit_keyword_args(cached_entity))
+    end
+
+    def all(keyspace)
+      @mutex.synchronize do
+        matching_values = []
+        @cache.each do |key, entity|
+          matching_values << entity.fetch('value') if match_keyspace?(key, keyspace)
+        end
+        return matching_values
+      end
+    end
+
+    def delete(key)
+      @mutex.synchronize do
+        @cache.delete(key)
+      end
+    end
+
+    def clear(keyspace)
+      @mutex.synchronize do
+        @cache.delete_if { |key, _| match_keyspace?(key, keyspace) }
+      end
+    end
+
+    def match_keyspace?(key, keyspace)
+      regex = Regexp.new("^#{keyspace}\\" + Repository::KeyGeneration::KEY_COMPONENT_SEPARATOR)
+      return regex.match(key)
+    end
+
+    private
+
+    def internal_timestamp
+      Time.now.utc.iso8601
+    end
+
+    def build_hit_keyword_args(cached_entity)
+      options = {}
+      if cached_entity.has_key?('fingerprint')
+        options[:fingerprint] = cached_entity['fingerprint']
+      end
+      if cached_entity.has_key?('updated_at')
+        options[:updated_at] = Time.parse(cached_entity['updated_at'])
+      end
+      if cached_entity.has_key?('last_modified')
+        options[:last_modified] = cached_entity['last_modified']
+      end
+      return **options
+    end
+  end
+end

data/lib/hitnmiss/repository.rb

@@ -0,0 +1,41 @@
+require 'hitnmiss/repository/cache_management'
+
+module Hitnmiss
+  module Repository
+    def self.included(mod)
+      mod.include(CacheManagement)
+      mod.extend(ClassMethods)
+      mod.include(InstanceMethods)
+    end
+
+    module ClassMethods
+      def default_expiration(expiration_in_seconds=nil)
+        if expiration_in_seconds
+          @default_expiration = expiration_in_seconds
+        else
+          @default_expiration
+        end
+      end
+    end
+
+    module InstanceMethods
+      private
+
+      def enrich_entity_expiration(unenriched_entity)
+        if unenriched_entity.expiration
+          return unenriched_entity
+        else
+          return Hitnmiss::Entity.new(unenriched_entity.value,
+                                      expiration: self.class.default_expiration,
+                                      fingerprint: unenriched_entity.fingerprint,
+                                      last_modified: unenriched_entity.last_modified)
+        end
+      end
+
+      def cache_entity(args, cacheable_entity)
+        entity = enrich_entity_expiration(cacheable_entity)
+        super(args, entity)
+      end
+    end
+  end
+end

data/lib/hitnmiss/repository/cache_management.rb

@@ -0,0 +1,70 @@
+require 'hitnmiss/repository/fetcher'
+require 'hitnmiss/repository/driver_management'
+require 'hitnmiss/repository/key_generation'
+
+module Hitnmiss
+  module Repository
+    module CacheManagement
+      class UnsupportedDriverResponse < StandardError; end
+
+      def self.included(mod)
+        mod.include(Fetcher)
+        mod.extend(DriverManagement)
+        mod.include(KeyGeneration)
+        mod.include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def clear
+          Hitnmiss.driver(self.class.driver).clear(self.class.keyspace)
+        end
+
+        def delete(*args)
+          Hitnmiss.driver(self.class.driver).delete(generate_key(*args))
+        end
+
+        def all
+          Hitnmiss.driver(self.class.driver).all(self.class.keyspace)
+        end
+
+        def prime_all
+          cacheable_entities = fetch_all(self.class.keyspace)
+          return cacheable_entities.map do |cacheable_entity_hash|
+            args = cacheable_entity_hash.fetch(:args)
+            cacheable_entity = cacheable_entity_hash.fetch(:entity)
+            cache_entity(args, cacheable_entity)
+            cacheable_entity.value
+          end
+        end
+
+        def prime(*args)
+          cacheable_entity = fetch(*args)
+          cache_entity(args, cacheable_entity)
+          return cacheable_entity.value
+        end
+
+        def get(*args)
+          hit_or_miss = get_from_cache(*args)
+          if hit_or_miss.is_a?(Hitnmiss::Driver::Miss)
+            return prime(*args)
+          elsif hit_or_miss.is_a?(Hitnmiss::Driver::Hit)
+            return hit_or_miss.value
+          else
+            raise UnsupportedDriverResponse.new("Driver '#{self.class.driver.inspect}' did not return an object of the support types (Hitnmiss::Driver::Hit, Hitnmiss::Driver::Miss)")
+          end
+        end
+
+        private
+
+        def get_from_cache(*args)
+          Hitnmiss.driver(self.class.driver).get(generate_key(*args))
+        end
+
+        def cache_entity(args, cacheable_entity)
+          Hitnmiss.driver(self.class.driver).set(generate_key(*args),
+                                                 cacheable_entity)
+        end
+      end
+    end
+  end
+end