lion-attr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34d61bee3070595310ca92f1f1ef9256aaebe603
+  data.tar.gz: ac04beac1d6b6bcacfabfe81583e5259f05fea54
+SHA512:
+  metadata.gz: 31280e75824539ab18df77a855c69b20d4f54ec23c945beca643f1e264bb444b5e8b450d8c47852f94fb46db50b145829599fe24c98e30222e140b66ac962f6f
+  data.tar.gz: 40b783f03ea499fef042d7596ac9d9f1dad11fae3bc997907dd5ad83df47229b3317207d59d47f2f97883a155dea584d7c44a90a2d7092e4633a11ba4cb2b304

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 Victor Tran
+
+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/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'LionAttr'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/lion_attr.rb

@@ -0,0 +1,262 @@
+require_relative 'lion_attr/internal_redis'
+require_relative 'lion_attr/config'
+require_relative 'lion_attr/bson'
+
+# LionAttr, a gem to store Mongoid object in Redis for fast access. It also helps
+# you to store object attributes to real time update via Redis increamental
+# operations.
+#
+# In many web applications, updating objects to database (mongodb) too often
+# would hurt overal application performance because databases usually need to
+# do some extra tasks such as indexing, updating its cache ...
+#
+# One of the most popular example for this problem is tracking pageview of a web
+# page. Imagine if you have a blog and you want to know how many time people visit
+# a specific article, what would you do? An obvious way to do so is whenever a
+# person make a request, you increase the record holding pageview counter by using
+# `mongoid#inc` method. Doing this is not a good idea because it increases database
+# calls making your application slower.
+#
+# A better solution for this problem is to keep the pageview counter in memory
+# (which is fast) key-value storage such as Redis. Instead of increasing the
+# counter by the database, we increase the counter inside Redis and save back to
+# the database later (like after 10 mins, 30 mins or even a day).
+#
+# LionAttr provides APIs for you to do so with ease.
+#
+# That counter is usually an attribute of a Model object, the difference is that
+# attribute will get the value from Redis instead of the database. We call it live
+# attribute because it tends update its value very frequently.
+#
+# @example
+#
+#  class Article
+#    include Mongoid::Document
+#    include LionAttr
+#    field :url, type: String
+#    field :view, type: Integer
+#
+#    # field :view will be stored in Redis and saved back to Mongodb later
+#    live :view
+#  end
+#
+# @todo: Cache object
+# @todo:       Custom key
+# @todo: Inc
+# @todo: Callbacks
+# @todo: Configure
+#
+# @since 0.1.0
+#
+# @see http://tranvictor.github.io/lion_attr
+
+module LionAttr
+
+  # Including LionAttr will set an after save callback to update the object cache
+  # in Redis.
+  #
+  # @param base Mongoid::Document
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.set_callback(:save, :after, :update_to_redis, prepend: true)
+  end
+
+  # Key to store in Redis, it is combined by object identity and field name.
+  #
+  # @param [String, Symbol] field
+  # @return [String]
+  # @example
+  #   article.key(:view)
+  #   #=> 54d5f10d5675730bd1050000_view
+  #
+  #   article.url = "http://clicklion.com/article/1"
+  #   article.class.live_key = :url
+  #   article.key(:view)
+  #   #=> http://clicklion.com/article/1_view
+  #
+  # @see ClassMethods#live_key Object Identity definition
+  def key(field)
+    self.class._key(self.send(self.class.live_key), field)
+  end
+
+  # Call this method to manually create a cache of the object in Redis.
+  # It will store the object as a json string in a Redis Hash with key is the
+  # object's id. Object from different classes will be stored in different hashes
+  # distinguished by class full name.
+  #
+  # @see InternalRedis
+  def update_to_redis
+    InternalRedis.new(self.class.name).set(id, as_document.to_json)
+  end
+
+  # Call this method will clear all of Redis keys related to the object.
+  def clean_cache_after_destroy
+    @live_keys ||= self.class.live_fields.map { |f| key(f) }
+    @internal_redis ||= InternalRedis.new(self.class.name)
+    @internal_redis.del @live_keys
+    @internal_redis.del id
+  end
+
+  module ClassMethods
+
+    # Fetch the object specified with an id from Redis. It will not touch the
+    # database (Mongdb). If that object is not available on Redis or invalid (due to
+    # model changes, it will make a query to the database (Mongodb).
+    #
+    # @param [String] id
+    # @return [Mongoid::Document]
+    def fetch(id)
+      @internal_redis ||= InternalRedis.new(name)
+      string_object = @internal_redis.get(id)
+      if string_object.nil?
+        object = _fetch_from_db(id)
+      else
+        object = new(JSON.load(string_object))
+      end
+    rescue Mongoid::Errors::UnknownAttribute
+      object = _fetch_from_db(id)
+    end
+
+    # Query the object by id, and create a cache version in Redis.
+    #
+    # @param [String] id
+    # @return [Mongoid::Document]
+    def _fetch_from_db(id)
+      object = find(id)
+      @internal_redis.set(id, object.as_document.to_json)
+      object
+    end
+
+    # Get all live fields of the class
+    #
+    # @example
+    #   article.class.live_fields
+    #   #=> [:view]
+    def live_fields
+      @live_fields
+    end
+
+    def live(*fields)
+      fields.each do |field|
+        generate_fetch_cache_method(field)
+        # generate_set_cache_method(field)
+      end
+      generate_update_db_method(fields)
+      generate_incr_method
+      (@live_fields ||= []).push(*fields)
+      set_callback(:destroy, :after, :clean_cache_after_destroy)
+    end
+
+    # Specify the field which is used to get storage key for the object.
+    #
+    # @param [String, Symbole] field
+    # @example
+    #   article.class.live_key = :url
+    #   # Whenever LionAttr need to use object key, it gets from :url
+    def live_key=(field)
+      @key = field
+    end
+
+    # Get object key to interact with Redis. If you don't specify the live_key
+    # :id will be used by default.
+    def live_key
+      @key || :id
+    end
+
+    def generate_update_db_method(_fields)
+      define_method('update_db') do
+        @live_keys ||= self.class.live_fields.map { |f| key(f) }
+        @internal_redis ||= InternalRedis.new(self.class.name)
+        redis_values = @internal_redis.mget(@live_keys)
+        self.class.live_fields.each_with_index do |f, i|
+          if read_attribute(f) != redis_values[i]
+            write_attribute(f, redis_values[i])
+          end
+        end
+        # TODO: This could be improved by using batch save instead of saving
+        # individual document
+        save
+      end
+    end
+
+    def _key(id, field)
+      "#{id}_#{field}"
+    end
+
+    # Increase live attributes value in Redis. If the live attributes are not
+    # Integer nor Float, a String message will be returned. Otherwise, increased
+    # value will be returned.
+    #
+    # @param [String] id
+    # @param [String, Symbol] field
+    # @param [Integer] increment
+    # @param [InternalRedis] internal_redis
+    #
+    # @return [Integer, Float, String]
+    def incr(id, field, increment = 1, internal_redis = nil)
+      unless self.live_fields.include?(field)
+        fail "#{field} is not a live attributes"
+      end
+      internal_redis ||= InternalRedis.new(name)
+      _incr(_key(id, field), fields[field.to_s].type,
+            @internal_redis, increment) do
+        find(id).read_attribute(field)
+      end
+    rescue => e
+      e.message
+    end
+
+    def _incr(key, type, internal_redis = nil, increment = 1, &block)
+      internal_redis ||= InternalRedis.new(name)
+      if block && !internal_redis.exists(key)
+        internal_redis.setnx key, block.call
+      end
+      if type == Integer
+        internal_redis.incrby(key, increment)
+      elsif type == Float
+        internal_redis.incrbyfloat(key, increment)
+      else
+        'ERR hash value is not a number'
+      end
+    end
+
+    def generate_incr_method
+      define_method('incr') do |field, increment = 1|
+      begin
+        unless self.class.live_fields.include?(field)
+          fail "#{field} is not a live attributes"
+        end
+        @internal_redis ||= InternalRedis.new(self.class.name)
+        self.class._incr(key(field),
+                         fields[field.to_s].type,
+                         @internal_redis,
+                         increment) { read_attribute(field) }
+      rescue => e
+        e.message
+      end
+      end
+    end
+
+    def generate_fetch_cache_method(name)
+      re_define_method("#{name}") do
+        @internal_redis ||= InternalRedis.new(self.class.name)
+        raw = @internal_redis.get(key(name))
+        field = fields[name.to_s]
+        if raw.nil?
+          raw = read_attribute(name)
+          if lazy_settable?(field, raw)
+            value = write_attribute(name, field.eval_default(self))
+          else
+            value = field.demongoize(raw)
+            attribute_will_change!(name) if value.resizable?
+          end
+
+          @internal_redis.set(key(name), raw)
+        else
+          value = field.demongoize(raw)
+        end
+        value
+      end
+    end
+  end
+end

data/lib/lion_attr/bson.rb

@@ -0,0 +1,11 @@
+module BSON
+  class ObjectId
+    def to_json(*_args)
+      to_s.to_json
+    end
+
+    def as_json(*_args)
+      to_s.as_json
+    end
+  end
+end

data/lib/lion_attr/config.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module LionAttr
+
+  # This module defines all the configuration options for LionAttr
+  module Config
+    def redis_config=(options)
+      @redis_config = options
+      RedisPool.instance.update_pool
+    end
+
+    def redis_config
+      @redis_config ||= {}
+    end
+
+    extend self
+  end
+
+  module ModuleInterface
+    # Sets the LionAttr configuration options. Best used by passing a block.
+    # You should configure before actually using LionAttr.
+    #
+    # @example Set up configuration options and tell LionAttr to store everything in
+    # redis datababse 13
+    #
+    #   LionAttr.configure do |config|
+    #     config.redis_config = { db: 13 }
+    #   end
+    #
+    # @return [ Config ] The configuration object.
+    #
+    # @since 0.1.0
+    def configure
+      block_given? ? yield(::LionAttr::Config) : ::LionAttr::Config
+    end
+  end
+  extend ModuleInterface
+end

data/lib/lion_attr/internal_redis.rb

@@ -0,0 +1,46 @@
+require_relative 'redis_pool'
+
+module LionAttr
+  class InternalRedis
+    def initialize(hash_name)
+      @hash_name = hash_name
+    end
+
+    def get(key)
+      redis.with { |c| c.hget @hash_name, key }
+    end
+
+    def set(key, value)
+      redis.with { |c| c.hset @hash_name, key, value }
+    end
+
+    def exists(key)
+      redis.with { |c| c.hexists @hash_name, key }
+    end
+
+    def del(key)
+      redis.with { |c| c.hdel @hash_name, key }
+    end
+
+    def setnx(key, value)
+      redis.with { |c| c.hsetnx @hash_name, key, value }
+    end
+
+
+    def incrby(key, increment)
+      redis.with { |c| c.hincrby @hash_name, key, increment }
+    end
+
+    def incrbyfloat(key, increment)
+      redis.with { |c| c.hincrbyfloat @hash_name, key, increment }
+    end
+
+    def mget(keys)
+      redis.with { |c| c.hmget @hash_name, keys }
+    end
+
+    def redis
+      RedisPool.instance
+    end
+  end
+end

