cached_record 0.1.0

data/config/database.yml

@@ -0,0 +1,17 @@
+development:
+  adapter:  mysql2
+  host:     localhost
+  database: cached_record_development
+  username: root
+  password:
+  pool: 5
+  timeout: 5000
+
+test:
+  adapter:  mysql2
+  host:     localhost
+  database: cached_record_test
+  username: root
+  password:
+  pool: 5
+  timeout: 5000

data/db/cached_record.sql

@@ -0,0 +1,71 @@
+DROP TABLE IF EXISTS `articles`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `articles` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `title` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `content` text COLLATE utf8_unicode_ci,
+  `author_id` int(11) DEFAULT NULL,
+  `foo_id` int(11) DEFAULT NULL,
+  `published_at` datetime DEFAULT NULL,
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `author_id` (`author_id`)
+) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+INSERT INTO `articles` VALUES (1,'Behold! It\'s CachedRecord!','Cache ORM instances to avoid database queries',1,2,'2013-08-01 12:00:00','2013-08-01 10:00:00','2013-08-01 11:00:00');
+DROP TABLE IF EXISTS `articles_tags`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `articles_tags` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `article_id` int(11) DEFAULT NULL,
+  `tag_id` int(11) DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `articles_tags` (`article_id`,`tag_id`)
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+INSERT INTO `articles_tags` VALUES (1,1,1),(2,1,2);
+DROP TABLE IF EXISTS `comments`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `comments` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `content` text COLLATE utf8_unicode_ci,
+  `article_id` int(11) DEFAULT NULL,
+  `poster_id` int(11) DEFAULT NULL,
+  `created_at` datetime DEFAULT NULL,
+  `updated_at` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`),
+  KEY `article_id` (`article_id`),
+  KEY `poster_id` (`poster_id`)
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+INSERT INTO `comments` VALUES (1,'What a great article! :)',1,2,'2013-08-02 12:00:00','2013-08-02 13:00:00'),(2,'Thanks!',1,1,'2013-08-02 14:00:00','2013-08-02 14:00:00');
+DROP TABLE IF EXISTS `tags`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `tags` (
+  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
+  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `created_at` datetime DEFAULT NULL,
+  `updated_at` datetime DEFAULT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+INSERT INTO `tags` VALUES (1,'ruby','2013-08-01 08:00:00','2013-08-01 08:00:00'),(2,'gem','2013-08-01 08:01:00','2013-08-01 08:01:00');
+DROP TABLE IF EXISTS `users`;
+/*!40101 SET @saved_cs_client     = @@character_set_client */;
+/*!40101 SET character_set_client = utf8 */;
+CREATE TABLE `users` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `name` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `description` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
+  `active` tinyint(1) DEFAULT NULL,
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
+/*!40101 SET character_set_client = @saved_cs_client */;
+INSERT INTO `users` VALUES (1,'Paul Engel','Author of CachedRecord',1,'2013-08-01 11:00:00','2013-08-01 12:00:00'),(2,'Ken Adams','Some guy',1,'2013-08-02 10:00:00','2013-08-02 11:00:00');

data/lib/cached_record/cache.rb

@@ -0,0 +1,125 @@
+require "dalli"
+require "redis"
+
+module CachedRecord
+  module Cache
+    class Error < StandardError; end
+
+    def self.setup(store, options = {})
+      if valid_store? store
+        send store, options
+      end
+    end
+
+    def self.memcached(options = nil)
+      if stores[:memcached].nil? || options
+        options ||= {}
+        host = options.delete(:host) || "localhost"
+        port = options.delete(:port) || 11211
+        stores[:memcached] = Dalli::Client.new "#{host}:#{port}", options
+      end
+      stores[:memcached]
+    end
+
+    def self.redis(options = nil)
+      if stores[:redis].nil? || options
+        options ||= {}
+        stores[:redis] = Redis.new options
+      end
+      stores[:redis]
+    end
+
+    def self.cache
+      @cache ||= {Dalli::Client => {}, Redis => {}}
+    end
+
+    def self.clear!
+      @cache = nil
+    end
+
+    def self.get(klass, id)
+      retained(klass, id) || begin
+        cache_string = store(klass).get(klass.cache_key(id)) || begin
+          return unless (instance = yield if block_given?)
+          set instance
+        end
+        json, epoch_time = split_cache_string(cache_string)
+        memoized(klass, id, epoch_time) do
+          klass.load_cache_json JSON.parse(json)
+        end
+      end
+    end
+
+    def self.set(instance)
+      "#{instance.to_cache_json}#{"@#{Time.now.to_i}" if instance.class.as_cache[:memoize]}".tap do |cache_string|
+        store(instance.class).set instance.class.cache_key(instance.id), cache_string, instance.class.as_cache[:expire]
+      end
+    end
+
+    def self.expire(instance)
+      klass = instance.class
+      cache_key = klass.cache_key instance.id
+      store(klass).delete cache_key
+      cache[store(klass).class].delete cache_key if klass.as_cache[:memoize]
+      nil
+    end
+
+    def self.retained(klass, id)
+      return unless klass.as_cache[:memoize] && klass.as_cache[:retain]
+      cache_hash, cache_key = cache[store(klass).class], klass.cache_key(id)
+
+      if (cache_entry = cache_hash[cache_key]) && (Time.now.to_i < cache_entry[:cache_hit])
+        cache_entry[:instance]
+      end
+    end
+
+    def self.memoized(klass, id, epoch_time)
+      return yield unless klass.as_cache[:memoize]
+      cache_hash, cache_key = cache[store(klass).class], klass.cache_key(id)
+      cache_hit = klass.as_cache[:retain] ? {:cache_hit => (Time.now + klass.as_cache[:retain]).to_i} : {}
+
+      if (cache_entry = cache_hash[cache_key]) && (epoch_time == cache_entry[:epoch_time])
+        cache_entry.merge! cache_hit
+        cache_entry[:instance]
+      else
+        yield.tap do |instance|
+          cache_hash[cache_key] = {:instance => instance, :epoch_time => epoch_time}.merge(cache_hit) if instance
+        end
+      end
+    end
+
+  private
+
+    def self.valid_store?(arg)
+      [:memcached, :redis].include?(arg.to_sym)
+    end
+
+    def self.stores
+      @stores ||= {}
+    end
+
+    def self.store(klass)
+      store = klass.as_cache[:store] || begin
+        if stores.size == 1
+          stores.keys.first
+        else
+          raise Error, "Cannot determine default cache store (store size is not 1: #{@stores.keys.sort.inspect})"
+        end
+      end
+      if valid_store?(store)
+        send(store)
+      else
+        raise Error, "Invalid cache store :#{store} passed"
+      end
+    end
+
+    def self.split_cache_string(string)
+      reg_exp = /@(\d+)$/
+      string.match(reg_exp)
+      json = string.gsub(reg_exp, "")
+      epoch_time = $1.to_i if $1
+      [json, epoch_time]
+    end
+
+  end
+end

data/lib/cached_record/orm/active_record.rb

@@ -0,0 +1,76 @@
+module CachedRecord
+  module ORM
+    module ActiveRecord
+
+      def self.setup?
+        !!defined?(::ActiveRecord)
+      end
+
+      def self.setup
+        return false unless setup?
+        ::ActiveRecord::Base.send :include, ORM
+        ::ActiveRecord::Base.extend ClassMethods
+        ::ActiveRecord::Base.send :include, InstanceMethods
+        true
+      end
+
+      module ClassMethods
+        def uncached(id)
+          find(id)
+        end
+        def new_cached_instance(attributes, foreign_keys, variables)
+          super.tap do |instance|
+            instance.instance_variable_set :@new_record, false
+          end
+        end
+      private
+        def set_cached_association(instance, key, value)
+          return unless value
+          if reflection = _cache_reflection_(instance, key, value)
+            value = _cache_value_(instance, reflection, value)
+            instance.send :"#{reflection.name}=", value
+          end
+        end
+        def _cache_reflection_(instance, key, value)
+          if key.to_s.match /^_(.*)_ids?/
+            reflections[$1.pluralize.to_sym]
+          else
+            instance.send :"#{key}=", value
+            reflections.detect{|k, v| v.foreign_key == key.to_s}.try(:last)
+          end
+        end
+        def _cache_value_(instance, reflection, value)
+          if value.is_a? Array
+            (instance.respond_to?(:association) ? instance.association(reflection.name) : instance.send(reflection.name).instance_variable_get(:@association)).loaded!
+            value.collect{|x| reflection.klass.cached x}
+          else
+            reflection.klass.cached value
+          end
+        end
+      end
+
+      module InstanceMethods
+        def cache_attributes
+          as_json(cache_json_options.slice(:only).merge(:root => false)).symbolize_keys!.merge cache_foreign_keys
+        end
+        def cache_foreign_keys
+          (cache_json_options[:include] || {}).inject({}) do |json, name|
+            reflection = self.class.reflections[name]
+            json.merge cache_foreign_key(name, reflection, send(name))
+          end
+        end
+        def cache_foreign_key(name, reflection, value)
+          case reflection.macro
+          when :belongs_to
+            {:"#{reflection.foreign_key}" => value.try(:id)}
+          when :has_one
+            {:"_#{name.to_s.singularize}_id" => value.try(:id)}
+          when :has_many, :has_and_belongs_to_many
+            {:"_#{name.to_s.singularize}_ids" => value.collect(&:id)}
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cached_record/orm/data_mapper.rb

@@ -0,0 +1,87 @@
+module CachedRecord
+  module ORM
+    module DataMapper
+
+      def self.setup?
+        !!defined?(::DataMapper)
+      end
+
+      def self.setup
+        return false unless setup?
+        ::DataMapper::Resource.class_eval do
+          class << self
+            alias :included_without_cached_record :included
+          end
+          def self.included(base)
+            included_without_cached_record base
+            base.extend ORM::ClassMethods
+            base.extend ClassMethods
+          end
+        end
+        ::DataMapper::Resource.send :include, ORM::InstanceMethods
+        ::DataMapper::Resource.send :include, InstanceMethods
+        true
+      end
+
+      module ClassMethods
+        def uncached(id)
+          get(id)
+        end
+        def new_cached_instance(attributes, foreign_keys, variables)
+          super.tap do |instance|
+            instance.persistence_state = ::DataMapper::Resource::PersistenceState::Clean.new instance
+          end
+        end
+      private
+        def _new_cached_instance_(id, attributes)
+          new attributes.merge(:id => id)
+        end
+        def set_cached_association(instance, key, value)
+          return unless value
+          if relationship = _cache_relationship_(instance, key, value)
+            value = _cache_value_(instance, relationship, value)
+            instance.instance_variable_set relationship.instance_variable_name, value
+          end
+        end
+        def _cache_relationship_(instance, key, value)
+          if key.to_s.match /^_(.*)_ids?/
+            relationships[$1.pluralize.to_sym]
+          else
+            instance.send :"#{key}=", value
+            relationships.detect{|r| r.child_key.first.name.to_s == key.to_s}
+          end
+        end
+        def _cache_value_(instance, relationship, value)
+          if value.is_a? Array
+            value.collect{|x| relationship.child_model.cached x}
+          elsif relationship.is_a?(::DataMapper::Associations::ManyToOne::Relationship)
+            relationship.parent_model.cached value
+          end
+        end
+      end
+
+      module InstanceMethods
+        def cache_attributes
+          (cache_json_options[:only] ? as_json.slice(*cache_json_options[:only]) : as_json).symbolize_keys!.merge cache_foreign_keys
+        end
+        def cache_foreign_keys
+          (cache_json_options[:include] || {}).inject({}) do |json, name|
+            relationship = relationships[name]
+            json.merge cache_foreign_key(name, relationship, send(name))
+          end
+        end
+        def cache_foreign_key(name, relationship, value)
+          case relationship
+          when ::DataMapper::Associations::ManyToOne::Relationship
+            {:"#{relationship.child_key.first.name}" => value.try(:id)}
+          when ::DataMapper::Associations::OneToOne::Relationship
+            {:"_#{name.to_s.singularize}_id" => value.try(:id)}
+          when ::DataMapper::Associations::OneToMany::Relationship, ::DataMapper::Associations::ManyToMany::Relationship
+            {:"_#{name.to_s.singularize}_ids" => value.collect(&:id)}
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cached_record/orm.rb

@@ -0,0 +1,188 @@
+require "cached_record/orm/active_record"
+require "cached_record/orm/data_mapper"
+
+module CachedRecord
+  module ORM
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+
+      def as_cache(*args)
+        @as_cache = parse_as_cache_options args if args.any?
+        @as_cache ||= {:as_json => {}}
+      end
+
+      def as_memoized_cache(*args)
+        retain = args.last.delete(:retain) if args.last.is_a?(Hash)
+        as_cache(*args).tap do |options|
+          options[:memoize] = true
+          options[:retain] = retain if retain
+        end
+      end
+
+      def cache_key(id)
+        "#{name.underscore.gsub("/", ".")}.#{id}"
+      end
+
+      def cache_root
+        "#{name.underscore.gsub(/^.*\//, "")}".to_sym
+      end
+
+      def cached(id)
+        Cache.get(self, id) do
+          uncached id
+        end
+      end
+
+      def uncached(id)
+        raise NotImplementedError, "Cannot fetch uncached `#{self.class}` instances"
+      end
+
+      def load_cache_json(json)
+        json.symbolize_keys!
+        properties, variables = cache_json_to_properties_and_variables(json)
+        foreign_keys, attributes = properties.partition{|k, v| k.to_s.match /_ids?$/}.collect{|x| Hash[x]}
+        new_cached_instance attributes, foreign_keys, variables
+      end
+
+      def new_cached_instance(attributes, foreign_keys, variables)
+        id = attributes.delete(:id) || attributes.delete("id")
+        _new_cached_instance_(id, attributes).tap do |instance|
+          instance.id = id if instance.respond_to?(:id=)
+          foreign_keys.each do |key, value|
+            set_cached_association instance, key, value
+          end
+          variables.each do |key, value|
+            instance.instance_variable_set key, value
+          end
+        end
+      end
+
+    private
+
+      def _new_cached_instance_(id, attributes)
+        new attributes
+      end
+
+      def set_cached_association(instance, key, value)
+        raise NotImplementedError, "Cannot set cached association for `#{self}` instances"
+      end
+
+      def parse_as_cache_options(args)
+        if (symbol = args.first).is_a? Symbol
+          store = symbol
+        end
+        if (hash = args.last).is_a? Hash
+          expire = hash.delete :expire
+          as_json = parse_as_cache_json_options hash
+        end
+        {
+          :store => store,
+          :expire => expire,
+          :as_json => as_json || {}
+        }.reject{|key, value| value.nil?}
+      end
+
+      def parse_as_cache_json_options(options)
+        options.symbolize_keys!
+        validate_as_cache_json_options options
+        {}.tap do |opts|
+          opts[:only] = symbolize_array(options[:only]) if options[:only]
+          opts[:include] = symbolize_array(options[:include]) if options[:include]
+          opts[:memoize] = parse_memoize_options(options[:memoize]) if options[:memoize]
+          opts[:include_root] = true if options[:include_root]
+        end
+      end
+
+      def validate_as_cache_json_options(options)
+        options.assert_valid_keys :only, :include, :memoize, :include_root
+        options.slice(:only, :include).each do |key, value|
+          raise ArgumentError unless value.is_a?(Array)
+        end
+        if options[:memoize] && !options[:memoize].is_a?(Enumerable)
+          raise ArgumentError
+        end
+        if options.include?(:include_root) && ![true, false].include?(options[:include_root])
+          raise ArgumentError
+        end
+      end
+
+      def symbolize_array(array)
+        array.collect &:to_sym
+      end
+
+      def parse_memoize_options(options)
+        [options].flatten.inject({}) do |memo, x|
+          hash = x.is_a?(Hash) ? x : {x => :"@#{x}"}
+          memo.merge hash.inject({}){|h, (k, v)| h[k.to_sym] = v.to_sym; h}
+        end
+      end
+
+      def cache_json_to_properties_and_variables(json)
+        if as_cache[:as_json][:include_root]
+          properties = json.delete cache_root
+          variables = json.inject({}){|h, (k, v)| h[:"@#{k}"] = v; h}
+          [properties, variables]
+        else
+          json.partition{|k, v| !k.to_s.match(/^@/)}.collect{|x| Hash[x]}
+        end
+      end
+
+    end
+
+    module InstanceMethods
+
+      def cache_attributes
+        raise NotImplementedError, "Cannot return cache attributes for `#{self.class}` instances"
+      end
+
+      def cache_foreign_keys
+        raise NotImplementedError, "Cannot return cache foreign keys for `#{self.class}` instances"
+      end
+
+      def as_cache_json
+        attributes = {:id => id}.merge cache_attributes
+        variables = (cache_json_options[:memoize] || {}).inject({}) do |hash, (method, variable)|
+          hash[variable] = send method
+          hash
+        end
+        merge_cache_json attributes, variables
+      end
+
+      def merge_cache_json(attributes, variables)
+        if cache_json_options[:include_root]
+          variables = variables.inject({}){|h, (k, v)| h[k.to_s.gsub(/^@/, "").to_sym] = v; h}
+          {self.class.cache_root => attributes}.merge variables
+        else
+          attributes.merge variables
+        end
+      end
+
+      def to_cache_json
+        as_cache_json.to_json
+      end
+
+      def cache
+        self.class.cached id
+        true
+      end
+
+      def expire
+        Cache.expire self
+        true
+      end
+
+    private
+
+      def cache_json_options
+        self.class.as_cache[:as_json] || {}
+      end
+
+    end
+
+  end
+end

data/lib/cached_record/version.rb

@@ -0,0 +1,7 @@
+module CachedRecord
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 0
+
+  VERSION = [MAJOR, MINOR, TINY].join(".")
+end

data/lib/cached_record.rb

@@ -0,0 +1,22 @@
+require "gem_ext/redis"
+require "cached_record/version"
+require "cached_record/cache"
+require "cached_record/orm"
+
+module CachedRecord
+
+  def self.setup(*args)
+    args.each do |arg|
+      if arg.is_a?(Hash)
+        arg.each do |store, options|
+          Cache.setup store, options
+        end
+      else
+        Cache.setup arg
+      end
+    end
+    ORM::ActiveRecord.setup
+    ORM::DataMapper.setup
+  end
+
+end

data/lib/gem_ext/redis.rb

@@ -0,0 +1,25 @@
+begin
+  require "redis"
+rescue LoadError
+end
+
+class Redis
+
+  alias :set_without_cached_record :set
+  def set(key, value, ttl_or_options = nil)
+    if ttl_or_options.is_a? Integer
+      ttl = ttl_or_options
+      options = {}
+    else
+      options = ttl_or_options || {}
+    end
+    set_without_cached_record(key, value, options).tap do
+      expire key, ttl if ttl
+    end
+  end
+
+  def delete(*args)
+    del *args
+  end
+
+end

data/script/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+Bundler.require :default, :development
+require_relative "setup"
+
+puts "Loading CachedRecord development environment (#{CachedRecord::VERSION})"
+Pry.start

data/script/setup.rb

@@ -0,0 +1,37 @@
+require "yaml"
+require "logger"
+require "active_record"
+
+dbconfig = YAML.load_file(File.expand_path("../../config/database.yml", __FILE__))["development"]
+logger = Logger.new("log/development.log")
+
+ActiveRecord::Base.establish_connection dbconfig
+ActiveRecord::Base.time_zone_aware_attributes = true
+ActiveRecord::Base.default_timezone = :local
+ActiveRecord::Base.logger = logger
+
+CachedRecord.setup :redis
+Redis.new.flushdb
+
+class Article < ActiveRecord::Base
+  belongs_to :author, :class_name => "User"
+  has_many :comments
+  has_and_belongs_to_many :tags
+  as_memoized_cache :only => [:title], :include => [:author, :comments, :tags], :expire => 20.seconds
+end
+
+class User < ActiveRecord::Base
+  has_one :foo, :class_name => "Article", :foreign_key => "foo_id"
+  as_memoized_cache :only => [:name], :include => [:foo]
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :poster, :class_name => "User"
+  as_memoized_cache :only => [:content], :include => [:poster]
+end
+
+class Tag < ActiveRecord::Base
+  has_and_belongs_to_many :articles
+  as_memoized_cache :only => [:name]
+end