rackdis 0.12.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75c6e66a488ac41277d59ce05e77de10be798f4e
+  data.tar.gz: 492d897a8e9593501e80b27d2d149be707b104ed
+SHA512:
+  metadata.gz: 60a14fb0a27ba95a2e006b540d4e58590be7650729b849e33c3ca12763edef12d1785e537f3671095b226fe4aaae512cdd094e2d99001c84fe6139ed4d873927
+  data.tar.gz: 921643b6b898c0e72b4000233eeaa1312227201745c9bbf3042d90135394670aef9d329daed3717582ae17fba8d0aa7dd20bc7267a48350b23082b267a932da2

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+# Changelog
+
+## 0.12-beta
+
+* refactored the API routes to dedup code, support POST commands
+* added arg parser and response builder
+* added a batch mode through a post request
+* validated commands that come through the redis facade
+* allowed running unsafe commands
+* allowed force enabling commands
+* made the config be setup better
+* added some basic specs
+* rescued all errors to return 500 (temporary)
+* added logging with support for multiple locations/levels
+* fixed option merging bugs
+* added CORS support
+* successfully tested chunked encoded subscribe manually
+
+## 0.6-beta
+
+* used the proper rack commands in the executable script
+* allowed options to be loaded from a config file
+* allowed options to be specified a the command line
+* added support for most set commands (missing `SSCAN`)
+* added support for most list commands (missing blocking commands)
+* added support for `MGET`
+* added support for `PUBLISH`
+* added support for `SUBSCRIBE` over a streaming connection
+
+## 0.0.1
+
+* got the server running
+* added GET and SET commands

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robert McLeod
+
+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,198 @@
+# Rackdis
+
+![](http://i.imgur.com/CDKmIl1.png)
+
+A Ruby clone of the awesome [Webdis](http://webd.is) server, allowing HTTP access to a Redis server through an API.
+
+Webdis is awesome, but it hasn't had much action lately and there are lots of feature requests and bug reports that haven't been addressed.  I would love to contribute but I have no desire in learning C at this stage.  I also think Ruby is awesome so I wanted to try cloning Webdis in Ruby.  Most of the stuff is already written for me, so this project is mostly glue code:
+
+* [Grape](https://github.com/intridea/grape) provides the micro framework necessary to build an API
+* [Slop](https://github.com/leejarvis/slop) awesome command line options
+* [Rack::Stream](https://github.com/intridea/rack-stream) provides the websockets and chunked encoding support
+* [Rack::Cors](https://github.com/cyu/rack-cors) provides cross origin resource sharing
+* [Redis-rb](https://github.com/redis/redis-rb) provides the interface to a redis server
+* [Thin](https://github.com/macournoyer/thin/) serves it all through rack
+
+Most commands should work, there are a few left unsupported. However this code is mostly untested, with specs forthcoming so stuff might not work quite right yet (hence the `-beta`).  I still have work to do in the Argument Parser and Response Builder area so commands that differ from the classic `COMMAND key [arg]` pattern may not work yet.  In this situation you would see a `NotImplementError` reported.
+
+**Please see the issues for feature planning and a vauge roadmap.**
+
+## Features
+
+* Most commands supported
+* Unsafe commands disabled by default
+* Pub/sub over streaming connections (chunked encoding/websockets)
+* Batch processing of multiple redis commands (MULTI/EXEC anyone?)
+* Logging to multiple locations and levels
+* Cross Origin Resource Sharing
+* Flexible command line operation
+* Configuration priority: command line > config file > hard coded defaults
+
+## Todo
+
+* more relevant HTTP codes
+* more specs
+* figure out what MULTI/EXEC is and how to support it
+* a lower level batch mode
+
+## Installation
+
+**Sorry I haven't actually pushed it to rubygems yet**
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rackdis'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rackdis
+
+## Usage
+
+The help screen is a good place to start:
+
+```sh
+$ rackdis --help
+Usage: rackdis [options]
+    -r, --redis               The redis server location (127.0.0.1, :6379, 127.0.0.1:6379)
+    -c, --config              Config file to load options from
+    -p, --port                Port for rackdis to bind to
+    -a, --address             Address for rackdis to bind to
+    -d, --daemonize           Put rackdis in the background
+        --log_level           Log level (shutup, error, warn, debug, info)
+    -l, --log                 Log location (- or stdout for stdout, stderr)
+        --db                  The redis db to use (a number 0 through 16)
+        --allow_unsafe        Enable unsafe commands (things like flushdb) !CAREFUL!
+        --force_enable        Comma separated list of commands to enable !CAREFUL!
+        --allow_batching      Allows batching of commands through a POST request
+    -h, --help                Display this help message.
+```
+
+All of these commands are optional.  The hard coded configuration has sane defaults.  Specifying a configuration file would override those defaults.  Specifying a command line options from above overrides everything.  Speaking of configuration files, here's what one looks like:
+
+```yml
+---
+:port:           7380
+:address:        127.0.0.1
+:daemonize:      false
+:db:             0
+:log:            stdout
+:log_level:      info
+:allow_unsafe:   false
+:force_enable:   false
+:allow_batching: false
+:redis:          127.0.0.1:6379
+```
+
+### Running it
+
+Fully fledged example:
+
+```sh
+rackdis -p 7379 -a 127.0.0.1 -d --allow_batching --allow_unsafe -l stderr --log_level debug --redis :6379 --db 4 --force_enable flushdb,move,migrate,select
+```
+
+Simply load from a config file:
+
+```sh
+rackdis -c config.yml
+```
+
+### Call and response
+
+The pattern looks like this: `http://localhost:7379/:version/:command/*args`
+
+* **version** is just the API version (v1)
+* **command** is the redis command to run
+* everything after that is arguments to the redis command
+
+The response is in JSON and provides some basic information about the request and including the result (of course).
+
+So if I want to get a range from a list: `http://localhost:7380/v1/lrange/shopping_list/4/10`
+
+```json
+{
+  "success":true,
+  "command":"LRANGE",
+  "key":"shopping_list",
+  "result":[ "milk", "chicken abortions", "prophylactics"]
+}
+```
+
+Add some members to a set: `http://localhost:7380/v1/sadd/cars/toyota/nissan/dodge`
+
+```json
+{
+  "success":true,
+  "command":"SADD",
+  "key":"cars",
+  "result":"OK"
+}
+```
+
+Or just get a value: `http://localhost:7380/v1/get/readings:ph`
+
+```json
+{
+  "success":true,
+  "command":"GET",
+  "key":"readings:ph",
+  "result":"7.4"
+}
+```
+
+You get the gist.
+
+### Batching
+
+Batching allows you to get redis to execute a bunch of commands one after the other
+
+```javascript
+$.post(
+  "http://localhost:7380/v1/batch",
+  {
+    commands: [
+      "SET this that",
+      "INCR rickrolls",
+      "SUNIONSTORE anothermans:treasure onemans:trash anothermans:treasure"
+    ]
+  }
+)
+```
+
+That will return this JSON:
+
+```json
+["OK", 45, "OK"]
+```
+
+You will need to enable batching explicitly at command line or in the config file.
+
+### Pub/Sub
+
+Publish/Subscribe is supported over chunked encoding and websockets.
+
+More details forthcoming.
+
+Subscribe: `http://localhost:7380/v1/subscribe/messages`
+
+Publish: `http://localhost:7380/v1/publish/messages/hi`
+
+## Changelog
+
+Please see the file `CHANGELOG.md`
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/rackdis/fork )
+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 a new Pull Request
+6. If it's all good I'll merge it

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rackdis"
+
+task :routes do
+  puts Rackdis::API::routes
+end

data/bin/rackdis

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'rackdis'
+require 'rack'
+require 'slop'
+
+opts = Slop.new help: true, strict: true, indent: 2 do
+  banner "Usage: rackdis [options]"
+  
+  on :r, :redis=,     "The redis server location (127.0.0.1, :6379, 127.0.0.1:6379)"
+  on :c, :config=,    "Config file to load options from"
+  on :p, :port=,      "Port for rackdis to bind to"
+  on :a, :address=,   "Address for rackdis to bind to"
+  on :d, :daemonize,  "Put rackdis in the background"
+  on :log_level=,     "Log level (shutup, error, warn, debug, info)"
+  on :l, :log=,       "Log location (- or stdout for stdout, stderr)"
+  on :db=,            "The redis db to use (a number 0 through 16)"
+  on :allow_unsafe,   "Enable unsafe commands (things like flushdb) !CAREFUL!"
+  on :force_enable=,  "Comma separated list of commands to enable !CAREFUL!", as: Array
+  on :allow_batching, "Allows batching of commands through a POST request"
+end
+
+# Show any errors with the given options
+begin
+  opts.parse!
+  Rackdis.configure(opts.to_hash)
+rescue Slop::Error, ArgumentError => e
+  puts "ERROR: #{e.message}"
+  puts opts
+  abort
+end
+
+app = Rack::Builder.new do
+  use Rack::Stream
+  use Rack::Cors do
+    allow do
+      origins '*'
+      resource '*', headers: :any, methods: :get
+    end
+  end
+  run Rackdis::API.new
+end
+
+Rack::Handler::Thin.run(app, Rackdis.rack_options)

data/etc/config.yml

@@ -0,0 +1,11 @@
+---
+:port:           9342
+:address:        127.0.0.1
+:daemonize:      false
+:db:             0
+:log:            /dev/null
+:log_level:      shutup
+:allow_unsafe:   false
+:force_enable:
+:allow_batching: false
+:redis:          "127.0.0.1:6379"

data/lib/rackdis/api.rb

@@ -0,0 +1,62 @@
+module Rackdis
+  class API < Grape::API
+      
+    
+    rescue_from :all do |e|
+      Rackdis.logger.error("#{e.class.name}: #{e.message}")
+      Rack::Response.new({ success: false, error: e.message }.to_json, 500)
+    end
+    
+    version 'v1'
+    format :json
+
+    helpers do
+      include Rack::Stream::DSL
+      
+      def redis
+        @redis ||= RedisFacade.new(Rackdis.redis_client, Rackdis.config, Rackdis.logger)
+      end
+      
+      def do_subscribe
+        after_open do
+          Rackdis.logger.debug "Someone subscribed to #{params[:channel]}"
+          redis.redis.subscribe params[:channel] do |on|
+            on.message do |channel, msg|
+              Rackdis.logger.debug "Pushing: #{msg}"
+              chunk msg
+            end
+          end
+        end
+        
+        status 200
+        header 'Content-Type', 'application/json'
+        ""
+      end
+      
+      def args
+        params[:args].split("/")
+      end
+    end
+    
+    # Subscribe
+    get 'subscribe/:channel' do
+      do_subscribe
+    end
+    
+    get 'SUBSCRIBE/:channel' do
+      do_subscribe
+    end
+
+    post 'batch' do
+      redis.batch params[:commands]
+    end
+
+    get ':command/*args' do
+      redis.call params[:command], args
+    end
+    
+    post ':command/*args' do
+      redis.call params[:command], args
+    end
+  end
+end

data/lib/rackdis/argument_parser.rb

@@ -0,0 +1,29 @@
+module Rackdis
+  class ArgumentParser
+    def initialize(command)
+      @command = command.to_sym
+    end
+    
+    def process(args)
+      case @command
+      when :lpush, :rpush, :sadd, :srem, :sunionstore, :sinterstore, :sdiffstore
+        [
+          args[0],
+          args[1..-1]
+        ]
+      when :mget, :sunion, :sinter, :sdiff
+        [
+          args[0..-1]
+        ]
+      when :publish
+        [
+          args[0],
+          args[1..-1].join("/")
+        ]
+      else
+        args
+      end
+    end
+    
+  end
+end

data/lib/rackdis/config.rb

@@ -0,0 +1,88 @@
+module Rackdis
+  class Config
+    
+    def self.defaults
+      {
+        port:           7380,
+        address:        "0.0.0.0",
+        daemonize:      false,
+        log:            STDOUT,
+        log_level:      "info",
+        db:             0,
+        allow_unsafe:   false,
+        force_enable:   [],
+        allow_batching: false,
+        redis:          "127.0.0.1:6379"
+      }
+    end
+    
+    def initialize(opts)
+      @config = Config.defaults
+      process_options opts
+      post_process
+    end
+
+    def [](key)
+      @config[key]
+    end
+    
+    private
+    
+    def process_options(opts)
+      load_from_file opts[:config]
+      
+      # We want to merge the command line opts
+      # overtop of the config file options but
+      # only if they are set because when they
+      # are not set they are nil which ends up
+      # wiping out all of the config
+      opts.each do |key, value|
+        next if value.nil?
+        @config[key] = value
+      end
+    end
+    
+    def load_from_file(file)
+      return false if file.nil?
+      raise ArgumentError, "Invalid config file: #{file}" unless File.exist? file
+      @config.merge!(YAML.load_file(file))
+    end
+
+    def post_process
+      process_log
+      process_redis
+    end
+
+    def process_log
+      @config[:log] = case @config[:log]
+      when nil, "", " ", "no", "none"
+        "/dev/null"
+      when "stdout", "-", "STDOUT"
+        STDOUT
+      when "stderr", "STDERR"
+        STDERR
+      else
+        @config[:log]
+      end
+      
+      @config[:log] = "/dev/null" if @config[:log_level] == "shutup"
+    end
+
+    def process_redis
+      if @config[:redis].include? ":"
+        parts = @config[:redis].split(":")
+        port = parts.last
+        host = parts.first
+      else
+        host = @config[:redis]
+      end
+      
+      host = "127.0.0.1" if host.nil? or host.empty?
+      port = 6379 if port.nil? or port.empty?
+      
+      @config[:redis_port] = port
+      @config[:redis_host] = host
+    end
+
+  end
+end

data/lib/rackdis/redis_facade.rb

@@ -0,0 +1,118 @@
+module Rackdis
+  class RedisFacade
+    attr_reader :redis
+    
+    def initialize(redis, config, log)
+      @redis  = redis
+      @config = config
+      @log    = log
+    end
+    
+    def call(command, args)
+      command.downcase!
+      valid_command! command
+      
+      @log.info("redis> #{command} #{args.join(' ')}")
+      args = Rackdis::ArgumentParser.new(command).process(args)
+      
+      @log.debug("API => REDIS: "+{command: command, args: args}.inspect)
+      
+      begin
+        result = @redis.send(command, *args)
+      rescue ArgumentError
+        raise NotImplementedError, "Oops sorry - too beta - this needs fixing.  A bug report at https://github.com/penguinpowernz/rackdis/issues would be nice :)"
+      end
+      
+      return Rackdis::ResponseBuilder.new(command).process(args, result)
+    end
+    
+    def batch(commands)
+      raise ArgumentError, "Batching is disabled" unless @config[:allow_batching]
+      
+      # Try to extract individual commands
+      begin
+        commands = JSON.parse(commands)
+      rescue JSON::ParserError
+        raise ArgumentError, "Invalid batch commands" unless commands.is_a? String
+        commands = commands.split("\n")
+      end
+      
+      raise ArgumentError, "Invalid batch commands" unless commands.is_a? Array
+      
+      # Check each command and their arguments
+      calls = []
+      commands.each do |line|
+        args   = line.split(" ")
+        cmd    = args.shift.downcase.to_sym
+        
+        # bail out if any of the commands or args are bad
+        valid_command!(cmd)
+        args   = Rackdis::ArgumentParser.new(cmd).process(args)
+        
+        calls << [cmd, args]
+      end
+      
+      # Everything passed to run all the commands now
+      calls.collect do |call|
+        result = @redis.send(*call)
+        Rackdis::ResponseBuilder.new(cmd).process(args, result)
+      end
+    end
+
+    # Pub/Sub
+    
+    def publish(channel, message)
+      @redis.publish(channel, message)
+      { success: true, command: :PUBLISH, channel: channel }
+    end
+
+    private
+    
+    def valid_command!(cmd)
+      raise ArgumentError, "Unsupported command: #{command}" unless valid_command?
+    end
+    
+    def valid_command?(cmd)
+      safe_commands.include?(cmd) or
+      (@config[:allow_unsafe] and unsafe_commands.include?(cmd)) or
+      (@config[:force_enable] and @config[:force_enable].include?(cmd))
+    end
+    
+    def safe_commands
+      [
+        :ping, :echo, :dbsize, :time,
+        :persist, :expire, :expireat, :ttl, :pexpire, :pexpireat, :pttl, :dump, :restore,
+        :set, :setex, :psetex, :setnx, :mset, :msetnx, :setrange, :append,
+        :get, :getset, :mget, :getrange,
+        :getbit, :setbit, :bitcount, :bitop, :bitpos,
+        :incr, :incrby, :incrbyfloat, :decr, :decrby, :del, :exists, :keys, :randomkey, :rename, :renamex, :sort, :type, :strlen, :scan,
+        :lpush, :lpushx, :rpush, :rpushx, :lrange, :lindex, :linsert, :llen, :lpop, :rpop, :rpoplpush, :lrem, :lset, :ltrim,
+        :sadd, :scard, :smembers, :sismember, :srem, :sinter, :sinterstore, :sdiff, :sdiffstore, :sunion, :sunionstore, :spop, :srandmember, :smove, :sscan,
+        :zcard, :zadd, :zincrby, :zrem, :zscore, :zrange, :zrevrange, :zrank, :zrevrank, :zremrangebyrank, :zrangebylex, :zrangebyscore, :zrevrangebyscore, :zremrangebyscore, :zcount, :zinterstore, :zunionstore, :zsan,
+        :hlen, :hset, :hsetnx, :hmset, :hget, :hmget, :hdel, :hexists, :hincrby, :hincrbyfloat, :hkeys, :hvals, :hgetall, :hscan,
+        :publish,
+        :pfadd, :pfcount, :pfmerge
+      ]
+    end
+    
+    def unsafe_commands
+      [
+        :auth, :info, :slowlog,
+        :bgrewriteaof, :bgsave, :lastsave, :save,
+        :config, :flushall, :flushdb,
+        :move, :migrate, :select, :slaveof,
+        :script, :eval, :evalsha
+      ]
+    end
+
+    # TODO: investigate and support these
+    # def unsupported_commmands
+    #   [
+    #     :monitor,
+    #     :unsubscribe, :psubscribe, :punsubscribe,
+    #     :brpop, :blpop, :brpoplpush
+    #   ]
+    # end
+
+  end
+end

data/lib/rackdis/response_builder.rb

@@ -0,0 +1,22 @@
+module Rackdis
+  class ResponseBuilder
+    def initialize(command)
+      @command = command.to_sym
+    end
+    
+    def process(args, result)
+      response_hash = {
+        command: @command.to_s.upcase,
+        result: result
+      }
+      
+      case @command
+      when :sinterstore
+      else
+        response_hash[:key] = args[0]
+      end
+      
+      response_hash
+    end
+  end
+end

data/lib/rackdis/version.rb

@@ -0,0 +1,3 @@
+module Rackdis
+  VERSION = "0.12-beta"
+end

data/lib/rackdis.rb

@@ -0,0 +1,76 @@
+require "logger"
+require "yaml"
+require "json"
+require "redis"
+require "grape"
+require "redis/connection/synchrony"
+require "rack/stream"
+require "rack/cors"
+
+require "rackdis/version"
+require "rackdis/api"
+require "rackdis/redis_facade"
+require "rackdis/config"
+require "rackdis/argument_parser"
+require "rackdis/response_builder"
+
+module Rackdis
+  class << self
+    attr_reader :config
+    
+    def configure(**opts)
+      @config = Rackdis::Config.new(opts)
+    end
+    
+    def rack_options
+      {
+        Port: @config[:port],
+        Host: @config[:address],
+        daemonize: @config[:daemonize]
+      }
+    end
+    
+    def redis_options
+      {
+        host: @config[:redis_host],
+        port: @config[:redis_port],
+        db: @config[:db] || 0
+      }
+    end
+    
+    def redis_client
+      Redis.new redis_options
+    end
+
+    def allow_unsafe_commands?
+      @config[:unsafe] || false
+    end
+    
+    def logger
+      @logger ||= create_logger
+    end
+    
+    def create_logger
+      logger = Logger.new @config[:log] || STDOUT
+      
+      if @config
+        logger.level = case @config[:log_level]
+        when "debug"
+          Logger::DEBUG
+        when "info"
+          Logger::INFO
+        when "error"
+          Logger::ERROR
+        when "warn"
+          Logger::WARN
+        else
+          Logger::UNKNOWN # shutup!
+        end
+      else
+        logger.log_level = Logger::UNKNOWN
+      end
+      
+      logger
+    end
+  end
+end

data/rackdis.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rackdis/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rackdis"
+  spec.version       = Rackdis::VERSION
+  spec.authors       = ["Robert McLeod"]
+  spec.email         = ["robert@penguinpower.co.nz"]
+  spec.summary       = %q{Ruby clone of Webdis Redis web API}
+  spec.description   = %q{A Ruby clone of the awesome Webdis Redis web API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rack"
+  spec.add_dependency "hiredis"
+  spec.add_dependency "redis"
+  spec.add_dependency "grape"
+  spec.add_dependency "rack-stream"
+  spec.add_dependency "em-synchrony"
+  spec.add_dependency "slop"
+  spec.add_dependency "thin"
+  spec.add_dependency "rack-cors"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "pry"
+end

data/spec/api_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Rackdis::API do
+  include Rack::Test::Methods
+  
+  subject(:response) { j2o last_response.body }
+  let(:r)            { redis_connection }
+  let(:key)          { "test:hello" }
+  after(:each)       { r.del key }
+  
+  describe "Key operations" do
+    
+    describe "GET" do
+      it "should give null for unset values" do
+        get "/v1/get/#{key}"
+        expect(response.result).to eq nil
+      end
+      
+      it "should get a value that is set" do
+        r.set(key, "world")
+        # pry
+        get "/v1/get/#{key}"
+        expect(response.result).to eq "world"
+      end
+    
+    end
+    
+    describe "SET" do
+      it "should set a value" do
+        get "/v1/set/#{key}/world"
+        expect(r.get(key)).to eq "world"
+      end
+      
+      it "should override a key" do
+        get "/v1/set/#{key}/world"
+        get "/v1/set/#{key}/bob"
+        expect(r.get(key)).to eq "bob"
+      end
+    end
+    
+    describe "INCR" do
+      it "should increment a value" do
+        get "/v1/incr/#{key}"
+        get "/v1/incr/#{key}"
+        get "/v1/incr/#{key}"
+        expect(r.get key).to eq "3"
+      end
+      
+      it "should return the incremented value" do
+        get "/v1/incr/#{key}"
+        get "/v1/incr/#{key}"
+        get "/v1/incr/#{key}"
+        expect(response.result).to eq 3
+      end
+    end
+  end
+  
+  describe "Sets operations" do
+    
+    describe "SMEMBERS" do
+      
+      context "when there are no memebers" do
+        it "should return an empty array" do
+          get "/v1/smembers/#{key}"
+          expect(response.result).to eq []
+        end
+      end
+      
+      context "when there are members" do
+        it "should return them" do
+          r.sadd key, "world"
+          get "/v1/smembers/#{key}"
+          expect(response.result).to eq ["world"]
+        end
+      end
+      
+    end
+    
+    describe "SADD" do
+      
+      it "should add single member" do
+        expect { get "/v1/sadd/#{key}/world" }.to change { r.scard key }.by(1)
+      end
+      
+      it "should add multiple members" do
+        expect { get "/v1/sadd/#{key}/tom/dick/harry" }.to change { r.scard key }.by(3)
+      end
+      
+    end
+  end
+end

data/spec/lib/rackdis/argument_parser_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Rackdis::ArgumentParser do
+  subject(:parser) { Rackdis::ArgumentParser.new(command) }
+  
+  
+  describe "PUBLISH" do
+    let(:command) { "publish" }
+    
+    it "should not modify the correct number of args" do
+      inn = ["channel", "hi there"]
+      out = parser.process(inn)
+      expect(out).to eq inn
+    end
+    
+    it "should join the message args together" do
+      inn = ["channel", "she was about 18", "19"]
+      out = parser.process(inn)
+      expect(out.size).to eq 2
+      expect(out[1]).to eq "she was about 18/19"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+require 'rack/test'
+require 'pry'
+require 'ostruct'
+require 'bundler/setup'
+Bundler.setup
+
+require 'rackdis'
+
+# Set test options
+Rackdis.configure(db: 13)
+
+# give a seperate redis connection to the same
+# database but use the hiredis driver to stop
+# errors about the evma server
+def redis_connection
+  Redis.new driver: :hiredis, db: 13
+end
+
+# Helpers for testing the action api
+
+def app
+  Rackdis::API
+end
+
+def j2o(json)
+  OpenStruct.new(JSON.parse(json))
+end

metadata

@@ -0,0 +1,263 @@
+--- !ruby/object:Gem::Specification
+name: rackdis
+version: !ruby/object:Gem::Version
+  version: 0.12.pre.beta
+platform: ruby
+authors:
+- Robert McLeod
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-stream
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: em-synchrony
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-cors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby clone of the awesome Webdis Redis web API
+email:
+- robert@penguinpower.co.nz
+executables:
+- rackdis
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/rackdis
+- etc/config.yml
+- lib/rackdis.rb
+- lib/rackdis/api.rb
+- lib/rackdis/argument_parser.rb
+- lib/rackdis/config.rb
+- lib/rackdis/redis_facade.rb
+- lib/rackdis/response_builder.rb
+- lib/rackdis/version.rb
+- rackdis.gemspec
+- spec/api_spec.rb
+- spec/lib/rackdis/argument_parser_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby clone of Webdis Redis web API
+test_files:
+- spec/api_spec.rb
+- spec/lib/rackdis/argument_parser_spec.rb
+- spec/spec_helper.rb