activeredis 0.0.3

data/.gitignore

@@ -0,0 +1,18 @@
+*.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 documentation

data/Gemfile

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

data/README.markdown

@@ -0,0 +1,68 @@
+# ActiveRedis
+
+ActiveModel based object persisting library for [Redis](http://code.google.com/p/redis) key-value database.
+
+## Features
+
+* ActiveModel compatibility
+* Race condition free operations
+
+## Missing features
+
+A lot. ActiveRedis is currently designed to handle concurrency issues.  Use [OHM](http://ohm.keyvalue.org/) or [remodel](http://github.com/tlossen/remodel) if you need advanced features and can accept some potential concurrency issues.
+
+* Indexes
+* Relations
+* Other cool stuff
+
+## How to start
+
+1. Clone the repository
+3. Install gems 
+
+    bundle install
+
+4. Run spec
+
+    rspec spec/core_spec.rb
+
+## Sample Code
+
+    require 'active_redis'
+    require 'pp'
+    
+    class User < ActiveRedis::Base
+      fields :name, :age, :country
+    end
+
+     create user(1)
+     user = User.new :age => 22, :name => "Joe"
+     user.save
+    
+     # create user(2)
+     user = User.new
+     user.age = 12
+     user.name = "Tom"
+     user.country = "japan"
+     user.save
+    
+     puts "count: #{User.count}" #=> 2
+     pp joe = User.find_by_name("Joe") #=>#<User:0x0000010193e930 @attributes={"age"=>"22", "name"=>"Joe"}, @id="1">
+     pp tom = User.find_by_age(12) #=>#<User:0x00000101910c60 @attributes={"age"=>"12", "name"=>"Tom", "country"=>"japan"}, @id="2">
+    
+     joe.destroy
+     puts "count: #{User.count}" #=> 1
+    
+     tom.destroy
+     puts "count: #{User.count}" #=> 0
+    
+     pp User.find_by_name("Tom") #=> nil
+    
+     User.delete_all
+
+
+## Contributing
+
+Pull requests are welcome!
+
+For any questions contact [yamadakazu45@gmail.com](mailto:yamadakazu45@gmail.com)

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/activeredis-console.rb

@@ -0,0 +1,4 @@
+class Cat < ActiveRedis::Base
+  
+end
+

data/activeredis.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'activeredis/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "activeredis"
+  gem.version       = ActiveRedis::VERSION
+  gem.authors       = ["Kazuhiro Yamada", "Yuta Hirakawa"]
+  gem.email         = ["sonixlabs@sonix.asia", "kyamada@sonix.asia"]
+  gem.description   = %q{ActiveModel based object persistance library for Redis}
+  gem.summary       = %q{ActiveModel based object persisting library for Redis key-value database.}
+  gem.homepage      = "https://github.com/sonixlabs/activeredis"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency 'redis'
+  gem.add_dependency 'activemodel'
+  gem.add_development_dependency 'rspec'
+end

data/benchmark.rb

@@ -0,0 +1,61 @@
+$LOAD_PATH << File.dirname(__FILE__) 
+require 'benchmark'
+require 'lib/active_redis'
+
+class Post < ActiveRedis::Base
+
+end
+
+
+LOREM = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+
+# Returns 0 if first round, otherwise return offset which is the sum 
+# of previous rounds.
+def calculate_offset(index, rounds)
+  return (index == 0) ? 0 : rounds[0..index-1].inject{|sum,x| sum +x}
+end
+
+Benchmark.bm(26) do |x|
+
+  rounds = [1000,5000,10000]
+
+  rounds.each_with_index do |howmany, index|
+
+    x.report("Create #{howmany} posts: ") do
+      howmany.times do |t|
+        p = Post.new({ :topic => "a"*(8+rand(55)),
+                     :author => "a"*(8+rand(55)),
+                     :content => LOREM*(8+rand(55))})
+        p.save
+      end
+    end
+
+    x.report("Count posts: ") do
+      Post.count
+    end
+
+    x.report("Find posts: ") do
+      howmany.times do |t|
+        p = Post.find(calculate_offset(index, rounds)+t+1)
+      end
+    end
+
+    x.report("Update (find+save) posts: ") do
+      howmany.times do |t|
+        p = Post.find(calculate_offset(index, rounds)+t+1)
+        p.save
+      end
+    end
+
+    x.report("Delete posts: ") do
+      howmany.times do |t|
+        p = Post.find(calculate_offset(index, rounds)+t+1)
+        p.destroy
+      end
+    end
+
+    puts
+  end
+
+end
+

data/benchmark_results.txt

@@ -0,0 +1,19 @@
+                                user     system      total        real
+Create 1000 posts:          0.350000   0.110000   0.460000 (  0.708575)
+Count posts:                0.000000   0.000000   0.000000 (  0.000095)
+Find posts:                 0.180000   0.040000   0.220000 (  0.301364)
+Update (find+save) posts:   0.420000   0.140000   0.560000 (  0.845421)
+Delete posts:               0.310000   0.080000   0.390000 (  0.479831)
+
+Create 5000 posts:          1.760000   0.560000   2.320000 (  3.553861)
+Count posts:                0.000000   0.000000   0.000000 (  0.000091)
+Find posts:                 0.900000   0.210000   1.110000 (  1.509994)
+Update (find+save) posts:   2.140000   0.680000   2.820000 (  4.263500)
+Delete posts:               1.490000   0.390000   1.880000 (  2.368327)
+
+Create 10000 posts:         3.500000   1.100000   4.600000 (  7.094810)
+Count posts:                0.000000   0.000000   0.000000 (  0.000092)
+Find posts:                 1.840000   0.420000   2.260000 (  3.062314)
+Update (find+save) posts:   4.250000   1.350000   5.600000 (  8.498068)
+Delete posts:               3.040000   0.790000   3.830000 (  4.838310)
+

data/lib/activeredis/version.rb

@@ -0,0 +1,3 @@
+module ActiveRedis
+  VERSION = "0.0.3"
+end

data/lib/activeredis.rb

@@ -0,0 +1,325 @@
+require 'redis'
+require 'time'
+require 'active_model'
+
+require 'active_model/version'
+
+class Module
+  def module_attr_reader(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        @@#{sym} = nil unless defined?(@@#{sym})
+        def self.#{sym}()
+          return @@#{sym}
+        end
+      EOS
+    end
+  end
+  def module_attr_writer(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  def module_attr_accessor(*syms)
+    module_attr_reader(*syms)
+    module_attr_writer(*syms)
+  end
+end
+
+module ActiveRedis
+  module_attr_accessor :host, :port
+  @@host = "localhost"
+  @@port = "6379"
+
+  class ActiveRedisError < StandardError
+  end
+  
+  # Raised when Active Redis cannot find record by given id or set of ids.
+  class RecordNotFound < ActiveRedisError
+  end
+  
+  class Base
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Naming
+
+    QUEUED = "QUEUED"
+    
+    # RAILSISM
+    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values
+    #  --> means: Strings as keys!
+    #  --> initialize stringifies
+    #
+    #  called by to_json for_example
+    attr_reader :attributes
+    attr_reader :id
+    attr :frozen
+
+    class << self; attr_accessor :_fields; end
+    
+    # INSTANCE METHODS
+    
+    def initialize(attributes = {}, id = nil)
+      @id = id if id
+      @attributes = {}
+      initialize_attributes(attributes)
+      frozen = false
+    end
+    
+    # Object's attributes' keys are converted to strings because of railsisms.
+    # Because of activeredisism, also values are converted to strings for consistency.
+    def initialize_attributes(attributes)
+      fields = Hash[[self.class._fields, Array.new(self.class._fields.size)].transpose]
+      fields.stringify_keys!   # NEEDS to be strings for railsisms
+      attributes.stringify_keys!   # NEEDS to be strings for railsisms
+      attributes.each_pair { |key, value| attributes[key] = value.to_s }
+      fields.merge!(attributes)
+      @attributes.merge!(fields)
+      @attributes.each_pair do |key, value|
+        self.class.define_field key
+      end
+    end
+
+    def save
+      creation = new_record?
+      @id = self.class.fetch_new_identifier if creation
+      while true
+        begin
+          connection.multi
+        rescue
+          sleep(0.1)
+          redo
+        end
+        break
+      end
+      if @attributes.size > 0  
+        @attributes.each_pair { |key, value|
+          if key.to_sym == :updated_at
+            value = Time.now.to_s
+          end
+          connection.hset("#{key_namespace}:attributes", key, value)
+        }
+      end
+      connection.zadd("#{class_namespace}:all", @id, @id) 
+      connection.exec
+      return true
+    end
+
+    def update_attributes(attributes)
+      attributes.stringify_keys!   # NEEDS to be strings for railsisms
+      attributes.each_pair { |key, value| attributes[key] = value.to_s }
+      @attributes.merge!(attributes)
+      attributes.each_pair do |key, value|
+        self.class.define_field key
+      end
+      save
+    end
+
+    def reload
+      @attributes = connection.hgetall "#{key_namespace}:attributes"
+    end
+    
+    def new_record?
+      @id == nil
+    end
+    
+    def key_namespace
+      "#{self.class.key_namespace}:#{self.id}"
+    end
+    
+    def class_namespace
+      "#{self.class.key_namespace}"
+    end
+    
+    def connection
+      self.class.connection
+    end
+
+    def destroy
+      connection.multi do
+        connection.del "#{key_namespace}:attributes"
+        connection.zrem "#{class_namespace}:all", @id
+        @frozen = true
+      end
+      return true     
+    end
+
+    def frozen?
+      @frozen
+    end
+    
+    def add_attribute(name, value=nil)
+      initialize_attributes({name => value})
+    end
+
+    def [](field)
+      send(field)
+    end
+  
+    def []=(field, value)
+      send(field+"=", value)
+    end
+    
+    #
+    # CLASS METHODS
+    #
+
+    def self.create(attributes)
+      self.new(attributes).save
+    end
+    
+    def self.define_field(field)
+      define_method field.to_sym do
+        if field.to_sym == :updated_at
+          Time.parse(@attributes["#{field}"])
+        else
+          @attributes["#{field}"]  
+        end
+      end
+
+      define_method "#{field}=".to_sym do |new_value|
+        @attributes["#{field}"] = new_value.to_s
+      end
+    end
+
+    # Run this method to declare the fields of your model.
+    def self.fields(*fields)
+      self._fields ||= []
+      self._fields = fields
+    end
+
+    def self.get_fields
+      self._fields
+    end
+
+    def self.key_namespace
+      "#{self}"
+    end
+    
+    def self.fetch_new_identifier
+      self.connection.incr self.identifier_sequencer
+    end
+    
+    def self.identifier_sequencer
+      "#{key_namespace}:sequence"
+    end
+    
+    def self.inherited(child)
+      #puts "Redis.new(:host => #{ActiveRedis.host}, :port => #{ActiveRedis.port})"
+      @@redis = Redis.new(:host => ActiveRedis.host, :port => ActiveRedis.port)
+      @@class = child
+    end
+    
+    def self.redis_information
+      connection.info # call_command [:info]
+    end
+    
+    def self.connection
+      @@redis
+    end
+
+    def self.count
+      begin
+        size = connection.zcard "#{key_namespace}:all"
+        while size == QUEUED
+          sleep(0.1)
+          size = connection.zcard "#{key_namespace}:all"
+        end
+        return size
+      rescue RuntimeError => e
+        return 0
+      end
+    end
+
+    def self.find_all()
+      record = []
+      # TODO Interim fix, "QUEUED" is find(id) rescue
+      while true
+        ids = connection.zrange "#{key_namespace}:all", 0, count
+        while ids == QUEUED 
+          sleep(0.1)
+          ids = connection.zrange "#{key_namespace}:all", 0, count
+        end
+        begin
+          ids.each do |id|
+            record << find(id)
+          end
+        rescue
+          redo
+        end
+        break
+      end
+      record
+    end
+
+    def self.all
+      find_all
+    end
+
+    def self.delete_all
+      records = find_all
+      records.each do |record|
+        record.destroy
+      end
+    end
+
+    def self.find(id)
+      return find_all if id == :all
+      exists = connection.zscore "#{key_namespace}:all", id
+      raise RecordNotFound.new("Couldn't find #{self.name} with ID=#{id}") unless exists
+      attributes = connection.hgetall "#{key_namespace}:#{id}:attributes"
+      obj = self.new attributes, id
+      return obj
+    end
+
+    def self.find_all_by_param(field, value)
+      finded = []
+      records = find_all
+      records.each do |record|
+        if record.attributes[field.to_s] == value.to_s
+          finded << record
+        end
+      end
+      return finded
+    end
+
+    def self.find_by_param(field, value)
+      records = find_all_by_param(field, value)
+      if records.size > 0
+        return records[0]
+      else
+        nil
+      end
+    end
+
+    def self.method_missing(name, *args)
+      return find_by_param($1.to_sym, args[0]) if name.to_s =~ /^find_by_(.*)/
+      return find_all_by_param($1.to_sym, args[0]) if name.to_s =~ /^find_all_by_(.*)/
+      super
+    end
+    
+    def self.delete_unused_field
+      ids = connection.zrange "#{key_namespace}:all", 0, count
+      if ids.size > 0
+        attributes = connection.hgetall "#{key_namespace}:#{ids[0]}:attributes"
+        now_keys   = self.get_fields
+        array = []
+        now_keys.each do |key|
+          array << key.to_s
+        end
+        attributes.reject! {|key| array.include? key }
+        attributes.keys.each do |delete_key|
+          ids.each do |id|
+            connection.hdel "#{key_namespace}:#{id}:attributes", delete_key
+          end
+        end
+      end
+    end
+  end
+end

data/sample/user.rb

@@ -0,0 +1,38 @@
+require 'active_redis'
+require 'pp'
+
+# ActiveRedis.host = "localhost"
+# ActiveRedis.port = "6379"
+class User < ActiveRedis::Base
+  fields "name", "age", "country", "updated_at"
+end
+
+# create user(1)
+user = User.new :age => 22, :name => "Joe"
+user.save
+
+# create user(2)
+user = User.new
+user.age = 12
+user.name = "Tom"
+user.country = "japan"
+user.save
+
+puts "count: #{User.count}" #=> 2
+pp joe = User.find_by_name("Joe") #=>#<User:0x0000010193e930 @attributes={"age"=>"22", "name"=>"Joe"}, @id="1">
+pp tom = User.find_by_name("Tom") #=>#<User:0x00000101910c60 @attributes={"age"=>"12", "name"=>"Tom", "country"=>"japan"}, @id="2">
+
+tom.update_attributes({:age => 20})
+#tom = User.find_by_age(20)
+tom.reload
+pp tom
+
+joe.destroy
+puts "count: #{User.count}" #=> 1
+
+User.delete_all
+puts "count: #{User.count}" #=> 0
+
+pp User.find_by_name("Tom") #=> nil
+
+

data/spec/active_redis_spec.rb

@@ -0,0 +1,264 @@
+require 'spec_helper'
+
+class Cat < ActiveRedis::Base
+  fields :name, :age
+end
+
+class Dog < ActiveRedis::Base
+  fields :category, :name, :color
+end
+
+describe Cat do
+
+  before(:each) do
+    ActiveRedis::Base.connection.flushall
+    @cat = Cat.new(:name => "lol")
+    @dog = Dog.new(:category => "Dachshund")
+  end
+
+  it "should be a rektive model" do
+    Cat.ancestors.should include(ActiveRedis::Base)
+  end
+  
+  it "should give out info on the redis server" do
+    Cat.redis_information.should be_an_instance_of(Hash)
+  end
+  
+  describe "counting" do
+    it "should know count of its objects when empty" do
+      Cat.count.should == 0
+    end
+
+    it "should know count of its objects" do
+       @cat.save
+       Cat.count.should == 1
+    end
+  end
+  
+  describe "attributes" do
+    
+    it "should have attributes" do
+      @cat.attributes.should include("name")
+    end
+  
+    it "should have accessors for all attributes" do
+      @cat.name.should == "lol"
+    end
+
+    it "should get fields" do
+      Cat.get_fields.should == [:name, :age]
+    end
+     
+    it "should stringify all values" do
+      numeric_cat = Cat.new(:age => 25, :length => 5.4)
+      numeric_cat.age.should == "25"
+      numeric_cat.length.should == "5.4"
+    end
+
+    it "should add a new attribute to a persisted object" do
+      @cat.save
+      @cat.add_attribute(:color)
+      @cat.color.should == ""
+    end
+
+    it "should add a new attribute with empty value and persist changes" do
+      @cat.save
+      @cat.add_attribute(:color)
+      @cat.color.should == ""
+      @cat.save
+      Cat.find(@cat.id).color.should == ""
+    end
+
+    it "should add a new attribute with non-empty value and persist changes" do
+      @cat.save
+      @cat.add_attribute(:color, "black")
+      @cat.color.should == "black"
+      @cat.save
+      Cat.find(@cat.id).color.should == "black"
+    end
+    
+    it "should add a new attribute with a value" do
+      @cat.add_attribute(:color, "black")
+      @cat.color.should == "black"
+    end
+    
+    it "should add a new attribute to a non-persisted object" do
+      cat = Cat.new(:name => "long")
+      cat.add_attribute(:length, 2.5)
+      cat.length.should == "2.5"
+    end
+
+    it "should update a attribute" do
+      cat = Cat.new(:name => "mike", :color => "black")
+      cat.update_attributes({:name => "tama"})
+      cat.reload
+      cat.name.should == "tama"
+      cat.color.should == "black"
+    end
+    
+    it "should convert attribute values to string when creating new" do
+      cat = Cat.new(:age => 2.5, :long => true, :length => 100)
+      cat.attributes["age"].should == "2.5"
+      cat.attributes["long"].should == "true"
+      cat.attributes["length"].should == "100"
+    end
+
+    it "should create persisted object" do
+      Cat.create(:age => 100, :long => true, :length => 120)
+      Cat.find_by_age(100).age.should == "100"
+    end
+    
+  end
+  
+  describe "persisting simple objects" do
+    before(:each) do
+      @cat = Cat.new(:name => "lol",
+                     :color => "white")
+    end
+    
+    it "should persist a simple object successfully" do
+      @cat.save.should be_true
+    end
+    
+    it "should have a key to fetch the next free identifier from" do
+      Cat.identifier_sequencer.should == "Cat:sequence"
+    end
+    
+    it "should reserve a unique identifier for the object" do
+      Cat.connection.should_receive(:incr).with(Cat.identifier_sequencer).and_return(1)
+      
+      Cat.fetch_new_identifier
+    end
+    
+    it "should save the identifier to the object" do
+      @cat.save
+      
+      @cat.id.should_not be_nil
+    end
+    
+#    it "should persist the attributes of the object" do
+#      Cat.stub!(:fetch_new_identifier).and_return(1)
+#      Cat.connection.stub!(:multi).and_yield
+#
+#      Cat.connection.should_receive(:call_command).with([ "hmset",
+#                                                          "#{Cat.key_namespace}:1:attributes",
+#                                                          "name", "lol",
+#                                                          "color", "white"]).and_return(true)
+#
+#      Cat.connection.should_receive(:zadd).with("#{Cat.key_namespace}:all", 1, 1).and_return(true)
+#      
+#      @cat.save
+#    end
+    
+#    it "should have atomic save operations" do
+#      Cat.stub!(:fetch_new_identifier)
+#      Cat.connection.should_receive(:multi).and_yield
+#      Cat.connection.should_receive(:call_command)
+#      Cat.connection.should_receive(:zadd)
+#      @cat.save
+#    end
+    
+    it "should persist attributeless cat" do
+      attributeless = Cat.new
+      attributeless.save
+      
+      attributeless.id.should_not be_nil
+    end
+    
+    
+    
+  end
+
+  describe "destroy" do
+    it "object should remove itself" do
+      @cat.save
+      
+      @cat.destroy.should == true
+      lambda {
+        Cat.find(@cat.id)
+      }.should raise_error(ActiveRedis::RecordNotFound)
+
+    end
+    
+    it "should destroy as an atomic operation" do
+      dead_cat = Cat.new({}, 1)
+      Cat.connection.should_receive(:multi).and_yield
+      Cat.connection.should_receive(:del).with("#{Cat.key_namespace}:1:attributes").and_return(10)
+      Cat.connection.should_receive(:zrem).with("#{Cat.key_namespace}:all", 1).and_return(1)
+      dead_cat.destroy.should == true
+    end
+    
+  end
+  
+  describe "find" do
+    
+    it "should raise error if record was not found" do
+      no_such_cat_id = 99
+      lambda { 
+        Cat.find(no_such_cat_id)
+      }.should raise_error(ActiveRedis::RecordNotFound)
+      
+    end
+    
+    it "should check that object exists in all" do
+      @cat.save
+      Cat.find(1)
+    end
+    
+    it "should find existing cat" do
+      attributes_to_persist = {"name" => "", "age" => "", "fur" => "long", "eyes" => "blue"}
+      c = Cat.new attributes_to_persist
+      c.save
+      
+      same_cat = Cat.find(c.id)
+      same_cat.attributes.should == attributes_to_persist
+    end
+    
+    it "should have id set" do
+      @cat.save
+      
+      existing_cat = Cat.find(1)
+      existing_cat.id.should == 1
+    end
+
+    it "should find attributeless cat" do
+      attributeless = Cat.new
+      attributeless.save
+      Cat.find(attributeless.id).should_not be_nil
+    end
+
+  end
+  
+  describe "update" do
+    
+    it "should not create new objects when updating" do
+      same_cat = Cat.new
+      same_cat.save
+      id_before_save = same_cat.id
+      
+      same_cat.save
+      same_cat.id.should == id_before_save
+    end
+    
+    it "should update attribute with new value" do
+      
+      @cat.save
+      
+      new_name = "updated lolcat"
+      @cat.name = new_name 
+      @cat.save
+      Cat.find(@cat.id).name.should == new_name
+      
+    end
+
+  end
+  
+  
+  describe "ActiveModel compatibility" do
+  
+    it "should respond to new_record?" do
+      Cat.new.new_record?.should == true
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'activeredis' # and any other gems you need
+
+RSpec.configure do |config|
+  config.before(:each) do
+    ActiveRedis::Base.connection.flushall
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: activeredis
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Kazuhiro Yamada
+- Yuta Hirakawa
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70240177908780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70240177908780
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: &70240177908360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70240177908360
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70240177907940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70240177907940
+description: ActiveModel based object persistance library for Redis
+email:
+- sonixlabs@sonix.asia
+- kyamada@sonix.asia
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- README.markdown
+- Rakefile
+- activeredis-console.rb
+- activeredis.gemspec
+- benchmark.rb
+- benchmark_results.txt
+- lib/activeredis.rb
+- lib/activeredis/version.rb
+- sample/user.rb
+- spec/active_redis_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/sonixlabs/activeredis
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: ActiveModel based object persisting library for Redis key-value database.
+test_files:
+- spec/active_redis_spec.rb
+- spec/spec_helper.rb
+has_rdoc: