rudis 0.1

data/LICENSE

@@ -0,0 +1,21 @@
+#MIT license.  See http://www.opensource.org/licenses/mit-license.php
+
+Copyright (c) 2010 Philotic, Inc.
+
+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,52 @@
+Rudis
+=====
+
+Rudis is a simple framework for implementing your favorite Redis recipes in Ruby.  There are only two concepts to Rudis:
+
+Types
+-----
+
+A type consists of any object that responds to `put` and `get`.These are used to transparently serialize and unserialize elements of your Redis sets, lists, zsets, and hashes.  For example:
+
+    >> s = Rudis::Set.new(:type => Rudis::JSONType)
+    >> s.add [1,2,3,4] # actually adds [1,2,3,4].to_json to the set
+    >> s.add {'foo' => 'bar'} # => '{foo:"bar"}' is added
+    >> s.include? {'foo' => 'bar'}
+    true
+    >> s.to_a
+    [[1,2,3,4], {'foo' => 'bar'}]
+
+You can write your own types, too!
+
+    class ActiveRecordType
+      def initialize(model)
+        @model = model
+      end
+      def self.put(val)
+        val.id
+      end
+      def self.get(val)
+        @model.find(val.to_i)
+      end
+    end
+
+Recipes
+-------
+
+A recipe is a subclass of `Rudis::Base`.  Rudis provides two handy-dandy methods: `key` and `redis`.  `redis` is both an instance method and a class method that gives you an instance of Redis (writable, with sensible defaults).  `key` is really handy:
+
+    class Foo < Rudis::Base
+    end
+
+    >> Foo.new('foo').key
+    => "foo"
+    >> Foo.new('foo').key('bar', 'baz')
+    => "foo:bar:baz"
+    >> Foo.key_sep = '/'
+    >> Foo.new('foo').key('bar', 'baz')
+    => "foo/bar/baz"
+    >> Foo.key_base = ['foo', 'bar']
+    >> Foo.new('zot').key('zongo')
+    => "foo/bar/zot/zongo"
+
+Enjoy!  I have lots of TODOs, including better SORT integration, more builtin types (like Marshall), and always more examples.  Checkout `examples/` for a few neat examples.

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.ruby_opts = ['-r init']
+end

data/init.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib', 'rudis'))

data/lib/rudis.rb

@@ -0,0 +1,19 @@
+#only once
+require begin
+  File.expand_path(
+    File.join(
+      File.dirname(__FILE__),
+      '..',
+      'vendor',
+      'core_ext',
+      'init'
+    )
+  )
+end
+
+class Rudis
+end
+
+require_local 'rudis/base'
+require_local 'rudis/type'
+require_local 'rudis/structure'

data/lib/rudis/base.rb

@@ -0,0 +1,54 @@
+class Rudis
+  class << self
+    attr_writer :redis
+    def redis
+      @redis ||= begin
+        require 'rubygems'
+        require 'redis'
+        Redis.new
+      end
+    end
+
+    attr_writer :key_base
+    def key_base
+      @key_base ||= ['rudis']
+    end
+
+    attr_writer :key_sep
+    def key_sep
+      @key_sep ||= ':'
+    end
+
+    def key(*args)
+      ([key_base].flatten + args).join(key_sep)
+    end
+  end
+
+
+  class Base < Rudis
+    class << self
+      attr_writer :redis
+      def self.redis
+        @redis ||= super
+      end
+    end
+
+    def redis
+      @redis ||= self.class.redis
+    end
+
+    def initialize(key, options={})
+      @key = key
+      @options = options
+      @options.rmerge!(default_options)
+    end
+
+    def default_options
+      {}
+    end
+
+    def key(*args)
+      self.class.key(@key, *args)
+    end
+  end
+end

data/lib/rudis/structure.rb

@@ -0,0 +1,63 @@
+class Rudis
+  class Structure < Base
+    def type
+      @options[:type]
+    end
+
+    def default_options
+      {:type => DefaultType}
+    end
+
+    def exists?
+      redis.exists(key)
+    end
+    alias exist? exists?
+
+    def del
+      redis.del(key)
+    end
+    alias delete! del
+
+    def rename(new_key)
+      redis.rename(key, self.class.key(new_key))
+      @key = new_key
+    end
+
+    def redis_type
+      redis.type(key)
+    end
+
+    def expire(time)
+      redis.expire(key, time)
+    end
+
+    def expire_at(time)
+      redis.expire_at(key, time)
+    end
+
+    def ttl
+      redis.ttl(key)
+    end
+
+    def watch(tries=0)
+      return redis.watch(key) unless block_given?
+
+      begin
+        redis.watch(key)
+        c = 0
+        while yield.nil? && (tries==0 || (c+=1) <= tries)
+          puts "Optimistic lock failed for #{key}, retrying #{c} time(s)"
+        end
+      ensure
+        redis.unwatch(key)
+      end
+    end
+  end
+end
+
+require_local 'structures/counter'
+require_local 'structures/list'
+require_local 'structures/lock'
+require_local 'structures/hash'
+require_local 'structures/set'
+require_local 'structures/zset'

data/lib/rudis/structures/counter.rb

@@ -0,0 +1,27 @@
+class Rudis
+  class Counter < Structure
+    def incr
+      redis.incr(key)
+    end
+
+    def decr
+      redis.decr(key)
+    end
+
+    def incrby(i)
+      redis.incrby(key, i.to_i)
+    end
+
+    def decrby(i)
+      redis.decrby(key, i.to_i)
+    end
+
+    def to_i
+      redis.get(key).to_i
+    end
+
+    def zero?
+      to_i.zero?
+    end
+  end
+end

data/lib/rudis/structures/hash.rb

@@ -0,0 +1,86 @@
+class Rudis
+  class Hash < Structure
+    def default_options
+      {
+        :type => DefaultType,
+        :key_type => DefaultType
+      }
+    end
+
+    def key_type
+      @options[:key_type]
+    end
+
+    def get(k)
+      e = redis.hget(key, key_type.put(k))
+      e && type.get(e)
+    end
+    alias [] get
+
+    def set(k,v)
+      redis.hset(key, key_type.put(k), type.put(v))
+    end
+    alias []= set
+
+    def mget(*ks)
+      ks.zip(redis.hmget(key, ks.map { |k|
+        key_type.put(k)
+      }).map { |v|
+        type.get(v)
+      }).to_h 
+    end
+    alias slice mget
+
+    def mset(hsh)
+      hsh = hsh.dup
+      hsh.map! {|k,v| [key_type.put(k), type.put(v)]}
+      redis.hmset(key, *hsh.to_a.flatten)
+    end
+    alias merge! mset
+
+    def keys
+      redis.hkeys(key).map { |k| key_type.get(k) }
+    end
+
+    def vals
+      redis.hvals(key).map { |v| type.get(v) }
+    end
+    alias values vals
+
+    def all
+      redis.hgetall(key).map! do |k,v|
+        [key_type.get(k), type.get(v)]
+      end
+    end
+    alias to_h all
+
+    def len
+      redis.hlen(key)
+    end
+    alias length len
+    alias count len
+    alias size len
+
+    def empty?
+      len == 0
+    end
+
+    def del(k)
+      redis.hdel(key, key_type.put(k))
+    end
+
+    def has_key?(k)
+      redis.hexists(key, key_type.put(k))
+    end
+    alias include? has_key?
+
+    def incrby(k, i)
+      redis.hincrby(key, key_type.put(k), i.to_i)
+    end
+
+    def incr(k)
+      incrby(k, 1)
+    end
+
+  end
+end

data/lib/rudis/structures/list.rb

@@ -0,0 +1,71 @@
+class Rudis
+  class List < Structure
+    def len
+      redis.llen(key)
+    end
+    alias length len
+    alias size len
+    alias count len
+
+    def empty?
+      len == 0
+    end
+
+    def index(i)
+      type.get(redis.lindex(key, i.to_i))
+    end
+
+    def range(range)
+      redis.lrange(key, range.first.to_i, range.last.to_i).map do |e|
+        type.get(e)
+      end
+    end
+
+    def all
+      range 0..-1
+    end
+    alias to_a all
+
+    def [](thing)
+      if thing.is_a? Fixnum
+        index thing
+      elsif thing.is_a? Range
+        range thing
+      end
+    end
+
+    def set(i, val)
+      redis.lset(key, i.to_i, type.put(val))
+    end
+    alias []= set
+
+    def rpush(val)
+      redis.rpush(key, type.put(val))
+    end
+    alias push rpush
+    alias << rpush
+
+    def rpop
+      e = redis.rpop(key)
+      e && type.get(e)
+    end
+    alias pop rpop
+
+    def lpush(val)
+      redis.lpush(key, type.put(val))
+    end
+    alias unshift lpush
+    alias >> lpush
+
+    def lpop
+      e = redis.lpop(key)
+      e && type.get(e)
+    end
+    alias shift lpop
+
+    def trim(range)
+      redis.trim(key, range.first.to_i, range.last.to_i)
+    end
+    alias trim! trim
+  end
+end

data/lib/rudis/structures/lock.rb

@@ -0,0 +1,61 @@
+class Rudis
+  class Lock < Structure
+    class LockFailed < Exception; end
+
+    def acquire(options={})
+      options.rmerge!(
+        :tries => 1,
+        :sleep => 1
+      )
+
+      return set(options) unless block_given?
+
+      1.upto options[:tries] do
+        if set(options)
+          return begin
+            yield
+          ensure
+            clear
+          end
+        end
+        sleep options[:sleep]
+      end
+
+      # oops, we couldn't get the lock
+      raise LockFailed, <<-msg.squish
+        Unable to acquire lock after #{options[:tries]} time(s)
+      msg
+      return false
+    end
+
+    # implements the SETNX locking algorithm from
+    # http://code.google.com/p/redis/wiki/SetnxCommand
+    def set(options={})
+      options.rmerge!(
+        :timeout => 30
+      )
+      if redis.setnx(key, timestamp(options[:timeout]))
+        return true
+      else
+        # check the timestamp
+        old = redis.getset(key, timestamp(options[:timeout]))
+        if old < timestamp
+          # expired lock, we're good
+          return true
+        else
+          # lock is not expired, put it back
+          redis.set(key, old)
+          return false
+        end
+      end
+    end
+
+    alias clear del
+
+  private
+    def timestamp(timeout=0)
+      Time.now.to_i + timeout
+    end
+
+  end
+end

data/lib/rudis/structures/set.rb

@@ -0,0 +1,52 @@
+class Rudis
+  class Set < Structure
+    def members
+      mems = redis.smembers(key)
+      mems.map! do |k|
+        type.get(k)
+      end
+      mems
+    end
+    alias all members
+    alias to_a members
+
+    def add(val)
+      redis.sadd(key, type.put(val))
+    end
+    alias << add
+
+    def is_member?(val)
+      redis.sismember(key, type.put(val))
+    end
+    alias member? is_member?
+    alias include? is_member?
+
+    def card
+      redis.scard(key)
+    end
+    alias count card
+    alias size card
+    alias length card
+
+    def rem(val)
+      redis.srem(key, type.put(val))
+    end
+    alias remove rem
+    alias delete rem
+
+    def randmember
+      e = redis.srandmember(key)
+      e && type.get(e)
+    end
+    alias rand randmember
+
+    def pop
+      e = redis.spop(key)
+      e && type.get(e)
+    end
+
+    def sort(*args)
+      #TODO
+    end
+  end
+end

data/lib/rudis/structures/zset.rb

@@ -0,0 +1,103 @@
+class Rudis
+  class ZSet < Structure
+    def default_options
+      {
+        :type => DefaultType,
+        :score_type => IntegerType
+      }
+    end
+
+    def score_type
+      @options[:score_type]
+    end
+
+    def add(member, score=1)
+      redis.zadd(key, score_type.put(score), type.put(member))
+    end
+    alias << add
+
+    def rem(member)
+      redis.zrem(key, type.put(member))
+    end
+
+    def incrby(member, i)
+      redis.zincrby(key, i.to_i, member)
+    end
+
+    def incr(member)
+      incrby(member, 1)
+    end
+
+    def rank(member)
+      i = redis.zrank(key, member)
+      i && i.to_i
+    end
+
+    def card
+      redis.zcard(key)
+    end
+    alias size card
+    alias length card
+    alias count card
+
+    def empty?
+      card == 0
+    end
+
+    def range(ran)
+      redis.zrange(key, ran.first.to_i, ran.last.to_i).map do |e|
+        type.get(e)
+      end
+    end
+
+    def revrange(ran)
+      redis.zrevrange(key, ran.first.to_i, ran.last.to_i).map do |e|
+        type.get(e)
+      end
+    end
+    alias rev_range revrange
+
+    def rangebyscore(min, max)
+      redis.zrangebyscore(key,
+        score_type.put(min),
+        score_type.put(max)
+      ).map do |e|
+        type.get(e)
+      end
+    end
+    alias range_by_score rangebyscore
+
+    def [](val)
+      if val.is_a? Range
+        range(val)
+      else
+        self[val..val]
+      end
+    end
+    alias slice []
+
+    def all
+      range(0..-1)
+    end
+    alias to_a all
+
+    def first
+      self[0..0].first
+    end
+
+    def last
+      self[-1..-1].first
+    end
+
+    def score(member)
+      s = redis.zscore(key, type.put(member))
+      s && score_type.get(s)
+    end
+
+    def member?(val)
+      !score(val).nil?
+    end
+    alias include? member?
+
+  end
+end

data/lib/rudis/type.rb

@@ -0,0 +1,5 @@
+require_local 'types/default'
+require_local 'types/integer'
+require_local 'types/json'
+require_local 'types/symbol'
+require_local 'types/time'

data/lib/rudis/types/default.rb

@@ -0,0 +1,12 @@
+class Rudis
+  #sorta boring.  nothing to see here.
+  class DefaultType
+    def self.put(val)
+      val
+    end
+
+    def self.get(val)
+      val
+    end
+  end
+end

data/lib/rudis/types/integer.rb

@@ -0,0 +1,11 @@
+class Rudis
+  module IntegerType
+    def self.put(val)
+      val.to_s
+    end
+
+    def self.get(val)
+      val.to_i
+    end
+  end
+end

data/lib/rudis/types/json.rb

@@ -0,0 +1,17 @@
+
+class Rudis
+  module JSONType
+
+    def self.put(val)
+      require 'rubygems'
+      require 'json'
+      val.to_json
+    end
+
+    def self.get(val)
+      require 'rubygems'
+      require 'json'
+      JSON.load(val)
+    end
+  end
+end

data/lib/rudis/types/symbol.rb

@@ -0,0 +1,11 @@
+class Rudis
+  module SymbolType
+    def self.put(val)
+      val.to_s
+    end
+    
+    def self.get(val)
+      val.to_sym
+    end
+  end
+end

data/lib/rudis/types/time.rb

@@ -0,0 +1,11 @@
+class Rudis
+  module TimeType
+    def self.put(val)
+      val.to_i
+    end
+
+    def self.get(val)
+      Time.at(val.to_i)
+    end
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,22 @@
+describe Rudis::Base do
+  before :all do
+    class Foo < Rudis::Base
+    end
+  end
+
+  it "has a writable base key" do
+    foo = Foo.new('foo_key')
+    Foo.key.should == 'rudis'
+    foo.key.should == 'rudis:foo_key'
+    Foo.key_base = ['Foo']
+    Foo.key.should == 'Foo'
+    foo.key.should == 'Foo:foo_key'
+  end
+
+  it "has a writable key separator" do
+    Foo.key_sep = '/'
+    Foo.key_base = ['Foo']
+    foo = Foo.new(:a)
+    foo.key(:b, "c:d:e").should == 'Foo/a/b/c:d:e'
+  end
+end

data/spec/counter_spec.rb

@@ -0,0 +1,17 @@
+describe Rudis::Counter do
+  before :each do
+    Rudis::Counter.redis.flushdb
+    @c = Rudis::Counter.new('my_counter')
+  end
+
+  it "counts!" do
+    @c.to_i.should == 0
+    @c.should be_zero
+    @c.incr.should == 1
+    @c.incr.should == 2
+    @c.decr.should == 1
+    @c.incrby(4).should == 5
+    @c.decrby(2).should == 3
+    @c.incrby(-1).should == 2
+  end
+end

data/spec/hash_spec.rb

@@ -0,0 +1,32 @@
+describe Rudis::Hash do
+  before :each do
+    Rudis::Hash.redis.flushdb
+    @hash = Rudis::Hash.new('myhash',
+      :key_type => Rudis::SymbolType,
+      :type => Rudis::IntegerType
+    )
+  end
+
+  it "implements the hash commands" do
+    @hash.should be_empty
+    @hash.length.should == 0
+    @hash[:foo] = 3
+    @hash.should_not be_empty
+    @hash[:foo].should == 3
+    @hash.all.should == {:foo => 3}
+    @hash[:bar] = 4
+    @hash.keys.to_set.should == Set.new([:foo, :bar])
+    @hash.values.sort.should == [3,4]
+    @hash.count.should == 2
+    @hash.to_h.should == {:foo => 3, :bar => 4}
+    @hash[:foo] = 5
+    @hash[:foo].should == 5
+    @hash.size.should == 2
+    @hash.slice(:foo).should == {:foo => 5}
+    @hash.merge!(:bar => 6, :baz => 7)
+    @hash.count.should == 3
+    @hash.to_h.should == {:foo => 5, :bar => 6, :baz => 7}
+    @hash.get(:baz).should == 7
+    @hash.get(:idontexist).should be_nil
+  end
+end

data/spec/list_spec.rb

@@ -0,0 +1,23 @@
+describe Rudis::List do
+  before :each do
+    Rudis::List.redis.flushdb
+    @list = Rudis::List.new('mylist', :type => Rudis::IntegerType)
+  end
+
+  it "implements the list commands" do
+    @list.size.should == 0
+    @list << 1
+    @list.to_a.should == [1]
+    @list.unshift 2
+    @list.count.should == 2
+    @list.all.should == [2,1]
+    @list.lpush 3
+    @list.shift.should == 3
+    @list.pop.should == 1
+    @list.lpop.should == 2
+    @list.length.should == 0
+    @list.rpop.should be_nil
+    @list.should be_empty
+    @list.to_a.should == []
+  end
+end

data/spec/set_spec.rb

@@ -0,0 +1,27 @@
+describe Rudis::Set do
+  before :each do
+    @key = (1..rand(5)).map { Time.now.hash.to_s }
+    @set = Rudis::Set.new(@key)
+  end
+
+  before :each do
+    Rudis::Set.redis.flushdb
+  end
+
+  it "implements the set commands" do
+    @set.key.should == "rudis:#{@key.join(':')}"
+    @set.card.should == 0
+    @set.add "foo"
+    @set.size.should == 1
+    @set << "bar"
+    @set.count.should == 2
+    @set.delete "foo"
+    @set.size.should == 1
+    @set.to_a.should == ["bar"]
+    @set.rand.should == "bar"
+    @set.pop.should == "bar"
+    @set.to_a.should == []
+    @set.pop.should be_nil
+  end
+
+end

data/spec/zset_spec.rb

@@ -0,0 +1,40 @@
+describe Rudis::ZSet do
+  before :each do
+    Rudis::ZSet.redis.flushdb
+    @zset = Rudis::ZSet.new('my_zset',
+      :type => Rudis::JSONType,
+      :score_type => Rudis::TimeType
+    )
+  end
+
+  it "implements the zset commands" do
+    now = Time.now
+    yesterday = now - 60*60*24
+    tomorrow = now + 60*60*24
+    @zset.should be_empty
+    @zset.count.should == 0
+    @zset.add([1,2,3], now)
+    @zset.length.should == 1
+    @zset.should_not be_empty
+    @zset.first.should == [1,2,3]
+    @zset.add({'four' => 4}, yesterday)
+    @zset.size.should == 2
+    @zset.add(['five' => 5, 'six' => 6], tomorrow)
+    @zset.all.should == [
+      {'four' => 4},
+      [1,2,3],
+      ['five' => 5, 'six' => 6]
+    ]
+    @zset.revrange(0..-2).should == [
+      ['five' => 5, 'six' => 6],
+      [1,2,3]
+    ]
+    @zset.range_by_score(yesterday, now).should == [
+      {'four' => 4},
+      [1,2,3]
+    ]
+    @zset.score("idontexist").should be_nil
+    @zset.should_not include("idontexist")
+    @zset.score({'four' => 4}).to_i.should == yesterday.to_i
+  end
+end

data/vendor/core_ext/init.rb

@@ -0,0 +1,7 @@
+PROJECT_DIR = File.expand_path(File.dirname(__FILE__))
+$:.unshift PROJECT_DIR
+
+Dir[File.join(PROJECT_DIR, 'lib/**')].each do |f|
+  require f
+end
+$:.shift

data/vendor/core_ext/lib/class.rb

@@ -0,0 +1,9 @@
+class Class
+  def soft_alias(new, target)
+    class_eval <<-code
+      def #{new}(*args, &blk)
+        #{target}(*args, &blk)
+      end
+    code
+  end
+end

data/vendor/core_ext/lib/enumerable.rb

@@ -0,0 +1,23 @@
+module Enumerable
+  def to_set
+    require 'set'
+    Set.new(self)
+  end
+
+  # assumes a collection of k-v pairs
+  def to_h
+    Hash[self]
+  end
+
+  def histogram
+    hist = Hash.new(0)
+    self.each do |e|
+      hist[e] += 1
+    end
+    hist
+  end
+
+  def hashmap
+    map { [self, yield(self)] }.to_h
+  end
+end

data/vendor/core_ext/lib/file.rb

@@ -0,0 +1,17 @@
+class File
+  def self.write(filename, content)
+    open(filename, "w") do |f|
+      f.write(content)
+    end
+  end
+
+  def self.append(filename, content)
+    open(filename, "a") do |f|
+      f << content
+    end
+  end
+
+  def self.add_line(filename, content)
+    self.append(filename, content.chomp + $/)
+  end
+end

data/vendor/core_ext/lib/hash.rb

@@ -0,0 +1,46 @@
+class Hash
+  def rmerge!(hsh)
+    hsh.each do |k,v|
+      self[k] = v unless self.has_key? k
+    end
+    self
+  end
+
+  def rmerge(hsh)
+    self.dup.rmerge!(hsh)
+  end
+
+  def accept_options!(hsh)
+    opts_diff = self.keys - hash.keys
+    raise ArgumentError <<-msg.squish unless opts_diff.empty?
+      Unrecognized options #{opts_diff.inspect}
+    msg
+    options.rmerge!(hsh)
+  end
+
+  def accept_options(hsh)
+    self.dup.accept_options!(hsh)
+  end
+
+  def map_keys!
+    keys.each do |k|
+      self[yield(k)] = self.delete(k)
+    end
+    self
+  end
+
+  def map_values!
+    self.each do |k,v|
+      self[k] = v
+    end
+    self
+  end
+
+  def map!
+    self.keys.each do |k|
+      new_k, new_v = yield(k, self.delete(k))
+      self[new_k] = new_v
+    end
+    self
+  end
+end

data/vendor/core_ext/lib/infinity.rb

@@ -0,0 +1 @@
+::Infinity = 1.0/0

data/vendor/core_ext/lib/main.rb

@@ -0,0 +1,11 @@
+# I fixed ruby loadpaths
+def require_local(filename)
+  require File.expand_path(
+    File.join(
+      File.dirname(
+        caller.first.split(':').first
+      ),
+      *filename.split('/')
+    )
+  )
+end

data/vendor/core_ext/lib/object.rb

@@ -0,0 +1,11 @@
+class Object
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  def meta_eval(&blk)
+    self.metaclass.class_eval(&blk)
+  end
+end

data/vendor/core_ext/lib/string.rb

@@ -0,0 +1,32 @@
+class String
+  def match?(regex)
+    self.match(regex) ? true : false
+  end
+
+  def squish!
+    self.strip!.gsub!(/\s+/,' ')
+    self
+  end
+
+  def squish
+    self.dup.squish!
+  end
+
+  def lines
+    self.split($/)
+  end
+
+  def map_parts(delim=$/, &blk)
+    self.split(delim).map(&blk).join(delim)
+  end
+
+  def unchomp!(ch=$/)
+    self.chomp!(ch)
+    self << ch
+    self
+  end
+
+  def unchomp(ch)
+    self.dup.unchomp!(ch)
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: rudis
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Jay Adkisson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-20 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+description: "    Rudis wraps redis-rb in objects that keep track of their own\n    redis instances and keys.\n"
+email: j4yferd@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rudis/structures/set.rb
+- lib/rudis/structures/counter.rb
+- lib/rudis/structures/zset.rb
+- lib/rudis/structures/list.rb
+- lib/rudis/structures/hash.rb
+- lib/rudis/structures/lock.rb
+- lib/rudis/base.rb
+- lib/rudis/structure.rb
+- lib/rudis/type.rb
+- lib/rudis/types/default.rb
+- lib/rudis/types/integer.rb
+- lib/rudis/types/symbol.rb
+- lib/rudis/types/json.rb
+- lib/rudis/types/time.rb
+- lib/rudis.rb
+- spec/base_spec.rb
+- spec/counter_spec.rb
+- spec/set_spec.rb
+- spec/list_spec.rb
+- spec/hash_spec.rb
+- spec/zset_spec.rb
+- vendor/core_ext/init.rb
+- vendor/core_ext/lib/string.rb
+- vendor/core_ext/lib/file.rb
+- vendor/core_ext/lib/object.rb
+- vendor/core_ext/lib/enumerable.rb
+- vendor/core_ext/lib/infinity.rb
+- vendor/core_ext/lib/main.rb
+- vendor/core_ext/lib/hash.rb
+- vendor/core_ext/lib/class.rb
+- init.rb
+- Rakefile
+- README.md
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/jayferd/rudis
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: An extensible OO redis client for ruby
+test_files: []
+