redify 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OWI0M2E1ZmYzNzNmYzQ2Y2M0MGI0N2ZjY2Y2MzZhZTgxNjdjMWQyYQ==
+  data.tar.gz: !binary |-
+    ZTNhZjFiOGU5ZDE2ZTNlNjhiN2E4ZTUyNDkwNjY5N2ViNDZjMzdkOQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NWM3MGEyMmQyZTU5ZTMzODY5ZjYwZWM3OWIxN2U2NWIxODA2MDcyMzRkMDZl
+    MDQwYmFjYTM1ZjIxNGQzNzk5ZWE2MzMwYzgyMTQyMjE4YzQ2MzEyZDBkY2Fl
+    YmE5NDU3MDM3N2UxMDU5ZDhiNDViZDk4NDRjYjQwZDNjZTIyNjE=
+  data.tar.gz: !binary |-
+    YzEyYjk2MDAxYjU1NWVlZDAzOWQwNDkxNGI4OTUwNjI4MzdhNDM0N2QwMmJi
+    Yjk3YzM3Njk0OGU1MWQwZWY3NmRhYTA4ODk2NTY0Njk2MmRhNGE0NGIyYThl
+    NDhjYWRlMDNlYjc3ZjUwZTAzYTNiNDBkODI4NmE4NDJiNzQ4ZjY=

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+]
+Z�0�g<�

data.tar.gz.sig

@@ -0,0 +1 @@
+�~��eU��5pe\��&3��*ߔ��

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redify.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Panayotis Procopiou
+
+MIT License
+
+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,173 @@
+# Redify
+
+[![Dependency Status][DS img]][Dependency Status] [![Code Climate](https://codeclimate.com/github/pauloddr/redify.png)](https://codeclimate.com/github/pauloddr/redify)
+
+## State of Code
+
+Redify is currently under development and is not ready for public usage yet.
+
+## Introduction
+
+Redify intends to act as a plug-and-play Redis layer for your ActiveRecord models. By adding the following to your models...
+
+```ruby
+class Foo < ActiveRecord::Base
+  redify
+  # ... rest of your code ...
+end
+```
+... a few common database operations will be done through Redis instead of ActiveRecord, increasing overall speed of queries and decreasing your database server access frequency.
+
+## Considerations
+
+Redify __will increase your server memory usage__, depending on data size that is stored into Redis. It will also likely increase the boot time of your application, since Redify loads all data into Redis upon model initialization. Please keep those in mind when using this gem.
+
+
+## Requirements
+
+Instead of directly connecting into Redis itself, Redify requires an already connected handler that responds to Redis commands (like `get`, `hmget`, etc), so it is not restricted to a specific Redis client.
+
+It works best with models which primary keys are either numeric or strings without any special characters, since they are used to compose key names in Redis.
+
+Redify requires ActiveSupport ~> 3.0.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'redify', :git => 'git://github.com/pauloddr/redify.git'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redify
+
+
+## Setting Up
+
+You can set up default options in `Redify::Settings` in your initializer scripts. The following example assumes you have defined a `$redis` variable elsewhere in your application pointing to a handler that responds to Redis commands:
+
+```ruby
+Redify::Settings.default_handler = $redis
+```
+
+You can define a namespace to be prepended to every key handled by Redify. By default, this namespace equals to `"Redify"` unless you set this option. A couple examples for Rails applications:
+
+```ruby
+# MyApplication:production:*
+Redify::Settings.namespace = "#{Rails.application.name}:#{Rails.env}"
+
+# MyApplication:1.2.0:*
+Redify::Settings.namespace = "#{Rails.application.name}:#{Rails.configuration.assets.version}" 
+```
+
+## Redis Structure
+
+Considering a model called `User` and an empty namespace, Redify will automatically generate the following keys in Redis when you "redify" a model:
+
+- `Users` - a hash with extended data about the model with the following fields:
+  - `field_names` - a string with a comma-separated, ordered list of field names.
+  - `field_types` - a string with a comma-separated, ordered list of field types. Possible values are: `string`, `number`, `float`, `date`, `datetime` and `boolean`.
+  - `associations` - a string with a comma-separated list of associations that are "redified' for the model.
+  - `redify_status` - internal status of model "redification". Possible values are `"LOADING"` and `"READY"`.
+- `Users:All` - an ordered list of primary keys from Users.
+- `User:N` (for each record) - an hash containing information about a single record, where `N` is the record primary key.
+
+When you throw in an associated model called `Post`, where `user has_many posts`, you also get:
+
+- `Posts`
+- `Posts:All`
+- `Post:N` (for each record)
+- `User:N:Posts` (for each `User`) - an ordered list of Post IDs that belong to `User#N`.
+
+
+## Operations
+
+Redify will use Redis for the following common operations:
+
+- `User.all`
+- `User.find N`
+- `User.first(n)` and `User.last(n)`
+- `User#Posts` (associations)
+
+Redify will fall back to ActiveRecord on more complex queries until it works with more finders and options.
+
+
+## Initialization Options
+
+Upon "redification" of a model, you can pass some extended options.
+
+### `:with_associations => [...]`
+
+```ruby
+class User < ActiveRecord::Base
+  has_many :posts
+  redify :with_associations => [:posts]
+  # ...
+end
+```
+
+You can also pass `:all` instead of an array of associations to always redify all associations.
+
+### `:through => <redis_handler>`
+
+Redify will use the default Redis handler passed to `Redify::Settings.default_handler` unless you specify this option. Namespace rules still apply to all Redis instances in use.
+
+
+## Finder Options
+
+### `:skip_redify => true`
+
+Example:
+```ruby
+User.all :skip_redify => true
+```
+
+Use this option if for some reason you want to go straight to ActiveRecord.
+
+### `:as => :hash`
+
+Example:
+```ruby
+User.all :as => :hash
+```
+
+Redify will return raw hashes instead of ActiveRecord models. This will yield the fastest speeds. Use this if you can affort not relying on ActiveRecord instances. 
+
+If the model has any redified associations, they will be available as an array of IDs. For example, when an user has many posts and they're included in the query (as in, `:include => :posts`), its hash will return as:
+
+```ruby
+{id: 1, name: "...", ..., post_ids: [1, 2, 3,...]}
+```
+
+## Scalability and Maintenance
+
+Redify is intended to work with multiple servers running multiple spawns of the same application, all sharing the same Redis connection. Data integrity is kept tight through a solid namespace composition and some under-the-hood work (keep reading) within the gem. That way, Redis can work as a large pool of data serving multiple applications in the same or different servers.
+
+To make sure multiple instances don't interfere with each other, Redify sets a root-level namespace in Redis called `RedifyApps`, followed by the server hostname, and finally the application namespace. This structure is then used to keep track of all processes running Redify applications. It maintains itself on demand by running a sanity check upon application boot, deleting old keys from applications that are no longer being used by any active processes.
+
+
+## Wishlist (TODO)
+
+In no particular order...
+
+- make it work with more finders
+- implement a simple index system with tags (a.k.a. "poor man's elastic search")
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[Dependency Status]: https://gemnasium.com/pauloddr/redify
+
+[DS img]: https://gemnasium.com/pauloddr/redify.png

data/Rakefile

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

data/lib/redify.rb

@@ -0,0 +1,12 @@
+require 'active_support/concern'
+
+require "redify/version"
+require "redify/settings"
+require "redify/core"
+require "redify/base"
+require "redify/model"
+require "redify/application"
+
+Redify::Settings.set_default_options
+
+ActiveRecord::Base.__send__(:include, Redify::Base)

data/lib/redify/application.rb

@@ -0,0 +1,44 @@
+require 'socket'
+
+module Redify
+
+  class Application
+
+    class << self
+
+      def install
+        return false unless installable?
+        p, n, h = get_data
+        h.sadd("#{p}", n)
+        h.sadd("#{p}:#{n}:PIDs", $$)
+      end
+
+      def uninstall
+        p, n, h = get_data
+        h.srem("#{p}", n)
+        h.srem("#{p}:#{n}:PIDs", $$)
+        true
+      end
+
+      private
+
+      def prefix
+        "RedifyApps:#{Socket.gethostname}"
+      end
+
+      def installable?
+        _, n, h = get_data
+        n && h
+      end
+
+      # returns prefix, namespace and handler
+      def get_data
+        [prefix, Redify::Settings.namespace, Redify::Settings.default_handler]
+      end
+
+
+    end
+
+  end
+
+end

data/lib/redify/base.rb

@@ -0,0 +1,35 @@
+module Redify
+  module Base
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # Call this from an ActiveRecord model to activate Redify features.
+      def redify(options = {})
+        
+        # includes main Redify functionality
+        __send__ :include, Redify::Model
+
+        # Redis handler for the model, if specified
+        __send__ :redify_handler=, options[:through]
+        
+        # caches some keys to avoid unnecessary calls to get_*_key_name_for() methods
+        __send__ :redify_keys=, {
+          :resource => Redify::Core.get_namespaced_key_name_for(:resource => self),
+          :all => Redify::Core.get_namespaced_key_name_for(:resource => self, :collection => "All")
+        }
+
+        # load data into Redis for the first time
+        Redify::Core.initialize_resource(self)
+
+        # hooks
+        after_create lambda { Redify::Core.after_create(self) }
+        after_save lambda { Redify::Core.after_save(self) }
+        after_destroy lambda { Redify::Core.after_destroy(self) }
+
+      end
+
+    end
+  end
+end

data/lib/redify/core.rb

@@ -0,0 +1,140 @@
+module Redify
+  class Core
+    class << self
+      
+      # Valid options:
+      #   :resource - ActiveRecord model class (User)
+      #   :collection - camel-cased string denoting collection name
+      #   :record - a single record instance (User.find 1)
+      def get_namespaced_key_name_for(options)
+        key_name = get_key_name_for(options)
+        namespace = Redify::Settings.namespace
+        namespace ? "#{namespace}:#{key_name}" : key_name
+      end
+
+      # Returns the key name without the namespace.
+      def get_key_name_for(options)
+        if options[:collection]
+          get_key_name_for_collection(options)
+        elsif options[:record]
+          get_key_name_for_record(options[:record])
+        elsif options[:resource] && options[:id]
+          get_key_name_for_resource_and_id(options)
+        elsif options[:resource]
+          get_key_name_for_resource(options[:resource])
+        end
+      end
+
+      def get_key_name_for_collection(options)
+        key_name = get_key_name_for_resource(options[:resource])
+        if options[:collection] == "All"
+          key_name << ":All"
+        else
+          key_name << ":Collections:#{options[:collection]}"
+        end
+      end
+
+      def get_key_name_for_record(record)
+        "#{record.class.name}:#{record.id}"
+      end
+
+      def get_key_name_for_resource(resource)
+        "#{ActiveSupport::Inflector.pluralize(resource.to_s)}"
+      end
+
+      def get_key_name_for_resource_and_id(options)
+        "#{options[:resource].to_s}:#{options[:id]}"
+      end
+
+      # Valid options:
+      #   :resource - ActiveRecord model class (User)
+      #   :id - record primary key
+      def fetch_record(options)
+
+        resource = options[:resource]
+
+        return nil unless resource
+        return resource.find(options[:id], :skip_redify => true) unless resource.redify_handler # Redis is unavailable
+        return synchronize(:resource => resource, :id => options[:id])
+
+      end
+
+      # fetch first or last N entries
+      def fetch_records_by_edge(resource, last = false, count = 1)
+        # TODO implement COUNT
+        edge_id = redify_handler.lindex resource.redify_keys[:all], (last ? -1 : 0)
+        edge_id ? Redify::Core.fetch_record(:resource => resource, :id => edge_id) : nil
+      end
+
+      # Loads all records into Redis upon initialization
+      def initialize_resource(resource)
+
+        redis = resource.redify_handler
+        resource_status = redis.hget(resource.redify_keys[:resource], 'status')
+
+        if resource_status == "READY"
+          puts "[Redify] Resource #{resource} is already loaded."
+        elsif resource_status == 'LOADING'
+          puts "[Redify] Resource #{resource} is being loaded by another process."
+        else
+          puts "[Redify] Initializing resource #{resource}"
+          redify_all_records(resource, redis)
+          puts "... finished"
+        end
+
+      end
+
+      def redify_all_records(resource, redis)
+        flush_keys(resource)
+        resource_key = resource.redify_keys[:resource]
+        redis.hset(resource_key, 'status', 'LOADING')
+        resource.find(:all, :skip_redify => true).each do |r|
+          redify_record(r)
+          redis.rpush(redify_keys[:all], r.id)
+        end
+        # TODO load associations and scopes
+        redis.hset(resource_key, 'status', 'READY')
+      end
+
+      # Turns an ActiveRecord instance into a Redis entry.
+      # Updates Redis entry if it already exists.
+      def redify_record(record)
+        key = Redify::Core.get_namespaced_key_name_for(:record => record)
+        record.class.redify_handler.hmset(key, record.attributes.to_a.flatten)
+        puts "[Redify] #{record.class}\##{record.id} redified"
+        return record
+      end
+
+      # Callbacks for Redified models
+
+      def after_create(record)
+        record.class.redify_handler.rpush record.class.redify_keys[:all], record.id
+      end
+
+      def after_save(record)
+        redify_record record
+      end
+
+      def after_destroy(record)
+        puts "after_destroy"
+        puts record.inspect
+      end
+
+      # Deletes all Redis keys under current namespace
+      def flush_keys(resource = nil)
+        namespace = Redify::Settings.namespace
+        redis = Redify::Settings.default_handler
+        pattern = "#{namespace}:"
+        pattern << "#{resource}" if resource
+        pattern << "*"
+        redis.keys(pattern).each do |key|
+          redis.del(key)
+        end
+        # namespace is also a key by itself
+        redis.del(namespace) unless resource
+      end
+
+
+    end
+  end
+end

data/lib/redify/model.rb

@@ -0,0 +1,55 @@
+module Redify
+  module Model
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      attr_accessor :redify_keys
+
+      def redify_handler
+        @redify_handler || Redify::Settings.default_handler
+      end
+      attr_writer :redify_handler
+
+      def find (*args)
+
+        if args.size > 0 && args.last.is_a?(Hash)
+          # let ActiveRecord deal with queries with extended options, including :skip_redify
+          args.last.delete(:skip_redify)
+          return super(*args)
+        end
+
+        a = args.at(0)
+        return send(a) if a == :first || a == :last || a == :all
+
+        records = []
+        
+        args.each do |id|
+          records << Redify::Core.fetch_record(:resource => self, :id => id)
+        end
+
+        args.size == 1 ? records.first : records
+
+      end
+
+      def first (*args)
+        Redify::Core.fetch_records_by_edge(self, false, args.first)
+      end
+
+      def last (*args)
+        Redify::Core.fetch_records_by_edge(self, true, args.first)
+      end
+
+      def all (*args)
+        records = []
+        redify_handler.lrange(redify_keys[:all], 0, -1).each do |record_id|
+          records << Redify::Core.fetch_record(:resource => self, :id => record_id)
+        end
+        records
+      end
+
+    end
+
+  end
+end

data/lib/redify/settings.rb

@@ -0,0 +1,39 @@
+module Redify
+
+  class Settings
+
+    class << self
+
+      attr_accessor :always_redify_associations, :raise_redis_errors
+      attr_reader :namespace
+
+      def namespace=(value)
+        return @namespace if @namespace == value
+        # remoces old namespace install
+        Redify::Application.uninstall
+        @namespace = value
+        Redify::Application.install
+      end
+
+      def set_default_options
+        # silently falls back to ActiveRecord when Redis is unavailable
+        raise_redis_errors = false
+
+        # only redify associations when specified
+        always_redify_associations = false
+
+        # default namespace
+        namespace = "Redify"
+      end
+
+      def default_handler=(handler)
+        @default_handler = handler
+        Redify::Application.install
+      end
+      attr_reader :default_handler
+
+    end
+
+  end
+
+end

data/lib/redify/version.rb

@@ -0,0 +1,3 @@
+module Redify
+  VERSION = "0.0.1"
+end

data/pauloddr-public.pem

@@ -0,0 +1,21 @@
+-----BEGIN CERTIFICATE-----
+MIIDhTCCAm2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMRYwFAYDVQQDDA1wYW5h
+LmVzcXVpdmVsMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJk/IsZAEZ
+FgNjb20wHhcNMTMxMDE4MTc1MTQyWhcNMTQxMDE4MTc1MTQyWjBEMRYwFAYDVQQD
+DA1wYW5hLmVzcXVpdmVsMRUwEwYKCZImiZPyLGQBGRYFZ21haWwxEzARBgoJkiaJ
+k/IsZAEZFgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDVfvUK
+4fm49UsGoYQl9uzMR49I2sNCPvuP9sNTkQ0MoTqIRTWtMtDwTWwr1ecdyCEK7Yba
+qW9veJ5wGKLHAE7Gblev3VpCl/JpLZ+RXjVZmYpb0tt77bumTd5GHNX8RS0VOggd
+kVaaBdECCquIir7ZzfRQzBHA2Fu5aR3r83wbiYtUX5WKHanq8xlSTvngtCeOs71j
+RLEg5a1+29iOtaOjyxKa7kzYvGpSOPmGtd/Fog8AQePUGO9H5R6gTKqSyfzH2Hv9
+q39LxTdbDUFlkSEKARoUqQkJ5fggRRyVnybqwixve8uQl3Ic8TmhoJQqEnPyiN6Z
+8yS2cVBCxzvepeIdAgMBAAGjgYEwfzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAd
+BgNVHQ4EFgQUS1qsU97VgO7r+8/fl12UubiKPYIwIgYDVR0RBBswGYEXcGFuYS5l
+c3F1aXZlbEBnbWFpbC5jb20wIgYDVR0SBBswGYEXcGFuYS5lc3F1aXZlbEBnbWFp
+bC5jb20wDQYJKoZIhvcNAQEFBQADggEBANKPXO84hY8Ih2SFZWrFhsd8MgbIP4ws
+GgJSduxmFLZ5IEQ5Emo0kGqrjoAgaQZ/zn75thdGihFdiyAK7yWCK8UqfFjub3gn
+T5HHcypkAlNArYKVGz+FV/P4kwivsW9zVdtprLR9RybA0NGQGWtIhSRk56zlSmXt
+mfCnq1LJdUiawssF9DrsPoi4uJUbkBMuLpslLiT4zGKuzmgm6ZeTDF6YKzF9sGSM
+25/9vufSQ+z5rRCRjBZ9k+8h3QPuCzQkfmmkUsA6HsX6Hnx9+bpFWp72u47wEQkk
+wKGToyzSzsBlAE7/zMwjWxIVuIDaZQfAiJ7pU8rqWpw1PcUDrNfZW2g=
+-----END CERTIFICATE-----

data/redify.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redify/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redify"
+  spec.version       = Redify::VERSION
+  spec.authors       = ["Paulo Procopiou"]
+  spec.email         = ["pana.esquivel@gmail.com"]
+  spec.description   = %q{Redis layer for ActiveRecord models}
+  spec.summary       = %q{Adds a Redis layer to some ActiveRecord finders}
+  spec.homepage      = "https://github.com/pauloddr/redify"
+  spec.license       = "MIT"
+
+  spec.cert_chain  = ['pauloddr-public.pem']
+  spec.signing_key = File.expand_path("~/.gemcert/pauloddr-private.pem")
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "redis"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "simplecov"
+ 
+  spec.add_runtime_dependency "activesupport", "~> 3.0"
+  spec.add_runtime_dependency "activerecord", "~> 3.0"
+  
+
+end

data/spec/redify/core_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Redify::Core do
+
+  let (:record) { User.find 1, :skip_redify => true }
+  let (:namespace) { Redify::Settings.namespace }
+
+  describe '.get_namespaced_key_name_for' do
+    subject { lambda {|options| Redify::Core.get_namespaced_key_name_for(options) } }
+    it { expect(subject.call(:resource => User, :collection => "All")).to eq("#{namespace}:Users:All") }
+    it { expect(subject.call(:resource => User, :collection => "OtherStuff")).to eq("#{namespace}:Users:Collections:OtherStuff") }
+    it { expect(subject.call(:record => record)).to eq("#{namespace}:User:1") }
+    it { expect(subject.call(:resource => User, :id => 1)).to eq("#{namespace}:User:1") }
+  end
+
+  describe '.get_key_name_for' do
+    subject { lambda {|options| Redify::Core.get_key_name_for(options) } }
+    it { expect(subject.call(:resource => User, :collection => "All")).to eq("Users:All") }
+    it { expect(subject.call(:resource => User, :collection => "OtherStuff")).to eq("Users:Collections:OtherStuff") }
+    it { expect(subject.call(:record => record)).to eq("User:1") }
+    it { expect(subject.call(:resource => User, :id => 1)).to eq("User:1") }
+  end
+
+  describe '.get_key_name_for_collection' do
+    subject { lambda {|options| Redify::Core.get_key_name_for_collection(options) } }
+    it { expect(subject.call(:resource => User, :collection => "All")).to eq("Users:All") }
+    it { expect(subject.call(:resource => User, :collection => "OtherStuff")).to eq("Users:Collections:OtherStuff") }
+  end
+
+  describe '.get_key_name_for_record' do
+    subject { lambda {|record| Redify::Core.get_key_name_for_record(record) } }
+    it { expect(subject.call(record)).to eq("User:1") }
+  end
+
+  describe '.get_key_name_for_resource_and_id' do
+    subject { lambda {|options| Redify::Core.get_key_name_for_resource_and_id(options) } }
+    it { expect(subject.call(:resource => User, :id => 1)).to eq("User:1") }
+  end
+
+end

data/spec/redify_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Redify do
+  
+  it "includes itself properly" do
+    expect(User.respond_to?(:redify_handler)).to be_true
+    expect(Post.respond_to?(:redify_handler)).to be_true
+    expect(Dummy.respond_to?(:redify_handler)).to be_false
+  end
+
+  it "creates Redis keys upon model initialization" do
+    expect(User.redify_handler.exists(User.redify_keys[:all])).to be_true
+    expect(Post.redify_handler.exists(Post.redify_keys[:all])).to be_true
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'simplecov'
+SimpleCov.start
+
+require 'support/active_record'
+require 'redify'         # needs activerecord
+require 'support/redis'
+require 'support/models' # needs redify + redis
+
+
+RSpec.configure do |config|
+  #config.treat_symbols_as_metadata_keys_with_true_values = true
+  #config.run_all_when_everything_filtered = true
+  #config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  #config.order = 'random'
+
+  config.after(:suite) do
+    # clean up
+    Redify::Core.flush_keys
+    Redify::Application.uninstall
+  end
+
+end

data/spec/support/active_record.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => ":memory:"
+
+ActiveRecord::Migration.verbose = false
+
+ActiveRecord::Migration.create_table :users do |t|
+  t.string   :name
+  t.integer  :post_count
+  t.datetime :created_at, :null => false
+  t.datetime :updated_at, :null => false
+end
+
+ActiveRecord::Migration.create_table :posts do |t|
+  t.integer  :user_id
+  t.string   :title
+  t.text     :content
+  t.datetime :created_at, :null => false
+  t.datetime :updated_at, :null => false
+end
+
+# This table won't use Redify
+ActiveRecord::Migration.create_table :dummies do |t|
+  t.string   :name
+  t.integer  :user_id
+  t.datetime :created_at, :null => false
+  t.datetime :updated_at, :null => false
+end

data/spec/support/models.rb

@@ -0,0 +1,24 @@
+class User < ActiveRecord::Base
+  redify
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  redify
+  belongs_to :user
+end
+
+class Dummy < ActiveRecord::Base
+  # no Redify for you
+  belongs_to :user
+end
+
+# Seeds
+
+User.create(:name => "User 1").posts.create(:title => "Post by User 1")
+User.create(:name => "User 2").posts.create(:title => "Post by User 2", :content => "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Etiam quis dolor magna. Donec tortor lectus, venenatis at rhoncus ut, condimentum non neque. Sed sit amet porta velit. Fusce porta augue nec sem tempor ornare. Curabitur eu tempus mi. Nunc venenatis laoreet risus, id malesuada erat vulputate at. In aliquet mi nisi, at ornare dolor venenatis eu.")
+User.create(:name => "User 3")
+User.create(:name => "User 4").posts.create(:title => "Post by User 4")
+User.create(:name => "User 5")
+
+Post.create(:title => "Another Post by User 1", :user_id => 1)

data/spec/support/redis.rb

@@ -0,0 +1,4 @@
+require 'redis'
+
+Redify::Settings.default_handler = Redis.new
+Redify::Settings.namespace = "RedifyTest_#{Time.now.to_i}"

metadata

@@ -0,0 +1,213 @@
+--- !ruby/object:Gem::Specification
+name: redify
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Paulo Procopiou
+autorequire: 
+bindir: bin
+cert_chain:
+- !binary |-
+  LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURoVENDQW0yZ0F3SUJB
+  Z0lCQVRBTkJna3Foa2lHOXcwQkFRVUZBREJFTVJZd0ZBWURWUVFEREExd1lX
+  NWgKTG1WemNYVnBkbVZzTVJVd0V3WUtDWkltaVpQeUxHUUJHUllGWjIxaGFX
+  d3hFekFSQmdvSmtpYUprL0lzWkFFWgpGZ05qYjIwd0hoY05NVE14TURFNE1U
+  YzFNVFF5V2hjTk1UUXhNREU0TVRjMU1UUXlXakJFTVJZd0ZBWURWUVFECkRB
+  MXdZVzVoTG1WemNYVnBkbVZzTVJVd0V3WUtDWkltaVpQeUxHUUJHUllGWjIx
+  aGFXd3hFekFSQmdvSmtpYUoKay9Jc1pBRVpGZ05qYjIwd2dnRWlNQTBHQ1Nx
+  R1NJYjNEUUVCQVFVQUE0SUJEd0F3Z2dFS0FvSUJBUURWZnZVSwo0Zm00OVVz
+  R29ZUWw5dXpNUjQ5STJzTkNQdnVQOXNOVGtRME1vVHFJUlRXdE10RHdUV3dy
+  MWVjZHlDRUs3WWJhCnFXOXZlSjV3R0tMSEFFN0dibGV2M1ZwQ2wvSnBMWitS
+  WGpWWm1ZcGIwdHQ3N2J1bVRkNUdITlg4UlMwVk9nZ2QKa1ZhYUJkRUNDcXVJ
+  aXI3WnpmUlF6QkhBMkZ1NWFSM3I4M3diaVl0VVg1V0tIYW5xOHhsU1R2bmd0
+  Q2VPczcxagpSTEVnNWExKzI5aU90YU9qeXhLYTdrell2R3BTT1BtR3RkL0Zv
+  ZzhBUWVQVUdPOUg1UjZnVEtxU3lmekgySHY5CnEzOUx4VGRiRFVGbGtTRUtB
+  Um9VcVFrSjVmZ2dSUnlWbnlicXdpeHZlOHVRbDNJYzhUbWhvSlFxRW5QeWlO
+  NloKOHlTMmNWQkN4enZlcGVJZEFnTUJBQUdqZ1lFd2Z6QUpCZ05WSFJNRUFq
+  QUFNQXNHQTFVZER3UUVBd0lFc0RBZApCZ05WSFE0RUZnUVVTMXFzVTk3VmdP
+  N3IrOC9mbDEyVXViaUtQWUl3SWdZRFZSMFJCQnN3R1lFWGNHRnVZUzVsCmMz
+  RjFhWFpsYkVCbmJXRnBiQzVqYjIwd0lnWURWUjBTQkJzd0dZRVhjR0Z1WVM1
+  bGMzRjFhWFpsYkVCbmJXRnAKYkM1amIyMHdEUVlKS29aSWh2Y05BUUVGQlFB
+  RGdnRUJBTktQWE84NGhZOEloMlNGWldyRmhzZDhNZ2JJUDR3cwpHZ0pTZHV4
+  bUZMWjVJRVE1RW1vMGtHcXJqb0FnYVFaL3puNzV0aGRHaWhGZGl5QUs3eVdD
+  SzhVcWZGanViM2duClQ1SEhjeXBrQWxOQXJZS1ZHeitGVi9QNGt3aXZzVzl6
+  VmR0cHJMUjlSeWJBME5HUUdXdEloU1JrNTZ6bFNtWHQKbWZDbnExTEpkVWlh
+  d3NzRjlEcnNQb2k0dUpVYmtCTXVMcHNsTGlUNHpHS3V6bWdtNlplVERGNllL
+  ekY5c0dTTQoyNS85dnVmU1ErejVyUkNSakJaOWsrOGgzUVB1Q3pRa2ZtbWtV
+  c0E2SHNYNkhueDkrYnBGV3A3MnU0N3dFUWtrCndLR1RveXpTenNCbEFFNy96
+  TXdqV3hJVnVJRGFaUWZBaUo3cFU4cnFXcHcxUGNVRHJOZlpXMmc9Ci0tLS0t
+  RU5EIENFUlRJRklDQVRFLS0tLS0K
+date: 2013-10-18 00:00:00.000000000 Z
+dependencies:
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: redis
+  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: 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: simplecov
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Redis layer for ActiveRecord models
+email:
+- pana.esquivel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/redify.rb
+- lib/redify/application.rb
+- lib/redify/base.rb
+- lib/redify/core.rb
+- lib/redify/model.rb
+- lib/redify/settings.rb
+- lib/redify/version.rb
+- pauloddr-public.pem
+- redify.gemspec
+- spec/redify/core_spec.rb
+- spec/redify_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/models.rb
+- spec/support/redis.rb
+homepage: https://github.com/pauloddr/redify
+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.6
+signing_key: 
+specification_version: 4
+summary: Adds a Redis layer to some ActiveRecord finders
+test_files:
+- spec/redify/core_spec.rb
+- spec/redify_spec.rb
+- spec/spec_helper.rb
+- spec/support/active_record.rb
+- spec/support/models.rb
+- spec/support/redis.rb

metadata.gz.sig

@@ -0,0 +1 @@
+���2n�����4��٘0F�4Hy2*�
���w�pY�i�p�SWΌ�J��(鏗�2@Gz�+1iL]�4��o,G��g)Ι1�?�^�^tۂ^,���v�Ǿ�iH�gu]������Z�����X��?��%C�T������%�vq��4?���Ur� ��_LE|,r��8Yn�,$�\��IHh���.AIb��9�kvZ�&��(��41aq���=p:NJ���������?��r�i�U�+�۵f