sinatra-redis 0.1.0

data/README.md

@@ -0,0 +1,48 @@
+Sinatra Redis Extension
+========================
+
+Extends [Sinatra](http://www.sinatrarb.com/) with an extension method for
+dealing with redis databases using the rubyredis.rb client library that
+comes with the redis source (pre-packaged with this library for convenience).
+
+Install the `sinatra-redis` with rip. No gem support yet.
+
+    $ rip install git://github.com/bmizerany/sinatra-redis.git
+    $ vim sinatra-using-redis.rb
+
+    require 'sinatra'
+    require 'sinatra/redis'
+
+    # Establish the database connection; or, omit this and use the REDIS_URL
+    # environment variable as the connection string; or, default to redis://locahost:6379/0
+    #
+    # NOTE: The database is the integer in the path
+    # set :redis, 'redis://some-remote-server:1234/5' 
+
+    # At this point, you can access the Redis object using the "redis" object:
+    puts redis.delete "foos"
+    puts redis.rpush "foos", "redis"
+    puts redis.rpush "foos", "is"
+    puts redis.rpush "foos", "sweet!"
+
+    # access redis within the context of an HTTP request
+    get '/foos' do
+      @foos = redis.lrange("foos", 0, -1) # Array
+      @foos.inspect
+    end
+
+    $ ruby sinatra-using-redis.rb
+
+### Redis Reference Material
+
+  * The [Redis Wiki](http://code.google.com/p/redis/)
+
+  * The [Redis Command Reference](http://code.google.com/p/redis/wiki/CommandReference)
+
+  * The [Redis Source](http://github.com/antirez/redis)
+
+  * Ezra's Mountain West Ruby Conf '09 [Talk](http://mwrc2009.confreaks.com/13-mar-2009-19-24-redis-key-value-nirvana-ezra-zygmuntowicz.html)
+
+### NOTE about the rip-off
+
+  This Code and README.md is a heavy adaption of [rtomayko's sinatra-sequel](http://github.com/rtomayko/sinatra-sequel/)

data/lib/sinatra/redis.rb

@@ -0,0 +1,38 @@
+require 'uri'
+require 'sinatra/redis/rubyredis'
+
+module Sinatra
+  module RedisHelper
+    def redis
+      options.redis
+    end
+  end
+
+  module RedisExtension
+    def redis=(url)
+      @redis = nil
+      set :redis_url, url
+      redis
+    end
+
+    def redis
+      url = URI(redis_url)
+      @redis ||=
+        RedisClient.new(
+          :host => url.host,
+          :port => url.port,
+          :db => url.path[1..-1],
+          :pass => url.password
+        )
+    end
+
+  protected
+
+    def self.registered(app)
+      app.set :redis_url, ENV['REDIS_URL'] || "redis://127.0.0.1:6379/0"
+      app.helpers RedisHelper
+    end
+  end
+
+  register RedisExtension
+end

data/lib/sinatra/redis/rubyredis.rb

@@ -0,0 +1,243 @@
+# NOTE: This library is packaged with sinatra-redis for
+# convenence.  It's been copied from the redis repo.
+
+# RubyRedis is an alternative implementatin of Ruby client library written
+# by Salvatore Sanfilippo.
+#
+# The aim of this library is to create an alternative client library that is
+# much simpler and does not implement every command explicitly but uses
+# method_missing instead.
+
+require 'socket'
+require 'set'
+
+begin
+    if (RUBY_VERSION >= '1.9')
+        require 'timeout'
+        RedisTimer = Timeout
+    else
+        require 'system_timer'
+        RedisTimer = SystemTimer
+    end
+rescue LoadError
+    RedisTimer = nil
+end
+
+class RedisClient
+    BulkCommands = {
+        "set"=>true, "setnx"=>true, "rpush"=>true, "lpush"=>true, "lset"=>true,
+        "lrem"=>true, "sadd"=>true, "srem"=>true, "sismember"=>true,
+        "echo"=>true, "getset"=>true, "smove"=>true
+    }
+
+    ConvertToBool = lambda{|r| r == 0 ? false : r}
+
+    ReplyProcessor = {
+        "exists" => ConvertToBool,
+        "sismember"=> ConvertToBool,
+        "sadd"=> ConvertToBool,
+        "srem"=> ConvertToBool,
+        "smove"=> ConvertToBool,
+        "move"=> ConvertToBool,
+        "setnx"=> ConvertToBool,
+        "del"=> ConvertToBool,
+        "renamenx"=> ConvertToBool,
+        "expire"=> ConvertToBool,
+        "keys" => lambda{|r| r.split(" ")},
+        "info" => lambda{|r| 
+            info = {}
+            r.each_line {|kv|
+                k,v = kv.split(":",2).map{|x| x.chomp}
+                info[k.to_sym] = v
+            }
+            info
+        }
+    }
+
+    Aliases = {
+        "flush_db" => "flushdb",
+        "flush_all" => "flushall",
+        "last_save" => "lastsave",
+        "key?" => "exists",
+        "delete" => "del",
+        "randkey" => "randomkey",
+        "list_length" => "llen",
+        "push_tail" => "rpush",
+        "push_head" => "lpush",
+        "pop_tail" => "rpop",
+        "pop_head" => "lpop",
+        "list_set" => "lset",
+        "list_range" => "lrange",
+        "list_trim" => "ltrim",
+        "list_index" => "lindex",
+        "list_rm" => "lrem",
+        "set_add" => "sadd",
+        "set_delete" => "srem",
+        "set_count" => "scard",
+        "set_member?" => "sismember",
+        "set_members" => "smembers",
+        "set_intersect" => "sinter",
+        "set_intersect_store" => "sinterstore",
+        "set_inter_store" => "sinterstore",
+        "set_union" => "sunion",
+        "set_union_store" => "sunionstore",
+        "set_diff" => "sdiff",
+        "set_diff_store" => "sdiffstore",
+        "set_move" => "smove",
+        "set_unless_exists" => "setnx",
+        "rename_unless_exists" => "renamenx"
+    }
+
+    def initialize(opts={})
+        @host = opts[:host] || '127.0.0.1'
+        @port = opts[:port] || 6379
+        @db = opts[:db] || 0
+        @timeout = opts[:timeout] || 0
+        @pass = opts[:pass] || ""
+        connect_to_server
+    end
+
+    def to_s
+        "Redis Client connected to #{@host}:#{@port} against DB #{@db}"
+    end
+
+    def connect_to_server
+        @sock = connect_to(@host,@port,@timeout == 0 ? nil : @timeout)
+        call_command(["auth",@pass]) if !@pass.empty?
+        call_command(["select",@db]) if @db != 0
+    end
+
+    def connect_to(host, port, timeout=nil)
+        # We support connect() timeout only if system_timer is availabe
+        # or if we are running against Ruby >= 1.9
+        # Timeout reading from the socket instead will be supported anyway.
+        if @timeout != 0 and RedisTimer
+            begin
+                sock = TCPSocket.new(host, port, 0)
+            rescue Timeout::Error
+                @sock = nil
+                raise Timeout::Error, "Timeout connecting to the server"
+            end
+        else
+            sock = TCPSocket.new(host, port, 0)
+        end
+        sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+        # If the timeout is set we set the low level socket options in order
+        # to make sure a blocking read will return after the specified number
+        # of seconds. This hack is from memcached ruby client.
+        if timeout
+            secs = Integer(timeout)
+            usecs = Integer((timeout - secs) * 1_000_000)
+            optval = [secs, usecs].pack("l_2")
+            sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
+            sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
+        end
+        sock
+    end
+
+    def method_missing(*argv)
+        call_command(argv)
+    end
+
+    def call_command(argv)
+        # this wrapper to raw_call_command handle reconnection on socket
+        # error. We try to reconnect just one time, otherwise let the error
+        # araise.
+        connect_to_server if !@sock
+        begin
+            raw_call_command(argv)
+        rescue Errno::ECONNRESET
+            @sock.close
+            connect_to_server
+            raw_call_command(argv)
+        end
+    end
+
+    def raw_call_command(argv)
+        bulk = nil
+        argv[0] = argv[0].to_s.downcase
+        argv[0] = Aliases[argv[0]] if Aliases[argv[0]]
+        if BulkCommands[argv[0]] and argv.length > 1
+            bulk = argv[-1].to_s
+            argv[-1] = bulk.length
+        end
+        @sock.write(argv.join(" ")+"\r\n")
+        @sock.write(bulk+"\r\n") if bulk
+
+        # Post process the reply if needed
+        processor = ReplyProcessor[argv[0]]
+        processor ? processor.call(read_reply) : read_reply
+    end
+
+    def select(*args)
+        raise "SELECT not allowed, use the :db option when creating the object"
+    end
+
+    def [](key)
+        get(key)
+    end
+
+    def []=(key,value)
+        set(key,value)
+    end
+
+    def sort(key, opts={})
+        cmd = []
+        cmd << "SORT #{key}"
+        cmd << "BY #{opts[:by]}" if opts[:by]
+        cmd << "GET #{[opts[:get]].flatten * ' GET '}" if opts[:get]
+        cmd << "#{opts[:order]}" if opts[:order]
+        cmd << "LIMIT #{opts[:limit].join(' ')}" if opts[:limit]
+        call_command(cmd)
+    end
+
+    def incr(key,increment=nil)
+        call_command(increment ? ["incrby",key,increment] :  ["incr",key])
+    end
+
+    def decr(key,decrement=nil)
+        call_command(decrement ? ["decrby",key,decrement] :  ["decr",key])
+    end
+
+    def read_reply
+        # We read the first byte using read() mainly because gets() is
+        # immune to raw socket timeouts.
+        begin
+            rtype = @sock.read(1)
+        rescue Errno::EAGAIN
+            # We want to make sure it reconnects on the next command after the
+            # timeout. Otherwise the server may reply in the meantime leaving
+            # the protocol in a desync status.
+            @sock = nil
+            raise Errno::EAGAIN, "Timeout reading from the socket"
+        end
+
+        raise Errno::ECONNRESET,"Connection lost" if !rtype
+        line = @sock.gets
+        case rtype
+        when "-"
+            raise "-"+line.strip
+        when "+"
+            line.strip
+        when ":"
+            line.to_i
+        when "$"
+            bulklen = line.to_i
+            return nil if bulklen == -1
+            data = @sock.read(bulklen)
+            @sock.read(2) # CRLF
+            data
+        when "*"
+            objects = line.to_i
+            return nil if bulklen == -1
+            res = []
+            objects.times {
+                res << read_reply
+            }
+            res
+        else
+            raise "Protocol error, got '#{rtype}' as initial reply byte"
+        end
+    end
+end

data/sinatra-redis.gemspec

@@ -0,0 +1,33 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.name = 'sinatra-redis'
+  s.version = '0.1.0'
+  s.date = '2009-09-21'
+
+  s.description = "Extends Sinatra with redis helpers for instant redis use"
+  s.summary = s.description
+
+  s.authors = ["Blake Mizerany"]
+  s.email = "blake.mizerany@gmail.com"
+
+  # = MANIFEST =
+  s.files = %w[
+    README.md
+    lib/sinatra/redis.rb
+    lib/sinatra/redis/rubyredis.rb
+    sinatra-redis.gemspec
+  ]
+  # = MANIFEST =
+
+  s.extra_rdoc_files = %w[README.md]
+  s.add_dependency 'sinatra',    '>= 0.9.4'
+
+  s.has_rdoc = true
+  s.homepage = "http://github.com/rtomayko/sinatra-redis"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sinatra::Redis"]
+  s.require_paths = %w[lib]
+  s.rubyforge_project = 'bmizerany'
+  s.rubygems_version = '1.1.1'
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-redis
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Blake Mizerany
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-21 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+description: Extends Sinatra with redis helpers for instant redis use
+email: blake.mizerany@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- lib/sinatra/redis.rb
+- lib/sinatra/redis/rubyredis.rb
+- sinatra-redis.gemspec
+has_rdoc: true
+homepage: http://github.com/rtomayko/sinatra-redis
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Sinatra::Redis
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: bmizerany
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 2
+summary: Extends Sinatra with redis helpers for instant redis use
+test_files: []
+