ultracache 0.1.0

data/lib/ultracache/macro.rb

@@ -0,0 +1,40 @@
+module Ultracache
+  module Macro
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def cached_queue_in(another, options={}, &block)
+        name = options[:as] ? options[:as] : self.to_s.underscore
+        relationship = BelongsAsCachedQueue.new name, block, :self_class => self,
+          :need_update => options[:need_update], :unless => options[:unless],
+          :associated_class => another
+
+        self.relationships(:strict => true).add(relationship)
+      end
+
+      def has_cached_queue(another, options={})
+        name = options[:as] ? options[:as] : another
+        relationship = HasCachedQueue.new name, :self_class => self,
+          :associated_class => options[:class] ? options[:class] : another
+
+        self.relationships(:strict => true).add(relationship)
+
+        define_method name do |*options|
+          read_cache(name, options.first || {})
+        end
+      end
+
+      def has_cached_attribute(name, options={}, &block)
+        relationship = HasCachedAttribute.new name, block, :self_class => self,
+          :serializer => options[:serializer]
+
+        rs = self.relationships(:strict => true)
+        self.relationships(:strict => true).add(relationship)
+
+        define_method name do |*options|
+          read_cache(name, options.first || {})
+        end
+      end
+    end
+  end
+end

data/lib/ultracache/models/mongoid_extension.rb

@@ -0,0 +1,9 @@
+module Ultracache
+  module Models
+    module MongoidExtension
+      def cached_queue_score
+        self.id.to_s[0..6].to_i(16)
+      end
+    end
+  end
+end

data/lib/ultracache/railtie.rb

@@ -0,0 +1,16 @@
+require 'rails'
+
+begin; require 'mongoid'; rescue LoadError; end
+
+module Rails
+  module Ultracache
+    class Railtie < Rails::Railtie
+      initializer 'ultracache' do |app|
+        if defined? ::Mongoid
+          require File.join(File.dirname(__FILE__), 'models/mongoid_extension.rb')
+          ::Mongoid::Document.send :include, Ultracache::Models::MongoidExtension
+        end
+      end
+    end
+  end
+end

data/lib/ultracache/relationship.rb

@@ -0,0 +1,24 @@
+module Ultracache
+  class Relationship
+    attr_reader :name
+
+    def initialize(name, options={})
+      @name = name
+      @self_class = options[:self_class].to_s
+      @associated_class = options[:associated_class].to_s
+    end
+
+    def self_class
+      @self_class.camelize.constantize
+    end
+
+    def associated_class
+      @associated_class.camelize.constantize
+    end
+
+    def read_cache(obj, options = {}); end
+    def save_cache(obj); end
+    def destroy_cache(obj); end
+    def update_cache(obj); end
+  end
+end

data/lib/ultracache/relationship/belongs_as_cached_queue.rb

@@ -0,0 +1,96 @@
+module Ultracache
+  class BelongsAsCachedQueue < Relationship
+    def initialize(name, block, options={})
+      super(name, options)
+      @serializer_block = block
+      @alias = options[:as]
+      @need_update = options[:need_update]
+      @unless = options[:unless]
+
+      @storage = Ultracache::Configurations.storage
+      @serializer = Ultracache::Configurations.serializer
+    end
+
+    # Saves serialized form of object into cache queue which the object
+    # has a relationship to.
+    #
+    # The first parameter, `obj`, is the object which will be stored into
+    # cache queue. `storage` parameter is 
+    #
+    # @return Serialized form of the object
+    def save_cache(obj)
+      return if @unless && obj.send(@unless)
+
+      value = if @serializer_block
+        @serializer_block.call obj
+      else
+        JSON.generate(obj.as_json)
+      end
+
+      @storage.put_queue(key(obj), score_of(obj), value)
+    end
+
+    # Destroys serialized cache from associated cache queue. In some cases
+    # like caching serialized documents of MongoDB, two or more cached objects
+    # may have the same score with other documents. To remove cache we want to
+    # delete only, we should deal with this problem.
+    #
+    # If two or more documents are fetched with the computed score,
+    # `destroy_cache` deserializes the cached documents in order to find one
+    # cache having the same identifier.
+    def destroy_cache(obj)
+      score = score_of(obj)
+      key = key(obj)
+
+      docs = @storage.get_queue(key, :from => score, :to => score)
+
+      if docs.count == 1
+        # Only one document is fetched from queue, and it is okay to remove
+        @storage.remove_from_queue_by_range(key, :from => score, :to => score)
+      elsif docs.count > 1
+        # We should deserialize fetched documents to find the document having
+        # the same id with `obj`
+        docs.each do |doc|
+          deserialized = @serializer.deserialize(doc)
+          _id = deserialized["id"]
+          _id = deserialized["_id"] unless _id
+
+          if _id == obj.id
+            @storage.remove_from_queue(key, doc)
+          end
+        end
+      end
+    end
+
+    # Updates object cache in queue. To update cache, we should destroy the
+    # document and regenerate it with updated information.
+    def update_cache(obj)
+      return unless @need_update
+      delete_cache(obj)
+      save_cache(obj)
+    end
+
+    # Returns key of cache queue which cache of the object will be stored into
+    def key(obj)
+      associated = @associated_class.to_s.underscore
+
+      namespace = @name
+      parent_id = obj.send("#{associated}_id")
+
+      "#{@associated_class.to_s.underscore}:#{parent_id}:#{namespace}"
+    end
+
+    protected
+      def score_of(obj)
+        obj.respond_to?(:cached_queue_score) ? obj.cached_queue_score : obj.id
+      end
+
+      def serialize(obj)
+        # Is it okay to refer configurations object here?
+        @serializer.serialize(obj) do |obj|
+          @serializer_block.call(obj)
+        end
+      end
+  end
+end
+

data/lib/ultracache/relationship/has_cached_attribute.rb

@@ -0,0 +1,51 @@
+module Ultracache
+  class HasCachedAttribute < Relationship
+    def initialize(name, block, options={})
+      super(name, options)
+      @serializer_method = options[:serializer]
+      @serializing_block = block if block_given?
+
+      @serializer = Ultracache::Configurations.serializer
+      @storage = Ultracache::Configurations.storage
+    end
+
+    def key(obj)
+      "#{@self_class.to_s.underscore}:#{obj.id}:#{@name}"
+    end
+
+    # Save serialized attribute to cache. If serializer method or serialization
+    # block is not given, Ultracache tries to serialize the object by
+    # serializeing hash returned by its `as_json` method.
+    def save_cache(obj)
+      value = if @serializer_method
+        @serializer.serialize(obj.send(@serializer_method))
+      elsif @serializing_block
+        @serializer.serialize(@serializing_block.call(obj))
+      else
+        @serializer.serialize(obj.as_json)
+      end
+
+      @storage.set(key(obj), value)
+      value
+    end
+
+    # Read stored cache from storage. If the cache is not found, it tries to
+    # save corresponding cache to storage and return its value
+    def read_cache(obj, options = {})
+      k = key(obj)
+
+      @storage.get(k) || save_cache(obj)
+    end
+
+    # Destroys cache from storage
+    def destroy_cache(obj)
+      @storage.del(key(obj))
+    end
+
+    # Updates value of existing cache. Its behavior is same with that of
+    # `save_cache`.
+    def update_cache(obj)
+      save_cache(obj)
+    end
+  end
+end

data/lib/ultracache/relationship/has_cached_queue.rb

@@ -0,0 +1,31 @@
+module Ultracache
+  class HasCachedQueue < Relationship
+    attr_reader :fetch_by
+
+    def initialize(name, options={})
+      @fetch_by = options[:fetch_by]
+      super(name, options)
+
+      @storage = Ultracache::Configurations.storage
+    end
+
+    def key(obj)
+      "#{@self_class.to_s.underscore}:#{obj.id}:#{@name}"
+    end
+
+    # Reads caches stored in corresponding queue. Caches can be fetched by
+    # their score or their rank.
+    def read_cache(obj, options = {})
+      k = self.key(obj)
+
+      fetch_by = @fetch_by || options[:fetch_by]
+      if fetch_by && fetch_by == :rank
+        @storage.get_queue_by_rank(k, options)
+      elsif options[:per_page]
+        @storage.get_queue_paged(k, options)
+      else
+        @storage.get_queue(k, options)
+      end
+    end
+  end
+end

data/lib/ultracache/relationships.rb

@@ -0,0 +1,41 @@
+module Ultracache
+  class Relationships
+    attr_reader :klass
+    attr_reader :relationships
+
+    def initialize(klass, rs = {})
+      @relationships = rs
+      @klass = klass
+    end
+
+    def add(relationship)
+      @relationships[relationship.name] = relationship
+    end
+
+    def keys
+      @relationships.keys
+    end
+
+    def find(name)
+      @relationships[name]
+    end
+    alias [] find
+
+    def each
+      @relationships.each do |k,v|
+        yield k, v
+      end
+    end
+
+    def merge(another)
+      klass = if another.klass >= @klass
+        @klass
+      else
+        another.klass
+      end
+
+      Relationships.new(klass, @relationships.merge(another.relationships))
+    end
+    alias | merge
+  end
+end

data/lib/ultracache/serializer/base.rb

@@ -0,0 +1,19 @@
+module Ultracache
+  # Base class
+  module Serializer
+    class Base
+
+      # Serializes model object. The Object should be converted into
+      # a hash containing an id field and required attributes.
+      #
+      # @param [Hash] obj A hash containing information of an object
+      #
+      # @return [String] Serialized object
+      def serialize(obj, &block); obj.to_s; end
+
+      # Deserializes a string which an object is serialized into to a
+      # hash.
+      def deserialize(serialized_object); end
+    end
+  end
+end

data/lib/ultracache/serializer/json_serializer.rb

@@ -0,0 +1,15 @@
+require 'json'
+
+module Ultracache
+  module Serializer
+    class JsonSerializer < Serializer::Base
+      def serialize(obj, &block)
+        JSON.generate(obj)
+      end
+
+      def deserialize(serialized_object)
+        JSON.parse(serialized_object)
+      end
+    end
+  end
+end

data/lib/ultracache/storage/redis.rb

@@ -0,0 +1,63 @@
+require 'redis'
+require 'redis/distributed'
+require 'json'
+
+module Ultracache
+  module Storage
+    class Redis
+      include Storage
+
+      def initialize(options = {})
+        @urls = options[:urls] || 'localhost'
+      end
+
+      def connection
+        @connection ||= ::Redis::Distributed.new(@urls)
+      end
+
+      def set(id, doc)
+        connection.set(id, doc)
+      end
+
+      def get(id)
+        connection.get(id)
+      end
+
+      def multi_get(*ids)
+        connection.mget(ids)
+      end
+
+      def del(id)
+        connection.del(id)
+      end
+
+      def get_queue(id, opts={})
+        connection.zrevrangebyscore(id, opts[:to] || "+inf", opts[:from] || "-inf")
+      end
+
+      def get_queue_paged(id, opts={})
+        per_page = opts[:per_page] || 20
+        page = opts[:page] || 1
+        offset = per_page.to_i * (page.to_i - 1)
+
+        connection.zrevrangebyscore(id, opts[:to] || "+inf", opts[:from] || "-inf", :limit => [offset, per_page])
+      end
+
+      def remove_from_queue_by_range(id, opts={})
+        connection.zremrangebyscore(id, opts[:from], opts[:to])
+      end
+
+      def remove_from_queue(id, val)
+        connection.zrem(id, val)
+      end
+
+      def get_queue_by_rank(id, opts={})
+        connection.zrevrange(id, opts[:from] || 0, opts[:to] || -1)
+      end
+
+      def put_queue(id, key, entry)
+        connection.zadd(id, key, entry)
+      end
+    end
+  end
+end

data/lib/ultracache/version.rb

@@ -0,0 +1,3 @@
+module Ultracache
+  VERSION = '0.1.0'
+end

data/spec/models/admin.rb

@@ -0,0 +1,13 @@
+require 'models/person'
+
+class Admin < Person
+  include Ultracache::Cached
+
+  has_cached_attribute :cached_permissions do |admin|
+    admin.permission
+  end
+
+  def name
+    'admin'
+  end
+end

data/spec/models/customer.rb

@@ -0,0 +1,7 @@
+class Customer
+  include Mongoid::Document
+  include Ultracache::Cached
+
+  has_many :orders
+  has_cached_queue :cached_orders, :class => 'Order'
+end