wave_box 0.4.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+
+*.swp

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in wavebox.gemspec
+gemspec
+
+gem 'redis'
+
+group :development do
+  gem 'guard'
+  gem 'guard-minitest'
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+  gem 'growl'
+  gem 'mock_redis'
+end

data/Guardfile

@@ -0,0 +1,14 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'minitest', :colour => true do
+  # with Minitest::Unit
+  watch(%r|^test/test_(.*)\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+
+  # with Minitest::Spec
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)\.rb|)            { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/README.md

@@ -0,0 +1,71 @@
+# WaveBox
+
+A redis-based messaging system
+
+inspired by [Tumblr Staircar](http://engineering.tumblr.com/post/7819252942/staircar-redis-powered-notifications)
+
+## Features
+
+* Easy to use
+* Works well with redis presharding
+* Simple memory usage control
+* Tested in production environment
+
+## Example
+
+```ruby
+require 'wave_box'
+
+class User
+  include ::WaveBox::GenerateWave
+  include ::WaveBox::ReceiveWave
+
+  can_generate_wave :name => "message",
+                    :redis => :wave_redis_instance,
+                    # waves with timestamp older than expire will be discarded
+                    :expire => 60 * 60 * 24 * 7, # One week
+                    # only store last 20 waves
+                    :max_size => 20,
+                    :id => :wave_box_id
+
+  can_receive_wave :name => "message",
+                   :redis => :wave_redis_instance,
+                   :expire => 60 * 60 * 24 * 7, # One week
+                   :max_size => 20,
+                   :id => :wave_box_id
+
+  def wave_redis_instance
+    Redis.new # return a redis instance
+  end
+
+  def wave_box_id
+    self.id
+  end
+end
+
+sender = User.new
+# => #<User:0x007f85631b9a50>
+receiver = User.new
+# => #<User:0x007f85631cf940>
+
+# Send a wave from sender to receiver
+sender.generate_message "hi", receiver
+
+# Find all message waves in sender's outbox
+sender.generated_message_after(0)
+# => ["hi"]
+
+# Find all message waves in receiver's inbox
+receiver.received_message_after(0)
+# => ["hi"]
+```
+
+## Install
+
+```
+gem install wave_box
+```
+
+## License
+
+the [MIT License](http://www.opensource.org/licenses/MIT).

data/Rakefile

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

data/lib/wave_box/box.rb

@@ -0,0 +1,60 @@
+module WaveBox
+  class Box
+    attr_reader :expire, :max_size
+
+    def initialize(options)
+      @options = options
+      @expire = options[:expire]
+      @max_size = options[:max_size]
+      @redis = options[:redis]
+      @key = options[:key]
+      @encode = options[:encode]
+    end
+
+    def push(value, time = Time.now)
+      if @encode == false
+        v = value
+      else
+        v = encode(value)
+      end
+      @redis.zadd(@key, time.to_i, v)
+
+      truncate!
+    end
+
+    def size
+      @redis.zcard @key
+    end
+
+    def after(time)
+      items = @redis.zrangebyscore( @key, "#{time.to_i}", "+inf")
+
+      if @encode == false
+        items
+      else
+        items.map { |x| decode(x) }
+      end
+    end
+
+    private
+
+    # TODO: Current encode/decode solution sucks,
+    # it create too much storage overhead
+    def encode(str)
+      "#{str}:#{Time.now.to_i}:#{box_counter}"
+    end
+
+    def decode(str)
+      str.split(':')[0..-3].join(':')
+    end
+
+    def box_counter
+      @redis.incr("#{@key}:counter")
+    end
+
+    def truncate!
+      @redis.zremrangebyscore( @key, 0, (Time.now - @expire).to_f ) if @expire
+      @redis.zremrangebyrank( @key, 0, -1*(@max_size + 1) ) if @max_size
+    end
+  end
+end

data/lib/wave_box/generate_wave.rb

@@ -0,0 +1,86 @@
+module WaveBox
+  module GenerateWave
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /generated_(\w+)_after/
+        generated_after( $1, *args )
+      elsif method.to_s =~ /generate_(\w+)/
+        generate( $1, *args)
+      else
+        super
+      end
+    end
+
+    # method missing with good manner
+    def respond_to_missing?(method, *)
+      (method =~ /generated_(\w+)_after/) || (method =~ /generate_(\w+)/) || super
+    end
+
+    def generate(name, wave, receiver, time = Time.now, options = {})
+      send("#{name}_outbox").push wave, time unless options[:outbox] == false
+
+      if receiver.respond_to? :each
+        receiver.each do |rec|
+          rec.receive(name, wave, time)
+        end
+      else
+        receiver.receive(name, wave, time)
+      end
+    end
+
+    def generated_after(name, time)
+      send("#{name}_outbox").after(time)
+    end
+
+    module ClassMethods
+      def can_generate_wave(config)
+        raise ArgumentError, "Missing redis" unless config[:redis]
+        raise ArgumentError, "Missing id lambda" unless config[:id]
+        raise ArgumentError, "Missing wave name" unless config[:name]
+
+        name = config[:name]
+        [:redis, :expire, :max_size, :encode].each do |c|
+          define_method "#{name}_outbox_#{c}" do config[c] end
+        end
+
+        if config[:redis].is_a? Symbol
+          class_eval <<-RUBY
+            def #{name}_outbox_redis_instance
+              send( "#{config[:redis]}" )
+            end
+          RUBY
+        else
+          define_method "#{name}_outbox_redis_instance" do config[:redis] end
+        end
+
+        if config[:id].is_a? Symbol
+          class_eval <<-RUBY
+            def #{name}_outbox_id
+              send("#{config[:id]}")
+            end
+          RUBY
+        else
+          define_method "#{name}_outbox_id" do config[:redis] end
+        end
+
+        define_method "#{name}_outbox_key" do "wave:#{name}:outbox:#{send("#{name}_outbox_id")}" end
+
+        class_eval <<-RUBY
+          def #{name}_outbox
+            @#{name}_outbox ||= WaveBox::Box.new({
+                                :encode => #{name}_outbox_encode,
+                                :redis => #{name}_outbox_redis_instance,
+                                :key => #{name}_outbox_key,
+                                :expire => #{name}_outbox_expire,
+                                :max_size => #{name}_outbox_max_size})
+          end
+        RUBY
+
+      end
+    end
+
+    def self.included(host)
+      host.extend ClassMethods
+    end
+
+  end
+end

data/lib/wave_box/receive_wave.rb

@@ -0,0 +1,73 @@
+module WaveBox
+  module ReceiveWave
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /received_(\w+)_after/
+        received_after( $1, *args )
+      elsif method.to_s =~ /receive_(\w+)/
+        receive( $1, *args)
+      else
+        super
+      end
+    end
+
+    def receive(name, wave, time = Time.now)
+      send("#{name}_inbox").push(wave, time)
+    end
+
+    def received_after(name, time)
+      send("#{name}_inbox").after(time)
+    end
+
+    module ClassMethods
+      def can_receive_wave(config)
+        raise ArgumentError, "Missing redis config" unless config[:redis]
+        raise ArgumentError, "Missing id lambda" unless config[:id]
+        raise ArgumentError, "Missing wave name" unless config[:name]
+
+        name = config[:name]
+
+        [:expire, :max_size, :encode].each do |c|
+          define_method "#{name}_inbox_#{c}" do config[c] end
+        end
+
+        if config[:redis].is_a? Symbol
+          class_eval <<-RUBY
+            def #{name}_inbox_redis_instance
+              send("#{config[:redis]}")
+            end
+          RUBY
+        else
+          define_method "#{name}_inbox_redis_instance" do config[:redis] end
+        end
+
+        if config[:id].is_a? Symbol
+          class_eval <<-RUBY
+            def #{name}_inbox_id
+              send("#{config[:id]}")
+            end
+          RUBY
+        else
+          define_method "#{name}_inbox_id" do config[:redis] end
+        end
+
+        define_method "#{name}_inbox_key" do "wave:#{name}:inbox:#{send("#{name}_inbox_id")}" end
+
+        class_eval <<-RUBY
+          def #{name}_inbox
+            @#{name}_inbox ||= WaveBox::Box.new({
+                                  :redis => #{name}_inbox_redis_instance,
+                                  :key => #{name}_inbox_key,
+                                  :encode => #{name}_inbox_encode,
+                                  :expire => #{name}_inbox_expire,
+                                  :max_size => #{name}_inbox_max_size})
+          end
+        RUBY
+      end
+    end
+
+    def self.included(host)
+      host.extend ClassMethods
+    end
+
+  end
+end

data/lib/wave_box/version.rb

@@ -0,0 +1,3 @@
+module WaveBox
+  VERSION = "0.4.0"
+end

data/lib/wave_box.rb

@@ -0,0 +1,5 @@
+require 'wave_box/receive_wave'
+require "wave_box/generate_wave"
+require "wave_box/box"
+
+require "redis"

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require "minitest/mock"
+require "wave_box"
+require 'minitest/unit'
+require 'minitest/pride'

data/spec/wave_box/box_spec.rb

@@ -0,0 +1,89 @@
+require 'mock_redis'
+require 'spec_helper'
+
+describe WaveBox::Box do
+  describe "A box without limit" do
+    before do
+      @box = WaveBox::Box.new :redis => MockRedis.new,
+                               :key => "test_key"
+    end
+
+    it "should save pushed item" do
+      @box.push(1)
+
+      @box.size.must_equal 1
+    end
+
+    it "should return pushed items based on a timestamp" do
+      @box.push("foo")
+
+      @box.after(0).size.must_equal 1
+      @box.after(0)[0].must_equal "foo"
+    end
+
+    it "should able to handle two identical items in a single box" do
+      @box.push("foo")
+      @box.push("foo")
+
+      @box.after(0).size.must_equal 2
+      @box.after(0).each { |x| x.must_equal "foo" }
+    end
+
+    it "should not truncate any item" do
+      100.times { @box.push "foo" }
+
+      @box.size.must_equal 100
+
+      @box.push "bar", Time.now - 10000
+      @box.after(0)[0].must_equal "bar"
+    end
+  end
+
+  describe "A box with limit" do
+    before do
+      @max_size = 10
+      @expire = 10*60
+      @box_with_limit = WaveBox::Box.new({
+                                    :redis => MockRedis.new,
+                                    :key => "test_key",
+                                    :expire => @expire,
+                                    :max_size => @max_size })
+    end
+
+    it "should know its limit" do
+      @box_with_limit.max_size.must_equal @max_size
+      @box_with_limit.expire.must_equal @expire
+    end
+
+    it "should truncate items over max size limit" do
+      20.times { @box_with_limit.push("foo") }
+
+      @box_with_limit.size.must_equal @max_size
+    end
+
+    it "should truncate items over expire time" do
+      @box_with_limit.push "foo", Time.now - (@expire + 10)
+
+      @box_with_limit.size.must_equal 0
+    end
+  end
+
+  describe "A box can be set to not encode items" do
+    before do
+      @box = WaveBox::Box.new({
+                              :redis => MockRedis.new,
+                              :key => "test_key",
+                              :expire => 10*60,
+                              :max_size => 10,
+                              :encode => false})
+    end
+
+    it "should not be able to handle two identical items in a single box" do
+      @box.push("foo")
+      @box.push("foo")
+
+      @box.after(0).size.must_equal 1
+    end
+  end
+
+end

data/spec/wave_box/generate_wave_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+require "mock_redis"
+
+describe WaveBox::GenerateWave do
+  it "should raise an ArgumentError if no wave name is given" do
+    lambda do
+      class A
+        include WaveBox::GenerateWave
+
+        can_generate_wave :id => :box_id,
+                          :redis => MockRedis.new
+      end
+    end.must_raise ArgumentError
+  end
+
+  it "should raise an argument error if no redis config is given" do
+    lambda do
+      class A
+        include WaveBox::GenerateWave
+
+        can_generate_wave :id => :box_id,
+                          :name => "message"
+      end
+    end.must_raise ArgumentError
+  end
+
+  it "should raise an ArgumentError if no box_id config is given" do
+    lambda do
+      class A
+        include WaveBox::GenerateWave
+
+        can_generate_wave :redis => MockRedis.new,
+                          :name => "message"
+      end
+    end.must_raise ArgumentError
+  end
+
+  it "Can accept a symbol as redis parameter" do
+    class Sender
+      include WaveBox::GenerateWave
+
+      can_generate_wave :name => "message",
+                        :redis => :dynamic_instance,
+                        :expire => 60*10,
+                        :max_size => 10,
+                        # You have to specify a box id which
+                        # is unique among all receiver
+                        :id => :box_id
+
+      def dynamic_instance
+        return MockRedis.new
+      end
+
+      def box_id
+        object_id
+      end
+    end
+
+    class Receiver
+      include WaveBox::ReceiveWave
+
+      can_receive_wave :name => "message",
+                       :redis => :dynamic_instance,
+                       :expire => 60*10,
+                       :max_size => 10,
+                       # You have to specify a box id which
+                       # is unique among all receiver
+                       :id => :box_id
+      def dynamic_instance
+        return MockRedis.new
+      end
+
+      def box_id
+        object_id
+      end
+    end
+
+    s = Sender.new
+    r = Receiver.new
+
+    s.message_outbox.wont_be_nil
+    s.generate_message "foo", r
+
+    s.generated_message_after(0).size.must_equal 1
+    r.received_message_after(0).size.must_equal 1
+  end
+
+  describe "A normal generator usage" do
+    before do
+      class User
+        include WaveBox::GenerateWave
+
+        can_generate_wave :name => "message",
+                          :redis => MockRedis.new,
+                          :expire => 60*10,
+                          :max_size => 10,
+                          # You have to specify a box id which
+                          # is unique among all receiver
+                          :id => :box_id
+
+        def box_id
+          object_id
+        end
+      end
+
+      @user = User.new
+    end
+
+    it "should have an outbox with name" do
+      @user.message_outbox.wont_be_nil
+    end
+
+    it "should save the box id lambda and call it when needed" do
+      @user.message_outbox_id.must_equal @user.object_id
+    end
+
+    describe "Sending wave" do
+      before do
+        class Receiver
+          include WaveBox::ReceiveWave
+
+          can_receive_wave :name => "message",
+                           :redis => MockRedis.new,
+                           :expire => 60*10,
+                           :max_size => 10,
+                           # You have to specify a box id which
+                           # is unique among all receiver
+                           :id => :box_id
+
+          def box_id
+            object_id
+          end
+        end
+        @receiver = Receiver.new
+        @wave = "foo"
+      end
+
+      it "should be able to send wave to a receiver" do
+        @user.generate "message", @wave, @receiver
+
+        @user.message_outbox.size.must_equal 1
+        @user.message_outbox.after(0)[0].must_equal @wave
+
+        @receiver.message_inbox.size.must_equal 1
+        @receiver.message_inbox.after(0)[0].must_equal @wave
+      end
+
+      it "should be able to send multiple waves to a receiver and record them
+        in the outbox" do
+        n = 10
+        n.times do |i|
+          @user.generate "message", @wave, @receiver
+
+          @user.message_outbox.size.must_equal i+1
+          @receiver.message_inbox.size.must_equal i+1
+        end
+      end
+
+      it "should be able to save options in its outbox" do
+        @user.generate "message", @wave, @receiver, Time.now - 10000
+        @user.message_outbox.after(0).size.must_equal 0
+      end
+
+      it "should be able to save options in the receiver's inbox" do
+        @user.generate "message", @wave, @receiver, Time.now - 10000
+        # This wave will be truncated
+        @receiver.message_inbox.after(0).size.must_equal 0
+      end
+
+      it "should have a helper to retrieve outbox after..." do
+        @user.generated_after("message", 0).must_equal @user.message_outbox.after(0)
+      end
+
+      it "can be customized to not save a backup in its outbox in a sepcify call" do
+        @user.generate "message", @wave, @receiver, Time.now, :outbox => false
+
+        @user.message_outbox.after(0).size.must_equal 0
+      end
+
+      it "should utilize method_missing to provide some much better api" do
+        @user.generate_message @wave, @receiver
+
+        @user.generated_message_after(0).size.must_equal 1
+
+        @receiver.message_inbox.size.must_equal 1
+        @receiver.message_inbox.after(0)[0].must_equal @wave
+      end
+
+      it "should implement method missing politely" do
+        @user.respond_to?(:generate_message).must_equal true
+        @user.respond_to?(:generated_message_after).must_equal true
+      end
+    end
+
+  end
+
+  describe "USAGE: can generate multiple waves in a single class" do
+    before do
+      class MultipleSender
+        include WaveBox::GenerateWave
+
+        can_generate_wave :name => "message",
+                          :redis => MockRedis.new,
+                          :expire => 60*10,
+                          :max_size => 10,
+                          # You have to specify a box id which
+                          # is unique among all receiver
+                          :id => :box_id
+
+        can_generate_wave :name => "stone",
+                          :redis => MockRedis.new,
+                          :expire => 60*10,
+                          :max_size => 10,
+                          # You have to specify a box id which
+                          # is unique among all receiver
+                          :id => :box_id
+
+
+        def box_id
+          object_id
+        end
+      end
+
+      class MultipleReceiver
+        include WaveBox::ReceiveWave
+
+        can_receive_wave :name => "message",
+                         :redis => MockRedis.new,
+                         :expire => 60*10,
+                         :max_size => 10,
+                         # You have to specify a box id which
+                         # is unique among all receiver
+                         :id => :box_id
+
+        can_receive_wave :name => "stone",
+                         :redis => MockRedis.new,
+                         :expire => 60*10,
+                         :max_size => 10,
+                         # You have to specify a box id which
+                         # is unique among all receiver
+                         :id => :box_id
+
+
+        def box_id
+          object_id
+        end
+      end
+
+      @sender = MultipleSender.new
+      @receiver = MultipleReceiver.new
+    end
+
+    it "Should have multiple outbox" do
+      @sender.message_outbox.wont_be_nil
+      @sender.stone_outbox.wont_be_nil
+    end
+
+    it "Should have multiple outbox key" do
+      @sender.message_outbox_key.wont_equal @sender.stone_outbox_key
+    end
+
+    it "Should be able to send multiple type of waves without
+        conflicting each other" do
+      @sender.generate_message "foo", @receiver
+      @sender.generated_message_after(0).size.must_equal 1
+      @receiver.received_after("message", 0).size.must_equal 1
+
+      @sender.generate_stone "bar", @receiver
+
+      @sender.generated_message_after(0).size.must_equal 1
+      @sender.generated_stone_after(0).size.must_equal 1
+
+      @receiver.received_message_after(0).size.must_equal 1
+      @receiver.received_stone_after(0).size.must_equal 1
+    end
+  end
+end
+

data/spec/wave_box/receive_wave_spec.rb

@@ -0,0 +1,75 @@
+require "spec_helper"
+require 'mock_redis'
+
+describe WaveBox::ReceiveWave do
+  it "should raise an argument error if no name given" do
+    lambda do 
+      class A
+        include WaveBox::ReceiveWave
+
+        can_receive_wave :id => :box_id,
+                         :redis => MockRedis.new
+      end
+    end.must_raise ArgumentError
+  end
+
+  it "should raise an argument error if no redis config is given" do
+    lambda do
+      class A
+        include WaveBox::ReceiveWave
+
+        can_receive_wave :id => :box_id,
+                         :name => "message"
+      end
+    end.must_raise ArgumentError
+  end
+
+  it "should raise an ArgumentError if no box_id config is given" do
+    lambda do
+      class A
+        include WaveBox::ReceiveWave
+
+        can_receive_wave :redis => :box_id,
+                         :name => "message"
+      end
+    end.must_raise ArgumentError
+  end
+
+  describe "A normal receiver usage" do
+    before do
+      class User
+        include WaveBox::ReceiveWave
+
+        can_receive_wave :name => "message",
+                         :redis => MockRedis.new,
+                         :expire => 60*10,
+                         :max_size => 10,
+                         # You have to specify a box id which
+                         # is unique among all receiver
+                         :id => :box_id
+
+        def box_id
+          object_id
+        end
+      end
+
+      @user = User.new
+      @wave = "foo"
+    end
+
+    it "should have an inbox" do
+      @user.message_inbox.wont_be_nil
+    end
+
+    it "should be able to receive wave and save it to its inbox" do
+      @user.receive("message", @wave)
+
+      @user.message_inbox.size.must_equal 1
+      @user.message_inbox.after(0)[0].must_equal @wave
+    end
+
+    it "should have a helper to retrieve inbox after..." do
+      @user.received_message_after(0).must_equal @user.message_inbox.after(0)
+    end
+  end
+end

data/wave_box.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "wave_box/version"
+
+Gem::Specification.new do |s|
+  s.name        = "wave_box"
+  s.version     = WaveBox::VERSION
+  s.authors     = ["Poga Po"]
+  s.email       = ["poga.bahamut@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Redis-based Push-style messaging}
+  s.description = %q{A simple push style messaging based on redis}
+
+  s.rubyforge_project = "wavebox"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  s.licenses      = "MIT"
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "redis"
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: wave_box
+version: !ruby/object:Gem::Version
+  version: 0.4.0
+  prerelease: 
+platform: ruby
+authors:
+- Poga Po
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70280405090200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70280405090200
+description: A simple push style messaging based on redis
+email:
+- poga.bahamut@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/wave_box.rb
+- lib/wave_box/box.rb
+- lib/wave_box/generate_wave.rb
+- lib/wave_box/receive_wave.rb
+- lib/wave_box/version.rb
+- lib/wave_box/wave.rb
+- spec/spec_helper.rb
+- spec/wave_box/box_spec.rb
+- spec/wave_box/generate_wave_spec.rb
+- spec/wave_box/receive_wave_spec.rb
+- wave_box.gemspec
+homepage: ''
+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: wavebox
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Redis-based Push-style messaging
+test_files:
+- spec/spec_helper.rb
+- spec/wave_box/box_spec.rb
+- spec/wave_box/generate_wave_spec.rb
+- spec/wave_box/receive_wave_spec.rb
+has_rdoc: