redis_wrapper 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Cameron Hurst
+
+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,9 @@
+require 'rspec/core/rake_task'
+
+desc "Run all tests"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation'
+  t.ruby_opts = "-W1"
+end
+
+task :default => :spec

data/lib/redis_wrapper/entry.rb

@@ -0,0 +1,99 @@
+module RedisWrapper
+  class Entry
+    attr_accessor :flags, :value
+    FLAG_MARSHALED = "0x1"
+    FLAG_COMPRESSED = "0x2"
+    DEFAULT_COMPRESS_LIMIT = 16 * 1024 #16 kilobytes
+    
+    def self.option_keys
+      [:expire_in,:flags, :raw]
+    end
+    
+    def initialize(value, options = {})
+      @flags = options[:flags] || {}
+      @value = value
+      @options = options
+      flag_extraction if @value.class == String
+    end
+    
+    def extracted_result
+      @value = demarshal(decompress(@value))
+    end
+
+    def prepared_result
+      prepare(@value) + flags_string
+    end
+
+    def prepare(value)
+      compress(marshal(value)) if value
+    end
+
+    def flags_string
+      string = ""
+      string += FLAG_MARSHALED if @flags[:marshaled]
+      string += FLAG_COMPRESSED if @flags[:compressed]
+      string
+    end
+    
+    def demarshal(val)
+      if marshaled?
+        @flags[:marshaled] = false
+        return Marshal.load(val)
+      end
+      val
+    end
+    
+    def decompress(val)
+      if compressed?
+        @flags[:compressed] = false
+        return Zlib::Inflate.inflate(val)
+      end
+      val
+    end
+    
+    def compress(val)
+      if should_compress?(val) && !compressed?
+        @flags[:compressed] = true
+        return Zlib::Deflate.deflate(val)
+      end
+      val
+    end
+    
+    def marshal(val)
+      if val && !marshaled?
+        @flags[:marshaled] = true
+        Marshal.dump(val)
+      end
+    end
+    
+    def flag_extraction
+      if @value
+        pflag = @value.slice(@value.length-3..@value.length)
+        if pflag == FLAG_MARSHALED
+          @flags[:marshaled] = true
+          @value = @value.slice(0..-4)
+          flag_extraction
+        elsif pflag == FLAG_COMPRESSED
+          @flags[:compressed] = true
+          @value = @value.slice(0..-4)
+          flag_extraction
+        end
+      end
+    end
+    
+    private
+      def compressed?
+        @flags[:compressed] == true
+      end
+      def marshaled?
+        @flags[:marshaled] == true
+      end
+      def should_compress?(val)
+        unless @options[:raw] || val.nil?
+          compression_threshold = @options[:compression_threshold] || DEFAULT_COMPRESS_LIMIT
+          return true if val.size >= compression_threshold
+        end
+        false
+      end
+  end
+end

data/lib/redis_wrapper/redis_wrapper.rb

@@ -0,0 +1,37 @@
+module RedisWrapper
+  class RedisWrapper
+    def initialize(options={})
+      @client = Redis.new(options)
+    end
+    def method_missing(method, *args, &block)
+      if @client.respond_to? method
+        options, args = get_options(*args) || [{}, args]
+        key, args = get_key(*args)
+        args = handle(*args)
+        args = [key] + args if args && key
+        result = Entry.new(@client.send(method, *args, &block), options).extracted_result
+        @client.send(:expire, key, options[:expire_in].to_i) if options[:expire_in]
+        result
+      else
+        raise NameError, :message=> "method #{method} is not defined"
+      end
+    end
+    
+    private
+      def get_options(*args)
+        if args.last.kind_of?(Hash)
+          if Entry.option_keys.map{|key| args.last.keys.include?(key)}.compact.include?(true)
+            return args.pop, args
+          end
+        end
+      end
+      
+      def get_key(*args)
+        args.first.kind_of?(String) ? [args.shift, args] : [nil, args]
+      end
+      
+      def handle(*args)
+        args.map{|u| Entry.new(u).prepared_result} if args
+      end
+  end
+end

data/lib/redis_wrapper/version.rb

@@ -0,0 +1,6 @@
+module RedisWrapper
+  MAJOR = 0
+  MINOR = 1
+  PATCH = 0
+  VERSION = [MAJOR, MINOR, PATCH].compact.join('.')
+end

data/lib/redis_wrapper.rb

@@ -0,0 +1,7 @@
+require "redis"
+require "redis_wrapper/version"
+
+module RedisWrapper
+  autoload :RedisWrapper, File.join(File.dirname(__FILE__), "redis_wrapper", "redis_wrapper")
+  autoload :Entry, File.join(File.dirname(__FILE__), "redis_wrapper", "entry")
+end

data/redis_wrapper.gemspec

@@ -0,0 +1,39 @@
+require './lib/redis_wrapper/version'
+
+Gem::Specification.new do |s|
+  s.name = "redis_wrapper"
+  s.version = RedisWrapper::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["wakemaster39"]
+  s.date = "2012-01-17"
+  s.description = "A high level wrapper around the redis-rb gem and API. Designed to be a drop in replacement for Redis class while handling object marshaling and compression, setting key expiries, and namespacing your keys"
+  s.email = "wakemaster39@gmail.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {spec,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.homepage = "http://github.com/wakemaster39/redis-wrapper"
+  s.licenses = ["MIT"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "High level wrapper around redis API"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<redis>, ["~>2.2.1"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<redis>, ["~>2.2.1"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<redis>, ["~>2.2.1"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end
+

data/spec/entry_spec.rb

@@ -0,0 +1,356 @@
+require 'redis_wrapper/entry.rb'
+require 'zlib'
+
+describe RedisWrapper::Entry do
+  describe '#flag_extraction' do 
+    context 'raw object' do
+      before do
+        @teststring = "teststring"
+        @wrapper = RedisWrapper::Entry.new(@teststring,:raw=>true)
+      end
+      it 'should extract no flags' do
+        @wrapper.flag_extraction
+        @wrapper.flags.should eq({})
+      end
+      it 'should not alter the string' do
+        @wrapper.flag_extraction
+        @wrapper.value.should eq(@teststring)
+      end
+    end
+    context 'marshaled object' do
+      before do
+        @teststring = "teststring0x1"
+        @wrapper = RedisWrapper::Entry.new(@teststring)
+      end
+      it 'should determine object is marshaled' do
+        @wrapper.flags.should include(:marshaled=>true) #include hash key
+      end
+      it 'should not need deflating' do
+        @wrapper.flags.should_not include(:compressed=>true) #include hash key
+      end
+      it 'should not pick flag if string contains flag not at end' do
+        @wrapper = RedisWrapper::Entry.new("0x10x10x10x1test",:raw=>true)
+        @wrapper.flag_extraction
+        @wrapper.flags.should_not include(:marshaled=>true)
+      end
+      it 'should not matter if double flagged' do
+        @wrapper = RedisWrapper::Entry.new("teststring0x10x1")
+        @wrapper.flags.should include(:marshaled=>true)
+        @wrapper.flags.should_not include(:compressed=>true)
+      end
+      it 'should remove the flag' do
+        @wrapper.value.should eq(@teststring.slice(0..-4))
+      end
+    end
+    context 'compressed object' do
+      before do
+        @teststring = "teststring0x2"
+        @wrapper = RedisWrapper::Entry.new(@teststring)
+      end
+      it 'should determine object is compressed' do
+        @wrapper.flags.should include(:compressed=>true) #include hash key
+      end
+      it 'should not need to be marshal dumped' do
+        @wrapper.flags.should_not include(:marshaled=>true) #include hash key
+      end
+      it 'should not pick flag if string contains flag not at end' do
+        @wrapper = RedisWrapper::Entry.new("0x20x20x20x2test")
+        @wrapper.flags.should_not include(:compressed=>true)
+      end
+      it 'should not matter if double flagged' do
+        @wrapper = RedisWrapper::Entry.new("teststring0x20x2")
+        @wrapper.flags.should_not include(:marshaled=>true)
+        @wrapper.flags.should include(:compressed=>true)
+      end
+      it 'should remove the flag' do
+        @wrapper.value.should eq(@teststring.slice(0..-4))
+      end
+    end
+    context 'marshaled and compressed object' do
+      before do
+        @teststring = "teststring0x10x2"
+        @wrapper = RedisWrapper::Entry.new(@teststring)
+      end
+      it 'should determine value is compressed and marshaled' do
+        @wrapper.flag_extraction
+        @wrapper.flags.should include(:compressed=>true,:marshaled=>true)
+      end
+      it 'should be based on order of flags' do
+        @wrapper.value = "teststring0x20x1"
+        @wrapper.flag_extraction
+        @wrapper.flags.should include(:compressed=>true,:marshaled=>true)
+      end
+      it 'should remove the flags' do
+        @wrapper.flag_extraction
+        @wrapper.value.should eq(@teststring.slice(0..-7))
+      end
+    end
+  end
+  
+  describe '#compressed?' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+    end
+    it 'should return true if compression flag true' do
+      @wrapper.flags = {:compressed=>true}
+      @wrapper.send(:compressed?).should eq(true)
+    end
+    it 'should return false if anything else' do
+      @wrapper.send(:compressed?).should eq(false)
+      @wrapper.flags = {:compressed=>"true"}
+      @wrapper.send(:compressed?).should eq(false)
+    end
+  end
+  describe '#marshaled?' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+    end
+    it 'should return true if compression flag true' do
+      @wrapper.flags = {:marshaled=>true}
+      @wrapper.send(:marshaled?).should eq(true)
+    end
+    it 'should return false if anything else' do
+      @wrapper.send(:marshaled?).should eq(false)
+      @wrapper.flags = {:compressed=>"true"}
+      @wrapper.send(:marshaled?).should eq(false)
+    end
+  end
+  
+  describe '#decompress' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+      @raw = "teststring"
+      @wrapper.value = Zlib::Deflate.deflate(@raw)
+      @wrapper.flags[:compressed] = true
+    end
+    it 'should decompress a compressed object' do
+      result = @wrapper.decompress(@wrapper.value)
+      result.should eq(@raw)
+    end
+    it 'should return original value if compression flag is not true' do
+      @wrapper.flags[:compressed] = false
+      @wrapper.decompress("test").should eq("test")
+    end
+    it 'should return error if value is not compressed' do
+      lambda {@wrapper.decompress("test")}.should raise_error
+    end
+    it 'should unset flag' do
+      @wrapper.decompress(@wrapper.value)
+      @wrapper.flags[:compressed].should_not eq(true)
+    end
+  end
+  
+  describe '#demarshal' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+      @raw = "teststring"
+      @wrapper.value = Marshal.dump(@raw)
+      @wrapper.flags[:marshaled] = true
+    end
+    it 'should demarshal a marshaled object' do
+      result = @wrapper.demarshal(@wrapper.value)
+      result.should eq(@raw)
+    end
+    it 'should return original value if marshaled flag is not true' do
+      @wrapper.flags[:marshaled] = false
+      @wrapper.demarshal("test").should eq("test")
+    end
+    it 'should return error if value is not marshaled' do
+      lambda {@wrapper.demarshal("test")}.should raise_error
+    end
+    it 'should unset flag' do
+      @wrapper.demarshal(@wrapper.value)
+      @wrapper.flags[:marshaled].should_not eq(true)
+    end
+  end
+  
+  describe '#extracted_result' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+      @obj = Array.new
+    end
+    context 'should return original value if' do
+      it 'marshaled' do
+        @wrapper.value = Marshal.dump(@obj)
+        @wrapper.flags[:marshaled] = true
+        @wrapper.extracted_result.should eq(@obj)
+      end
+      it 'compressed' do
+        @wrapper.value = Zlib::Deflate.deflate("test")
+        @wrapper.flags[:compressed] = true
+        @wrapper.extracted_result.should eq("test")
+      end
+      it 'compressed and marshaled' do
+        @wrapper.value = Zlib::Deflate.deflate(Marshal.dump(Array.new))
+        @wrapper.flags = {:compressed=>true,:marshaled=>true}
+        @wrapper.extracted_result.should eq(Array.new)
+      end
+      it 'should clear flags' do
+      @wrapper.value = Zlib::Deflate.deflate(Marshal.dump(@bj)) + "0x10x2"
+      @wrapper.flags = {:compressed=>true, :marshaled=>true}
+      @wrapper.extracted_result
+      @wrapper.flags.should eq({:compressed=>false, :marshaled=>false})
+    end
+    it 'should change stored value' do
+      @wrapper = RedisWrapper::Entry.new(Marshal.dump(@obj)+"0x1")
+      @wrapper.value.should_not eq(@obj)
+      @wrapper.extracted_result
+      @wrapper.value.should eq(@obj)
+    end
+    end
+  end
+  
+  describe '#should_compress?' do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+      @teststring = (0..10000).map{|u| u*u}.to_s
+    end
+    it 'should return false if :raw is set to true even if over threshold' do
+      @wrapper = RedisWrapper::Entry.new(nil,{:raw=>true})
+      @wrapper.value = @teststring
+      @wrapper.send(:should_compress?, @wrapper.value).should eq(false)
+    end
+    it 'should return true if over threshold without bypass' do
+      @wrapper.value = @teststring
+      @wrapper.send(:should_compress?, @wrapper.value).should eq(true)
+    end
+    it 'should accept a change in thershold in object creation' do
+      @wrapper = RedisWrapper::Entry.new(nil,{:compression_threshold=>100000})
+      @wrapper.value = @teststring
+      @wrapper.send(:should_compress?, @wrapper.value).should eq(false)
+    end
+    it 'should return true if greater than threshold' do
+      @wrapper.value = @teststring
+      @wrapper.send(:should_compress?, @wrapper.value).should eq(true)
+    end
+    it 'should not compress nil values' do
+      @wrapper.send(:should_compress?, @wrapper.value).should eq(false)
+    end
+  end
+  
+  describe '#marshal' do
+    before do
+      @obj = Array.new
+      @wrapper = RedisWrapper::Entry.new(@obj)
+    end
+    it 'should marshal an object' do
+      @wrapper.marshal(@obj).should eq(Marshal.dump(@obj))
+    end
+    it 'should set marshal flag to true' do
+      @wrapper.marshal(@obj)
+      @wrapper.flags[:marshaled].should eq(true)
+    end
+  end
+  
+  describe '#compress' do
+    before do
+      @wrapper = RedisWrapper::Entry.new("teststring1",:compression_threshold=>10)
+    end
+    it 'should compress object if above threshold' do
+      @wrapper.compress(@wrapper.value).should eq(Zlib::Deflate.deflate(@wrapper.value))
+    end
+    it "shouldn't compress if below threshold" do
+      @wrapper = RedisWrapper::Entry.new("teststring1")
+      @wrapper.compress(@wrapper.value).should eq(@wrapper.value)
+    end
+    it "should set compression flag true" do
+      @wrapper.compress(@wrapper.value)
+      @wrapper.flags[:compressed].should eq(true)
+    end
+  end
+  
+  describe '#new' do
+    context 'passed a string' do
+      before do
+        @teststring = "teststring"
+      end
+      it 'should extract flags if passed an ecoded string' do
+        @wrapper = RedisWrapper::Entry.new(@teststring + "0x10x2")
+        @wrapper.flags.should include(:compressed=>true, :marshaled=>true)
+        @wrapper.value.should eq(@teststring)
+      end
+    end
+    context 'passed an object' do
+      before do
+        @obj = Array.new
+        @options = {:compression_threshold=>0}
+      end
+      it 'should respect the raw flag' do
+        @wrapper = RedisWrapper::Entry.new(@obj,@options.merge(:raw=>true))
+        @wrapper.value.should eq(@obj)
+        @wrapper.flags.should eq({})
+      end
+    end
+    context 'passed nil' do
+      before do
+        @wrapper = RedisWrapper::Entry.new(nil,:compression_threshold=>2)
+      end
+      it 'should skip compression and marshalling' do
+        @wrapper.flags.should eq({})
+      end
+      it 'should leave object alone' do
+        @wrapper.value.should eq(nil)
+      end
+    end
+    context 'options should' do
+      it 'allow manual setting of flags' do
+        @wrapper = RedisWrapper::Entry.new(nil,:flags=>{:compressed=>true})
+        @wrapper.flags.should eq(:compressed=>true)
+      end
+    end
+  end
+  
+  describe "#flags_string" do
+    before do
+      @wrapper = RedisWrapper::Entry.new(nil)
+    end
+    it 'should return 0x1 if marshaled' do
+      @wrapper.flags = {:marshaled => true}
+      @wrapper.flags_string.should eq("0x1")
+    end
+    it 'should return 0x2 if compressed' do
+      @wrapper.flags = {:compressed => true}
+      @wrapper.flags_string.should eq("0x2")
+    end
+    it 'should return 0x10x2 if marshaled and compressed' do
+      @wrapper.flags = {:compressed => true, :marshaled => true}
+      @wrapper.flags_string.should eq("0x10x2")
+    end
+  end
+
+  describe "#prepare" do
+    before do
+      @obj = Array.new
+      @wrapper = RedisWrapper::Entry.new(@obj, :compression_threshold => 0)
+    end
+    it "should marshal when needed" do
+      @wrapper.should_receive(:marshal).with(@obj)
+      @wrapper.prepare(@obj)
+    end
+    it "should compress when needed" do
+      @wrapper.should_receive(:compress).with(Marshal.dump(@obj))
+      @wrapper.prepare(@obj)
+    end
+    it "should return nil if passed nil" do
+      @wrapper.prepare(nil).should eq(nil)
+    end
+  end
+
+  describe "#prepared_result" do
+    before do
+      @obj = Array.new
+      @wrapper = RedisWrapper::Entry.new(@obj, :compression_threshold => 0)
+    end
+    it 'should return a string' do
+      @wrapper.prepared_result.class.should eq(String)
+    end
+    it 'should be compressed and marshalled' do
+      @wrapper.prepared_result.should eq(Zlib::Deflate.deflate(Marshal.dump(@obj))+"0x10x2")
+    end
+    it 'should have flags' do
+      @flags = RedisWrapper::Entry.new(@wrapper.prepared_result).flags
+      @flags.should_not eq({})
+      @flags.class.should eq(Hash)
+    end
+  end
+end

data/spec/redis_wrapper_spec.rb

@@ -0,0 +1,61 @@
+require 'redis_wrapper/redis_wrapper'
+require 'redis'
+describe RedisWrapper::RedisWrapper do
+  describe '#get_options' do
+    before do
+      @wrapper = RedisWrapper::RedisWrapper.new()
+    end
+    it 'should return nil if last object is not a hash' do
+      @wrapper.send(:get_options, [],{},[]).should eq(nil)
+    end
+    it 'should return nil if object is a hash without a proper key' do
+      @wrapper.send(:get_options, [],{},{}).should eq(nil)
+    end
+    it 'should return args without last hash and the hash if contains proper key' do
+      @wrapper.send(:get_options, [],{},{:expire_in => 1}).should eq([{:expire_in => 1}, [[], {}]])
+    end
+  end
+
+  describe '#get_key' do
+    before do
+      @wrapper = RedisWrapper::RedisWrapper.new()
+      @key = "test"
+      @other =  [[1,2,3],{:expire_in=>1}]
+    end
+    it 'should return nil and args if first object is not a string' do
+      @wrapper.send(:get_key, *@other).should eq([nil,@other])
+    end
+    it 'should return string and args without string if first object is a string' do
+      @wrapper.send(:get_key, @key, *@other).should eq([@key,@other])
+    end
+  end
+
+  describe '#handle' do
+    before do
+      @wrapper = RedisWrapper::RedisWrapper.new()
+      @args = [[1,2,3],{:test=>1}]
+    end
+    it 'should return an array of string independent of what was passed' do
+      @wrapper.send(:handle,*@args).map{|u| u.class == String}.uniq.should eq([true])
+    end
+  end
+
+  describe '#method_missing' do
+    before do
+      @wrapper =  RedisWrapper::RedisWrapper.new()
+      @redis = Redis.new()
+    end
+    it 'should set a TTL if options hash contains a :expire_in key' do
+      @wrapper.set "test", "test", :expire_in => 100
+      @redis.ttl("test").should_not eq(-1)
+    end
+    it 'should return response from server' do
+      @wrapper.set("test", "test").should eq(@redis.set("test", "test"))
+    end
+    it 'should have no expiry if none was passed or previously set' do
+      @redis.ttl("test1").should eq(-1)
+      @wrapper.set("test1", "test")
+      @redis.ttl("test1").should eq(-1)
+    end
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: redis_wrapper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- wakemaster39
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-17 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &24307320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *24307320
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &24306720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *24306720
+description: A high level wrapper around the redis-rb gem and API. Designed to be
+  a drop in replacement for Redis class while handling object marshaling and compression,
+  setting key expiries, and namespacing your keys
+email: wakemaster39@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/redis_wrapper.rb
+- lib/redis_wrapper/entry.rb
+- lib/redis_wrapper/redis_wrapper.rb
+- lib/redis_wrapper/version.rb
+- redis_wrapper.gemspec
+- spec/entry_spec.rb
+- spec/redis_wrapper_spec.rb
+homepage: http://github.com/wakemaster39/redis-wrapper
+licenses:
+- MIT
+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.10
+signing_key: 
+specification_version: 3
+summary: High level wrapper around redis API
+test_files: []