cache_man 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 713ab0b91d633604cfa388ee97cb8a40593ed3b7
+  data.tar.gz: 204adbbc73dfb93c9add9c5e33d6e34b2469b774
+SHA512:
+  metadata.gz: a44e638edc706522134b9ac36cd74602cbc5d1763451fefd58ecbe9079aa1863c214c92c4a8af976aee582336ee2681c77788bddbe3967184de43d8c2db52b74
+  data.tar.gz: af5c8cb28291832170bd0f93b693b36fea190496e1e1a6995bca4bbf887d73558de1bb31482603e417bab796cb249e74e1e8929414518e3e79a5f98e9dae1abe

data/lib/cache_man.rb

@@ -0,0 +1,13 @@
+# This file contains the main namespace of the gem
+# and other required modules/classes needed by the rest of the gem
+require "cache_man/version"
+require "active_support/concern"
+require "active_support/core_ext/numeric/time"
+require "rails"
+
+module CacheMan
+end
+
+require "cache_man/errors.rb"
+require "cache_man/cacheable"
+require "cache_man/fetchable"

data/lib/cache_man/cacheable.rb

@@ -0,0 +1,62 @@
+# This concern adds support for getting and setting cache for a model.
+# It also adds support for a soft expiry of cache besides a hard expiry.
+# The module allows an object to respond to the stale? method which informs other objects whether the cache has soft expired or not.
+# The cache can be updated asynchronously if it has soft expired.
+# For the asynchronously update of the cache, this gem depends on another gem called dispatch_rider.
+# It depends on the cache settings defined in your application config to work properly.
+# The concern only works for ducks that respond to id and find methods.
+# So, ideally any ActiveModel or ActiveResource object should work.
+module CacheMan
+  module Cacheable
+    extend ActiveSupport::Concern
+
+    @cache_duration = 20.minutes
+
+    class << self
+      attr_reader :cache_duration
+    end
+
+    module ClassMethods
+      def cache_client
+        Rails.cache
+      end
+
+      def cache_key(id)
+        "#{self.name.underscore}/#{id}"
+      end
+
+      def cache(id)
+        resource = find(id)
+        resource.cache
+        resource
+      end
+      alias_method :new_cache, :cache
+
+      def get_cached(id)
+        cache_client.read(cache_key(id))
+      end
+    end
+
+    def cache_client
+      self.class.cache_client
+    end
+
+    def cache_key
+      self.class.cache_key(self.id)
+    end
+
+    # this is meant to be overriden to change the expiry (at least for now)
+    def cache_hard_expires_in
+      1.day
+    end
+
+    def cache
+      @cache_expires_at = Cacheable.cache_duration.since.to_i
+      self.cache_client.write(self.cache_key, self, expires_in: cache_hard_expires_in)
+    end
+
+    def stale?
+      @cache_expires_at && Time.now > Time.at(@cache_expires_at)
+    end
+  end
+end

data/lib/cache_man/errors.rb

@@ -0,0 +1,10 @@
+module CacheMan
+  class CacheManError < StandardError
+  end
+
+  class FinderNotFound < CacheManError
+    def initialize
+      super("There is no <model>.find method defined. Please implement a <model>.find method or a finder module in app/models/<model>/finder.rb")
+    end
+  end
+end

data/lib/cache_man/fetchable.rb

@@ -0,0 +1,45 @@
+# This concern adds support for a model to be fetched either from cache or from some other data store.
+# The concern is only to be included in classes that implement a class method find to fetch the object from a data store other than cache.
+# If such a class method does not exist, you can write your own custom finder module for the model.
+# By convention, the finder module should be app/models/<model_name>/finder.rb
+# The first attempt to fetch a model will be from cache.
+# If that fails, then it will fallback to fetching from a different data store.
+# If the cache has soft expired then it will return the stale object, but will let the cache update asynchronously.
+module CacheMan
+  module Fetchable
+    extend ActiveSupport::Concern
+
+    included do
+      include Cacheable
+      begin
+        extend "#{name}::Finder".constantize
+      rescue NameError
+        raise FinderNotFound.new unless respond_to?(:find)
+      end
+      private_class_method :find
+    end
+
+    module ClassMethods
+      def fetch(id)
+        cached_resource = get_cached(id)
+        if cached_resource.nil?
+          new_cache(id)
+        elsif cached_resource.stale?
+          recache(id) || cached_resource
+        else
+          cached_resource
+        end
+      end
+
+      def recache(id)
+        begin
+          new_cache(id)
+        rescue
+          # request failed, should probably do something useful with it here
+          # fall back to using cached copy
+        end
+      end
+
+    end
+  end
+end

data/lib/cache_man/version.rb

@@ -0,0 +1,3 @@
+module CacheMan
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: cache_man
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Suman Mukherjee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+description: This is a gem that serves remote resources from a cache. If the cache
+  gets stale, then the stale cache is served and the cache gets updated in async.
+email:
+- sumanmukherjee03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/cache_man/cacheable.rb
+- lib/cache_man/errors.rb
+- lib/cache_man/fetchable.rb
+- lib/cache_man/version.rb
+- lib/cache_man.rb
+homepage: ''
+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: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: The gem connects to a memcache server and tries to fetch the resource you
+  requested from the cache. It maintains a time stamp to figure out the expiry of
+  the cache. But the expiry is a soft expiry in most cases. If it is a soft expiry,
+  then it serves the stale asset and updates the cache in async. If it is a hard expiry,
+  then it fetches the resource from remote and serves the asset.
+test_files: []