redis-attrs 0.0.1

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 @@
+--color

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ernesto Garcia
+
+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,146 @@
+# Redis::Attrs - Add attributes to Ruby classes backed by Redis
+
+This gem is an amalgamation of the ideas found within the [redis_props][redis_props]
+and [redis-objects][redis-objects] gems, plus a few new ideas here and there.  It
+provides a way to define, on any Ruby class, some attributes that are backed by
+[Redis][redis] behind the curtain.
+
+Here are some of the characteristics that define this library:
+
+- Easy to integrate directly with existing ORMs - ActiveRecord, DataMapper, etc.
+- Not confined to ORMs. Use it in whatever Ruby classes you want.
+- It does work better with ORMs because it requires each object to provide a
+  unique id identifying it, something already provided by most ORMs out of the box.
+- Supports scalar value types, as well as more complex value types such as
+  collection types, counters and locks.
+- Integers are returned as integers, rather than '17'. The same holds for dates,
+  times, floats, etc.
+- Collection types can be assigned a Ruby-style collection to set their whole
+  content at once, resetting whatever content there was in the Redis key.
+- The user can add support for more scalar data types with no built-in support.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'redis-attrs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis-attrs
+
+## Usage
+
+Start by defining some attributes on your class:
+
+    class Film
+      include Redis::Attrs
+      redis_attrs :title => :string, :length => :integer
+      redis_attrs :released_on => :date, :cast => :list
+
+      # Remember that the objects need an id for this to work
+      attr_reader :id
+      def initialize(id)
+        @id = id
+      end
+
+      def presentation_title
+        "#{title} (#{released_on.year})"
+      end
+    end
+
+Then you can use those attributes as you would regularly, but internally they are
+reading from and writing to Redis.
+
+    >> film = Film.new(3)
+    >> film.title = "Argo"
+    >> film.released_on = "2012-10-12"
+    >> puts film.presentation_title
+    Argo (2012)
+    >> puts film.cast.size
+    0
+    >> film.cast = ["Ben Affleck", "Alan Arkin", "Brian Cranston"]
+    >> puts film.cast.size
+    3
+    >> puts film.cast[-3]
+    Ben Affleck
+
+`Redis::Attrs` will work on _any_ class that provides an `id` method that returns
+a unique value.  `Redis::Attrs` will automatically create keys that are unique to
+each object, in the format:
+
+    class_name:id:attr_name
+
+### Supported types
+
+`Redis::Attrs` supports the following scalar types: `string`, `integer`, `float`,
+`boolean`, `date` and `time`. These are automatically serialized and deserialized
+when written to and read from Redis.
+
+In addition, the library also supports some collection types and a couple other
+non-scalar types: `list`, `hash`, `set`, `sorted_set`, `counter` and `lock`.  These
+are all implemented using the [redis-objects][redis-objects] gem, each type handled
+by a class that encapsulate all Redis logic around them.
+
+### Defining new scalar types
+
+In addition to the predefined scalar types listed above, the user can define its
+own scalar types, by subclassing `Redis::Attrs::Scalar` and defining how to serialize
+and deserialize its values.
+
+The following example defines a data-type that stores its values serialized as JSON.
+The `serialize` and `deserialize` methods define how this process is done.  After
+registering the type with `Redis::Attrs`, a new attribute is added to the class
+`Film` defined above.
+
+    class JSONScalar < Redis::Attrs::Scalar
+      def serialize(value)
+        value.to_json
+      end
+
+      def deserialize(value)
+        JSON.parse(value)
+      end
+    end
+
+    Redis::Attrs.register_type(:json, JSONScalar)
+
+    class Film
+      redis_attrs :director => :json
+    end
+
+After the definitions above, more complex data structures could be stored as a single
+scalar value, by being serialized as JSON.
+
+    >> film = Film.new(1)
+    >> film.director = { "first_name" => "Ben", "last_name" => "Affleck" }
+    >> puts Redis::Attrs.redis.get("film:1:director")
+    {"first_name":"Ben","last_name":"Affleck"}
+
+### Attribute configuration options
+
+The complex attribute types support some configuration options, mostly specific to
+each type.  When an attribute needs to be configured with some of these options, then
+it must be declared with the singular version of the method `redis_attrs`, like below:
+
+    redis_attr :crawl, :lock, :expiration => 15.minutes
+    redis_attr :cast, :list, :marshal => true
+
+For more details about the supported configuration options for each of the complex
+data types, please refer to the [redis-objects][redis-objects] gem.
+
+## 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
+
+[redis]: http://redis.io
+[redis_props]: http://github.com/obie/redis_props
+[redis-objects]: http://github.com/nateware/redis-objects

data/Rakefile

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

data/lib/redis-attrs.rb

@@ -0,0 +1,92 @@
+require "redis-attrs/version"
+require "redis"
+require "active_support/inflector"
+
+class Redis
+  module Attrs
+    def self.redis
+      @redis ||= Redis.new
+    end
+
+    def self.redis=(r)
+      raise ArgumentError, "Redis Attrs: Invalid Redis instance" unless r.is_a?(Redis)
+      @redis = r
+    end
+
+    module ClassMethods
+      def redis
+        Redis::Attrs.redis
+      end
+
+      def redis_key_prefix
+        @redis_key_refix ||= ActiveSupport::Inflector.underscore(self.name)
+      end
+
+      def redis_attrs(attrs = nil)
+        @redis_attrs ||= []
+        return @redis_attrs if attrs.nil?
+        attrs.each do |name, type|
+          redis_attr name, type
+        end
+      end
+
+      def redis_attr(name, type, options = {})
+        @redis_attrs ||= []
+        klass = Redis::Attrs::supported_types[type]
+        raise ArgumentError, "Unknown Redis::Attr type #{type}" if klass.nil?
+        attr = klass.new(self, name, type, options)
+        @redis_attrs << attr
+      end
+    end
+
+    module InstanceMethods
+      def redis
+        Redis::Attrs.redis
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend(ClassMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    def self.supported_types
+      @supported_types ||= {
+        # Scalar types
+        string:  Redis::Attrs::String,
+        boolean: Redis::Attrs::Boolean,
+        date:    Redis::Attrs::Date,
+        time:    Redis::Attrs::Time,
+        integer: Redis::Attrs::Integer,
+        float:   Redis::Attrs::Float,
+
+        # Complex types
+        counter:    Redis::Attrs::Complex,
+        lock:       Redis::Attrs::Complex,
+        hash:       Redis::Attrs::Hash,
+        list:       Redis::Attrs::List,
+        set:        Redis::Attrs::List,
+        sorted_set: Redis::Attrs::Hash,
+      }
+    end
+
+    def self.register_type(type, klass)
+      type = type.to_sym
+      raise ArgumentError, "Redis attr type #{type} is already defined" if supported_types.include?(type)
+      raise ArgumentError, "Class implementing new type #{type} must be a subclass of Redis::Attrs::Scalar" unless klass.ancestors.include?(Scalar)
+      @supported_types[type] = klass
+    end
+
+    autoload :Base,    'redis-attrs/base'
+    autoload :Scalar,  'redis-attrs/scalar'
+    autoload :String,  'redis-attrs/string'
+    autoload :Boolean, 'redis-attrs/boolean'
+    autoload :Date,    'redis-attrs/date'
+    autoload :Time,    'redis-attrs/time'
+    autoload :Integer, 'redis-attrs/integer'
+    autoload :Float,   'redis-attrs/float'
+    autoload :Complex, 'redis-attrs/complex'
+    autoload :List,    'redis-attrs/list'
+    autoload :Hash,    'redis-attrs/hash'
+  end
+end

data/lib/redis-attrs/base.rb

@@ -0,0 +1,20 @@
+class Redis
+  module Attrs
+    class Base
+      attr_reader :klass, :name, :type, :options
+
+      def initialize(klass, name, type, options)
+        @klass, @name, @type, @options = klass, name, type, options
+      end
+
+      def redis
+        Redis::Attrs.redis
+      end
+
+      def redis_key(id)
+        raise "id attribute is required in order to properly store Redis attributes" if id.nil?
+        "#{klass.redis_key_prefix}:#{id}:#{name}"
+      end
+    end
+  end
+end

data/lib/redis-attrs/boolean.rb

@@ -0,0 +1,9 @@
+class Redis
+  module Attrs
+    class Boolean < Scalar
+      def deserialize(value)
+        value.nil? ? nil : %w(true yes).include?(value.downcase)
+      end
+    end
+  end
+end

data/lib/redis-attrs/complex.rb

@@ -0,0 +1,47 @@
+require "redis/hash_key"
+require "redis/list"
+require "redis/set"
+require "redis/sorted_set"
+require "redis/lock"
+require "redis/counter"
+
+class Redis
+  module Attrs
+    class Complex < Base
+
+      def initialize(klass, name, type, options)
+        super
+        attr = self
+        attr_class = self.class.redis_object_class[self.type]
+
+        # Define the getter
+        klass.send(:define_method, name) do
+          instance_variable_get("@#{name}") || begin
+            obj = attr_class.new attr.redis_key(id), redis, options
+            instance_variable_set("@#{name}", obj)
+          end
+        end
+
+        # TODO: Add support for collection setters
+        if self.respond_to?(:setter)
+          klass.send(:define_method, "#{name}=") do |value|
+            obj = send(name)
+            attr.setter(id, obj, value)
+          end
+        end
+      end
+
+      def self.redis_object_class
+        @@redis_object_class ||= {
+          lock:       Redis::Lock,
+          counter:    Redis::Counter,
+          hash:       Redis::HashKey,
+          list:       Redis::List,
+          set:        Redis::Set,
+          sorted_set: Redis::SortedSet,
+        }
+      end
+
+    end
+  end
+end

data/lib/redis-attrs/date.rb

@@ -0,0 +1,9 @@
+class Redis
+  module Attrs
+    class Date < Scalar
+      def deserialize(value)
+        value.nil? ? nil : ::Date.parse(value)
+      end
+    end
+  end
+end

data/lib/redis-attrs/float.rb

@@ -0,0 +1,9 @@
+class Redis
+  module Attrs
+    class Float < Scalar
+      def deserialize(value)
+        value.nil? ? nil : value.to_f
+      end
+    end
+  end
+end

data/lib/redis-attrs/hash.rb

@@ -0,0 +1,10 @@
+class Redis
+  module Attrs
+    class Hash < Complex
+      def setter(id, hash_object, new_hash)
+        redis.del redis_key(id)
+        new_hash.each { |key, value| hash_object[key] = value }
+      end
+    end
+  end
+end

data/lib/redis-attrs/integer.rb

@@ -0,0 +1,9 @@
+class Redis
+  module Attrs
+    class Integer < Scalar
+      def deserialize(value)
+        value.nil? ? nil : value.to_i
+      end
+    end
+  end
+end

data/lib/redis-attrs/list.rb

@@ -0,0 +1,10 @@
+class Redis
+  module Attrs
+    class List < Complex
+      def setter(id, list_object, new_list)
+        redis.del redis_key(id)
+        new_list.each { |item| list_object << item }
+      end
+    end
+  end
+end

data/lib/redis-attrs/scalar.rb

@@ -0,0 +1,38 @@
+require "time"
+
+class Redis
+  module Attrs
+    class Scalar < Base
+
+      def initialize(klass, name, type, options)
+        super
+        attr = self
+
+        # Define the getter
+        klass.send(:define_method, name) do
+          value = redis.get attr.redis_key(id)
+          value.nil? ? nil : attr.deserialize(value)
+        end
+
+        # Define the setter
+        klass.send(:define_method, "#{name}=") do |value|
+          if value.nil?
+            redis.del attr.redis_key(id)
+          else
+            value = attr.serialize(value)
+            redis.set attr.redis_key(id), value
+          end
+        end
+      end
+
+      def serialize(value)
+        value.to_s
+      end
+
+      def deserialize(value)
+        value
+      end
+
+    end
+  end
+end

data/lib/redis-attrs/string.rb

@@ -0,0 +1,6 @@
+class Redis
+  module Attrs
+    class String < Scalar
+    end
+  end
+end

data/lib/redis-attrs/time.rb

@@ -0,0 +1,9 @@
+class Redis
+  module Attrs
+    class Time < Scalar
+      def deserialize(value)
+        value.nil? ? nil : ::Time.parse(value)
+      end
+    end
+  end
+end

data/lib/redis-attrs/version.rb

@@ -0,0 +1,5 @@
+class Redis
+  module Attrs
+    VERSION = "0.0.1"
+  end
+end

data/redis-attrs.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis-attrs/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "redis-attrs"
+  gem.version       = Redis::Attrs::VERSION
+  gem.authors       = ["Ernesto Garcia"]
+  gem.email         = ["gnapse@gmail.com"]
+  gem.description   = %q{A module that allows Ruby objects to define attributes backed by a Redis data store. Works with any class or ORM.}
+  gem.summary       = %q{Add persistent object attributes backed by redis}
+  gem.homepage      = "http://github.com/gnapse/redis-attrs"
+
+  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_development_dependency "rspec"
+  gem.add_dependency "redis"
+  gem.add_dependency "activesupport"
+  gem.add_dependency "redis-objects"
+end

data/spec/redis_attrs_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+require "json"
+
+class Film
+  include Redis::Attrs
+  redis_attrs title: :string, released_on: :date, length: :integer
+  redis_attrs created_at: :time, rating: :float, featured: :boolean
+
+  def id
+    1
+  end
+end
+
+class JSONScalar < Redis::Attrs::Scalar
+  def serialize(value)
+    value.to_json
+  end
+
+  def deserialize(value)
+    JSON.parse(value)
+  end
+end
+
+describe Redis::Attrs do
+  let(:redis) { Redis::Attrs.redis }
+  let(:film) { Film.new }
+
+  it "has a version number" do
+    Redis::Attrs::VERSION.should_not be_nil
+  end
+
+  context "when included in a class" do
+    it "makes the class respond to .redis_attrs" do
+      Film.should respond_to(:redis_attrs)
+    end
+
+    it "provides the class and its instances with a .redis interface" do
+      Film.should respond_to(:redis)
+      film.should respond_to(:redis)
+
+      Film.redis.should be_a(Redis)
+      Film.redis.should equal(film.redis)
+    end
+  end
+
+  describe ".redis_attrs" do
+    it "adds getters and setters for the attributes defined" do
+      %w(title released_on length created_at rating featured).each do |attr|
+        film.should respond_to(attr)
+        film.should respond_to("#{attr}=")
+      end
+    end
+
+    context "with no paremeters" do
+      it "returns a list of all Redis attributes defined for the class" do
+        Film.redis_attrs.should be_a(Array)
+        Film.redis_attrs.count.should == 6
+        Film.redis_attrs.map(&:name).should == [:title, :released_on, :length, :created_at, :rating, :featured]
+        Film.redis_attrs.map(&:type).should == [:string, :date, :integer, :time, :float, :boolean]
+      end
+    end
+  end
+
+  describe "getters" do
+    let(:now) { Time.parse("2013-02-22 22:31:12 -0500") }
+
+    it "return nil by default" do
+      film.title.should be_nil
+      film.released_on.should be_nil
+      film.length.should be_nil
+    end
+
+    it "return whatever was last set with the corresponding setter" do
+      film.title = "Argo"
+      film.title.should == "Argo"
+    end
+
+    it "keep the original value type" do
+      film.released_on = Date.parse("2012-10-12")
+      film.released_on.should == Date.parse("2012-10-12")
+      film.created_at = now
+      film.created_at.should == now
+      film.length = 135
+      film.length.should == 135
+      film.rating = 8.2
+      film.rating.should == 8.2
+      film.featured = true
+      film.featured.should == true
+    end
+  end
+
+  describe "setters" do
+    it "set the corresponding key in Redis" do
+      film.title = "Argo"
+      redis.get("film:1:title").should == "Argo"
+
+      film.rating = 8.1
+      redis.get("film:1:rating").should == "8.1"
+    end
+
+    it "unset the key when being assigned nil" do
+      film.rating = 8.1
+      redis.keys.should include("film:1:rating")
+
+      film.rating = nil
+      redis.keys.should_not include("film:1:rating")
+      redis.get("film:1:rating").should be_nil
+    end
+  end
+
+  describe ".register_type" do
+    it "allows to define support for scalar value types not covered by the library" do
+      Redis::Attrs.register_type(:json, JSONScalar)
+      Film.redis_attrs director: :json
+      film.director = { first_name: "Ben", last_name: "Affleck" }
+      redis.keys.should include("film:1:director")
+      redis.get("film:1:director").should == { first_name: "Ben", last_name: "Affleck" }.to_json
+      film.director.should == { "first_name" => "Ben", "last_name" => "Affleck" }
+    end
+  end
+
+  describe "collection attributes" do
+    it "support lists" do
+      Film.redis_attrs cast: :list
+      film.cast.should be_empty
+      film.cast = ["Ben Affleck", "Alan Arkin", "John Goodman", "Ben Affleck"]
+      film.cast.size.should == 4
+    end
+
+    it "support hashes" do
+      Film.redis_attrs crew: :hash
+      film.crew.should be_empty
+      film.crew = { costume: "John Doe", makeup: "Jane Doe", camera: "James Doe" }
+      film.crew.size.should == 3
+      film.crew.keys.should == %w(costume makeup camera)
+    end
+
+    it "support sets" do
+      Film.redis_attrs producers: :set
+      film.producers.should be_empty
+      film.producers = ["Grant Heslov", "Ben Affleck", "George Clooney", "Ben Affleck"]
+      film.producers.size.should == 3
+    end
+
+    it "support sorted sets" do
+      Film.redis_attrs rankings: :sorted_set
+      film.rankings.should be_empty
+      film.rankings = { "oscars" => 3, "golden globe" => 1, "bafta" => 2 }
+      film.rankings.first.should == "golden globe"
+      film.rankings.last.should == "oscars"
+      film.rankings.members.should == ["golden globe", "bafta", "oscars"]
+    end
+
+    it "support counters" do
+      Film.redis_attrs awards_count: :counter
+      film.awards_count.value.should == 0
+      film.awards_count.incr
+      film.awards_count.value.should == 1
+    end
+
+    it "support locks" do
+      Film.redis_attrs playing: :lock
+      film.playing.lock {  }
+    end
+
+    it "support specifying configuration options" do
+      require "active_support/core_ext/numeric/time"
+      Film.redis_attr :watching, :lock, :expiration => 3.hours
+      film.watching.options[:expiration].should == 3.hours
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require "redis-attrs"
+
+Redis::Attrs.redis = Redis.new(db: 13)
+
+RSpec.configure do |config|
+
+  # Clean up the database
+  config.before(:each) do
+    Redis::Attrs.redis.flushdb
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: redis-attrs
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ernesto Garcia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis-objects
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A module that allows Ruby objects to define attributes backed by a Redis
+  data store. Works with any class or ORM.
+email:
+- gnapse@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/redis-attrs.rb
+- lib/redis-attrs/base.rb
+- lib/redis-attrs/boolean.rb
+- lib/redis-attrs/complex.rb
+- lib/redis-attrs/date.rb
+- lib/redis-attrs/float.rb
+- lib/redis-attrs/hash.rb
+- lib/redis-attrs/integer.rb
+- lib/redis-attrs/list.rb
+- lib/redis-attrs/scalar.rb
+- lib/redis-attrs/string.rb
+- lib/redis-attrs/time.rb
+- lib/redis-attrs/version.rb
+- redis-attrs.gemspec
+- spec/redis_attrs_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/gnapse/redis-attrs
+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.24
+signing_key: 
+specification_version: 3
+summary: Add persistent object attributes backed by redis
+test_files:
+- spec/redis_attrs_spec.rb
+- spec/spec_helper.rb