data/lib/lion_attr/redis_pool.rb

@@ -0,0 +1,25 @@
+require 'singleton'
+require 'redis'
+require 'connection_pool'
+
+module LionAttr
+  class RedisPool
+    include Singleton
+
+    def initialize
+      update_pool
+    end
+
+    def update_pool
+      @pool = ConnectionPool.new(size: 100, timeout: 2) do
+        puts ::LionAttr.configure.redis_config
+        Redis.new ::LionAttr.configure.redis_config
+      end
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+  end
+end

data/lib/lion_attr/version.rb

@@ -0,0 +1,3 @@
+module LionAttr
+  VERSION = "0.1.0"
+end

data/lib/tasks/lion_attr_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :lion_attr do
+#   # Task goes here
+# end

data/spec/config_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe LionAttr do
+  it 'can be configured via #configuree by passing a block' do
+    LionAttr.configure do |config|
+      config.redis_config = { :a => 1 }
+    end
+
+    expect(LionAttr::Config.redis_config[:a]).to eq 1
+  end
+
+  describe "#configure" do
+    it 'returns config object' do
+      expect(LionAttr.configure).to be LionAttr::Config
+    end
+  end
+end

data/spec/lion_attr_spec.rb

@@ -0,0 +1,290 @@
+require 'spec_helper'
+
+class TestRedis
+  include Mongoid::Document
+  field :foo, type: Integer
+  field :bar, type: Integer
+  field :mew, type: Float
+  field :baz, type: Float
+  field :qux, type: String
+  include LionAttr
+  live :foo, :bar, :mew, :qux
+end
+
+describe LionAttr do
+  before(:each) do
+    @test = TestRedis.new
+    @redis = LionAttr::InternalRedis.new(@test.class.name)
+  end
+
+  describe "class#incr" do
+    before(:each) do
+      @test.save
+    end
+
+    it 'defines an incr method on the class' do
+      expect(@test.class).to respond_to(:incr)
+    end
+
+    it 'should change attribute value in redis' do
+      @test.foo = 0
+      @redis.set(@test.key(:foo), 0)
+      expect(@redis.get(@test.key(:foo))).to eq(@test.foo.to_s)
+      TestRedis.incr(@test.id, :foo, 10)
+      expect(@redis.get(@test.key(:foo))).not_to eq((@test.foo + 10).to_s)
+    end
+
+    it 'should work fine if the attribute is not initialized to redis yet' do
+      @test.foo = 50
+      @test.save
+      TestRedis.incr @test.id, :foo, 1
+      expect(@test.foo).to eq 51
+    end
+
+    it 'should not be affected by fetch' do
+      @test.foo = 0
+      @test.save
+      @test.incr :foo, 10
+      @new_test = TestRedis.fetch(@test.id)
+      TestRedis.incr @test.id, :foo, 10
+      expect(@new_test.foo).to eq 20
+    end
+
+    it 'should return attribute value in redis' do
+      expect(TestRedis.incr(@test.id, :foo,
+                            10).to_s).to eq(@redis.get(@test.key(:foo)))
+    end
+
+    it 'should rescue error by return error message' do
+      #increase integer field by float increment
+      err_msg = "ERR value is not an integer or out of range"
+      expect(TestRedis.incr(@test.id, :foo, 10.0)).to eq(err_msg)
+
+      #increase float field by string
+      err_msg = 'ERR value is not a valid float'
+      expect(TestRedis.incr(@test.id, :mew, 'a')).to eq(err_msg)
+
+      #increase string field
+      err_msg = 'ERR hash value is not a number'
+      expect(TestRedis.incr(@test.id, :qux, 10)).to eq(err_msg)
+    end
+
+    it 'should set default value for increment is 1' do
+      @redis.set(@test.key(:foo), 0)
+      TestRedis.incr @test.id, :foo
+      expect(@redis.get(@test.key(:foo))).to eq(1.to_s)
+    end
+
+    it 'should raise exception when incr not live attribute' do
+      err_msg = 'baz is not a live attributes'
+      expect(@test.incr(:baz)).to eq(err_msg)
+    end
+  end
+
+  describe 'more methods' do
+    it 'should generate method to fetch attributes value from cache' do
+      expect(@test).to respond_to(:foo)
+      expect(@test).to respond_to(:foo=)
+      expect(@test).to respond_to(:bar)
+      expect(@test).to respond_to(:bar=)
+      expect(@test).to respond_to(:update_db)
+      expect(@test).to respond_to(:incr)
+      expect(@test.class).to respond_to(:fetch)
+      expect(@test.class).to respond_to(:live_fields)
+    end
+  end
+
+  describe 'callback' do
+    it 'should set callback function' do
+      expect(@test).to receive(:clean_cache_after_destroy)
+      @test.destroy
+    end
+
+    it 'should remove live attribute in redis if object was destroy' do
+      @redis.set(@test.key(:foo), 10)
+      @redis.set(@test.key(:bar), 10)
+      @test.destroy
+      expect(@redis.get(@test.key(:foo))).to eq(nil)
+      expect(@redis.get(@test.key(:bar))).to eq(nil)
+    end
+
+    it 'should remove object in redis if object was destroyed' do
+      id = @test.id
+      @test.save
+      @test.class.fetch(id)
+      expect(@redis.get(id)).to eq(@test.as_document.to_json)
+      @test.destroy
+      expect(@redis.get(id)).to eq(nil)
+    end
+  end
+
+  describe '#fetch' do
+    it 'should return object if it exist in redis' do
+      @redis.set(@test.id, @test.as_document.to_json)
+      expect(@test.class.fetch(@test.id)).to eq(@test)
+    end
+
+    it 'should set object in to redis in case not exist in redis yet' do
+      id = @test.id
+      expect(@redis.get(id)).to eq(nil)
+      @test.save
+      @test.class.fetch(id)
+      expect(@redis.get(id)).to eq(@test.as_document.to_json)
+    end
+
+    it 'should return updated object if original was updated' do
+      @test.save
+      @old_test = TestRedis.fetch(@test.id)
+      @test.update(:baz => 100)
+      @updated_test = TestRedis.fetch(@test.id)
+      expect(@updated_test.baz).to eq 100
+    end
+
+    it 'should be ok if the model is changed while cached object
+    is still available, it will refetch from db if the cached version is invalid' do
+      @test.save
+      document = @test.as_document
+      document['will_be_removed'] = 10
+      json_data = document.to_json
+      @redis.set(@test.id, json_data)
+      expect { @new_test = TestRedis.fetch(@test.id) }.not_to raise_error
+    end
+  end
+
+  describe '#key' do
+    it 'should contain object id and field name' do
+      expect(@test.key(:foo)).to eq("#{@test.id}_foo")
+      puts @test.key(:foo)
+    end
+  end
+
+  describe '#update_db' do
+    it 'should update mongodb record if attribute value
+    is difference from redis' do
+      @test.incr(:foo, 10)
+      expect(@redis.get(@test.key(:foo))).not_to eq(@test.read_attribute(:foo).to_s)
+      @test.update_db
+      expect(@redis.get(@test.key(:foo))).to eq(@test.read_attribute(:foo).to_s)
+    end
+  end
+
+  describe 'live attributes' do
+    it 'can be called multiple times' do
+      class TestMultipleLive
+        include Mongoid::Document
+        include LionAttr
+        field :foo, type: Integer
+        live :foo
+        field :bar, type: Integer
+        live :bar
+        include LionAttr
+      end
+      expect(TestMultipleLive.live_fields).to include(:foo, :bar)
+      @test = TestMultipleLive.new
+      expect(@test).to receive(:update_to_redis).exactly(1).times
+      @test.save
+    end
+
+    context 'custom key' do
+      it 'has default key of :id but can be assigned to other field' do
+        class TestCustomKey
+          include Mongoid::Document
+          include LionAttr
+          field :foo, type: Integer
+          live :bar
+        end
+        expect(TestCustomKey.live_key).to eq :id
+        TestCustomKey.class_eval do
+          self.live_key = :bar
+        end
+        expect(TestCustomKey.live_key).to eq :bar
+      end
+
+      it 'should change the key to save to redis' do
+        class TestCustomKey1
+          include Mongoid::Document
+          include LionAttr
+          field :foo, type: Integer
+          field :bar
+          live :bar
+          self.live_key = :foo
+        end
+        @instance = TestCustomKey1.new :foo => 100
+        expect(@instance.key(:bar)).to eq "100_bar"
+      end
+    end
+
+    describe '#incr' do
+      it 'should change attribute value in redis' do
+        @test.foo = 0
+        @redis.set(@test.key(:foo), 0)
+        expect(@redis.get(@test.key(:foo))).to eq(@test.foo.to_s)
+        @test.incr(:foo, 10)
+        expect(@redis.get(@test.key(:foo))).not_to eq((@test.foo + 10).to_s)
+      end
+
+      it 'should work fine if the attribute is not initialized to redis yet' do
+        @test.foo = 50
+        @test.save
+        @test.incr :foo, 1
+        expect(@test.foo).to eq 51
+      end
+
+      it 'should not be affected by fetch' do
+        @test.foo = 0
+        @test.save
+        @test.incr :foo, 10
+        @new_test = TestRedis.fetch(@test.id)
+        @new_test.incr :foo, 10
+        expect(@new_test.foo).to eq 20
+      end
+
+      it 'should return attribute value in redis' do
+        expect(@test.incr(:foo, 10).to_s).to eq(@redis.get(@test.key(:foo)))
+      end
+
+      it 'should rescue error by return error message' do
+        #increase integer field by float increment
+        err_msg = "ERR value is not an integer or out of range"
+        expect(@test.incr(:foo, 10.0)).to eq(err_msg)
+
+        #increase float field by string
+        err_msg = 'ERR value is not a valid float'
+        expect(@test.incr(:mew, 'a')).to eq(err_msg)
+
+        #increase string field
+        err_msg = 'ERR hash value is not a number'
+        expect(@test.incr(:qux, 10)).to eq(err_msg)
+      end
+
+      it 'should set default value for increment is 1' do
+        @redis.set(@test.key(:foo), 0)
+        @test.incr(:foo)
+        expect(@redis.get(@test.key(:foo))).to eq(1.to_s)
+      end
+
+      it 'should raise exception when incr not live attribute' do
+        err_msg = 'baz is not a live attributes'
+        expect(@test.incr(:baz)).to eq(err_msg)
+      end
+    end
+
+    describe '#getter' do
+      it 'should read attribute value from db
+      in case the value is not exist in redis' do
+        # redis not contain attribute value
+        expect(@redis.get(@test.key(:foo))).to eq(nil)
+        # fetch cache still return attribute value
+        expect(@test.foo).to eq(@test.read_attribute(:foo))
+        # redis should contain attribute value now
+        expect(@redis.get(@test.key(:foo))).to eq(@test.foo.to_s)
+      end
+
+      it 'should return attribute value from redis if it exist in redis' do
+        @test.foo = 10
+        @redis.set(@test.key(:foo), 20)
+        expect(@test.foo).to eq(20)
+      end
+    end
+  end
+end

data/spec/lion_attr_with_custom_configuration_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe LionAttr do
+
+  describe "configuration" do
+    it "can be configured to specific redis config" do
+      LionAttr.configure do |config|
+        puts "setting configuration"
+        config.redis_config = { :db => 13 }
+      end
+
+      class TestClass
+        include Mongoid::Document
+        include LionAttr
+        field :foo, type: Integer
+
+        live :foo
+      end
+
+      @test = TestClass.new
+      @test.save
+      redis = Redis.new :db => 13
+      expect(redis.exists "TestClass").to be true
+    end
+  end
+end

data/spec/mongoid.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: lion_attr_test
+      hosts:
+        - localhost:27017

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require 'bundler/setup'
+Bundler.setup
+
+require 'mongoid'
+
+Mongoid.load!("#{File.dirname(__FILE__)}/mongoid.yml", :test)
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+require 'lion_attr'
+
+RSpec.configure do |config|
+  config.order = :random
+
+  config.color = true
+
+  config.tty = true
+
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: lion-attr
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Victor Tran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: LionAttr uses Redis to store Mongoid object in-mem giving it fast accessibility.
+  It also gives convenience to manipulate numeric attributes which will be called
+  live attrbutes. With live attributes, you can increase, decrease database for high
+  performance.
+email:
+- vu.tran54@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/lion_attr.rb
+- lib/lion_attr/bson.rb
+- lib/lion_attr/config.rb
+- lib/lion_attr/internal_redis.rb
+- lib/lion_attr/redis_pool.rb
+- lib/lion_attr/version.rb
+- lib/tasks/lion_attr_tasks.rake
+- spec/config_spec.rb
+- spec/lion_attr_spec.rb
+- spec/lion_attr_with_custom_configuration_spec.rb
+- spec/mongoid.yml
+- spec/spec_helper.rb
+homepage: http://github.com/tranvictor
+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.4.3
+signing_key: 
+specification_version: 4
+summary: LionAttr gives convenience of caching Mongoid objects and increase counter
+  without touching database.
+test_files:
+- spec/config_spec.rb
+- spec/lion_attr_spec.rb
+- spec/lion_attr_with_custom_configuration_spec.rb
+- spec/mongoid.yml
+- spec/spec_helper.rb
+has_rdoc: