tusk 1.0.0

data/.autotest

@@ -0,0 +1,8 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib          = 'minitest/autorun'
+  at.find_directories = ARGV unless ARGV.empty?
+end

data/CHANGELOG.rdoc

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2012-07-18
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+.autotest
+CHANGELOG.rdoc
+Manifest.txt
+README.markdown
+Rakefile
+lib/tusk.rb
+lib/tusk/latch.rb
+lib/tusk/observable/pg.rb
+lib/tusk/observable/redis.rb
+test/helper.rb
+test/observable/test_pg.rb
+test/observable/test_redis.rb
+test/redis-test.conf

data/README.markdown

@@ -0,0 +1,206 @@
+# tusk
+
+* http://github.com/tenderlove/tusk
+
+## DESCRIPTION:
+
+Tusk is a minimal pub / sub system with multiple observer strategies.
+Tusk builds upon the Observer API from stdlib in order to provide a mostly
+consistent API for building cross thread or process pub / sub systems.
+
+Currently, Tusk supports Redis and PostgreSQL as message bus back ends.
+
+## FEATURES/PROBLEMS:
+
+* Send message across processes
+* Supports Redis as a message bus
+* Supports PostgreSQL as a message bus
+
+## SYNOPSIS:
+
+Here is an in-memory observer example:
+
+```ruby
+require 'observer'
+
+class Timer
+  include Observable
+
+  def tick
+    changed
+    notify_observers
+  end
+end
+
+class Listener
+  def update; puts "got update"; end
+end
+
+timer = Timer.new
+timer.add_observer Listener.new
+loop { timer.tick; sleep 1; }
+```
+
+
+The down side of this example is that the Listener cannot be in a different
+process.  We can move the Listener to a different process by using the Redis
+observable mixin and providing a redis connection:
+
+```ruby
+require 'tusk/observable/redis'
+require 'redis'
+
+class Timer
+  include Tusk::Observable::Redis
+
+  def tick
+    changed
+    notify_observers
+  end
+
+  def connection
+    Thread.current[:redis] ||= ::Redis.new
+  end
+end
+
+class Listener
+  def update; puts "got update PID: #{$$}"; end
+end
+
+timer = Timer.new
+
+fork {
+  timer.add_observer Listener.new
+  sleep
+}
+
+loop { timer.tick; sleep 1; }
+```
+
+PostgreSQL can also be used as the message bus:
+
+```ruby
+require 'tusk/observable/pg'
+require 'pg'
+
+class Timer
+  include Tusk::Observable::PG
+
+  def tick
+    changed
+    notify_observers
+  end
+
+  def connection
+    Thread.current[:pg] ||= ::PG::Connection.new :dbname => 'postgres'
+  end
+end
+
+class Listener
+  def update; puts "got update PID: #{$$}"; end
+end
+
+timer = Timer.new
+
+fork {
+  timer.add_observer Listener.new
+  sleep
+}
+
+loop { timer.tick; sleep 1; }
+```
+
+We can easily integrate Tusk with Active Record.  Here is a User model that
+sends notifications when a user is created:
+
+```ruby
+require 'tusk/observable/pg'
+class User < ActiveRecord::Base
+  attr_accessible :name
+
+  extend Tusk::Observable::PG
+
+  # After users are created, notify the message bus
+  after_create :notify_observers
+
+  # Listeners will use the table name as the bus channel
+  def self.channel
+    table_name
+  end
+
+  private
+
+  def notify_observers
+    self.class.changed
+    self.class.notify_observers
+  end
+end
+```
+
+The table name is used as the channel name where objects will listen.  Here is
+a producer script:
+
+```ruby
+require 'user'
+loop do
+  User.create!(:name => 'testing')
+  sleep 1
+end
+```
+
+Our consumer adds an observer to the User class:
+
+```ruby
+require 'user'
+class UserListener
+  def initialize
+    super
+    @last_id = 0
+  end
+
+  def update
+    users = User.where('id > ?', @last_id).sort_by(&:id)
+    @last_id = users.last.id
+    users.each { |u| p "user created: #{u.id}" }
+  end
+end
+
+User.add_observer UserListener.new
+# Put the main thread to sleep
+sleep
+```
+
+Whenever a user gets created, our consumer listener will be notified.
+
+## REQUIREMENTS:
+
+* PostgreSQL or Redis
+
+## INSTALL:
+
+* gem install tusk
+
+## LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Aaron Patterson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.plugins.delete :rubyforge
+Hoe.plugin :minitest
+Hoe.plugin :gemspec # `gem install hoe-gemspec`
+Hoe.plugin :git     # `gem install hoe-git`
+
+Hoe.spec 'tusk' do
+  developer('Aaron Patterson', 'aaron@tenderlovemaking.com')
+  self.readme_file   = 'README.markdown'
+  self.history_file  = 'CHANGELOG.rdoc'
+  self.extra_rdoc_files  = FileList['*.{rdoc,markdown}']
+
+  self.extra_dev_deps << ['pg', '~> 0.14.0']
+end
+
+# vim: syntax=ruby

data/lib/tusk.rb

@@ -0,0 +1,9 @@
+###
+# Tusk contains observers with different message bus strategies.
+#
+# Tusk::Observers::Redis offers an Observer API with Redis as the
+# message bus.  Tusk::Observers::PG offers and Observer API with
+# PostgreSQL as the message bus.
+module Tusk
+  VERSION = '1.0.0'
+end

data/lib/tusk/latch.rb

@@ -0,0 +1,24 @@
+require 'monitor'
+
+module Tusk
+  class Latch
+    def initialize(count = 1)
+      @count = count
+      @lock = Monitor.new
+      @cv = @lock.new_cond
+    end
+
+    def release
+      @lock.synchronize do
+        @count -= 1 if @count > 0
+        @cv.broadcast if @count.zero?
+      end
+    end
+
+    def await
+      @lock.synchronize do
+        @cv.wait_while { @count > 0 }
+      end
+    end
+  end
+end

data/lib/tusk/observable/pg.rb

@@ -0,0 +1,170 @@
+require 'thread'
+require 'digest/md5'
+require 'tusk/latch'
+
+module Tusk
+  module Observable
+    ###
+    # An observer implementation for PostgreSQL.  This module requires that
+    # your class implement a `connection` method that returns a database
+    # connection that this module can use.
+    #
+    # This observer works across processes.
+    #
+    # Example:
+    #
+    #     require 'pg'
+    #     require 'tusk/observable/pg'
+    #     
+    #     class Timer
+    #       include Tusk::Observable::PG
+    #     
+    #       def tick
+    #         changed
+    #         notify_observers
+    #       end
+    #     
+    #       def connection
+    #         Thread.current[:conn] ||= ::PG::Connection.new :dbname => 'postgres'
+    #       end
+    #     end
+    #     
+    #     class Listener
+    #       def update
+    #         puts "got update"
+    #       end
+    #     end
+    #     
+    #     timer = Timer.new
+    #     
+    #     fork do
+    #       timer.add_observer Listener.new
+    #       sleep # put the process to sleep so it doesn't exit
+    #     end
+    #     
+    #     loop do
+    #       timer.tick
+    #       sleep 1
+    #     end
+    module PG
+      def self.extended klass
+        super
+
+        klass.instance_eval do
+          @sub_lock       = Mutex.new
+          @observer_state = false
+          @subscribers    = {}
+          @_listener      = nil
+          @observing      = Latch.new
+        end
+      end
+
+      attr_reader :subscribers
+
+      def initialize *args
+        super
+
+        @sub_lock       = Mutex.new
+        @observer_state = false
+        @subscribers    = {}
+        @_listener      = nil
+        @observing      = Latch.new
+      end
+
+      # Returns the number of observers associated with this object *in the
+      # current process*.  If the object is observed across multiple processes,
+      # the returned count will not reflect the other processes.
+      def count_observers
+        @sub_lock.synchronize { subscribers.fetch(channel, {}).length }
+      end
+
+      # Remove all observers associated with this object *in the current
+      # process*. This method will not impact observers of this object in
+      # other processes.
+      def delete_observers
+        @sub_lock.synchronize { subscribers.delete channel }
+      end
+
+      # Returns true if this object's state has been changed since the last
+      # call to #notify_observers.
+      def changed?
+        @observer_state
+      end
+
+      # Set the changed state of this object.  Notifications will be sent only
+      # if the changed +state+ is a truthy object.
+      def changed state = true
+        @observer_state = state
+      end
+
+      # If this object's #changed? state is true, this method will notify
+      # observing objects.
+      def notify_observers
+        return unless changed?
+
+        unwrap(connection).exec "NOTIFY #{channel}"
+
+        changed false
+      end
+
+      # Add +observer+ as an observer to this object.  The +object+ will
+      # receive a notification when #changed? returns true and #notify_observers
+      # is called.
+      #
+      # +func+ method is called on +object+ when notifications are sent.
+      def add_observer object, func = :update
+        @sub_lock.synchronize do
+          subscribers.fetch(channel) { |k|
+            Thread.new {
+              start_listener
+              unwrap(connection).exec "LISTEN #{channel}"
+              @observing.release
+            }
+            subscribers[k] = {}
+          }[object] = func
+        end
+
+        @observing.await
+      end
+
+      # Remove +observer+ so that it will no longer receive notifications.
+      def delete_observer o
+        @sub_lock.synchronize do
+          subscribers.fetch(channel, {}).delete o
+        end
+      end
+
+      private
+
+      def unwrap conn
+        if conn.respond_to? :exec
+          conn
+        else
+          # Yes, I am a terrible person.  This pulls
+          # the connection out of AR connections.
+          conn.instance_eval { @connection }
+        end
+      end
+
+      def channel
+        "a" + Digest::MD5.hexdigest("#{self.class.name}#{object_id}")
+      end
+
+      def start_listener
+        return if @_listener
+
+        @_listener = Thread.new(unwrap(connection)) do |conn|
+          @observing.release
+
+          loop do
+            conn.wait_for_notify do |event, pid|
+              subscribers.fetch(event, []).dup.each do |listener, func|
+                listener.send func
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tusk/observable/redis.rb

@@ -0,0 +1,170 @@
+require 'securerandom'
+require 'thread'
+require 'tusk/latch'
+
+module Tusk
+  module Observable
+    ###
+    # An observer implementation for Redis.  This module requires that
+    # your class implement a `connection` method that returns a redis
+    # connection that this module can use.
+    #
+    # This observer works across processes.
+    #
+    # Example:
+    #
+    #     require 'redis'
+    #     require 'tusk/observable/redis'
+    #     
+    #     class Timer
+    #       include Tusk::Observable::Redis
+    #     
+    #       def tick
+    #         changed
+    #         notify_observers
+    #       end
+    #     
+    #       def connection
+    #         Thread.current[:conn] ||= ::Redis.new
+    #       end
+    #     end
+    #     
+    #     class Listener
+    #       def update
+    #         puts "got update"
+    #       end
+    #     end
+    #     
+    #     timer = Timer.new
+    #     
+    #     fork do
+    #       timer.add_observer Listener.new
+    #       sleep # put the process to sleep so it doesn't exit
+    #     end
+    #     
+    #     loop do
+    #       timer.tick
+    #       sleep 1
+    #     end
+    module Redis
+      def self.extended klass
+        super
+
+        klass.instance_eval do
+          @sub_lock        = Mutex.new
+          @observer_state  = false
+          @subscribers     = {}
+          @_listener       = nil
+          @control_channel = SecureRandom.hex
+        end
+      end
+
+      attr_reader :subscribers, :control_channel
+
+      def initialize *args
+        super
+
+        @sub_lock        = Mutex.new
+        @observer_state  = false
+        @subscribers     = {}
+        @_listener       = nil
+        @control_channel = SecureRandom.hex
+      end
+
+      # Returns the number of observers associated with this object *in the
+      # current process*.  If the object is observed across multiple processes,
+      # the returned count will not reflect the other processes.
+      def count_observers
+        @sub_lock.synchronize { subscribers.fetch(channel, {}).length }
+      end
+
+      # Remove all observers associated with this object *in the current
+      # process*. This method will not impact observers of this object in
+      # other processes.
+      def delete_observers
+        @sub_lock.synchronize { subscribers.delete channel }
+        connection.publish control_channel, 'quit'
+      end
+
+      # Returns true if this object's state has been changed since the last
+      # call to #notify_observers.
+      def changed?
+        @observer_state
+      end
+
+      # Set the changed state of this object.  Notifications will be sent only
+      # if the changed +state+ is a truthy object.
+      def changed state = true
+        @observer_state = state
+      end
+
+      # If this object's #changed? state is true, this method will notify
+      # observing objects.
+      def notify_observers
+        return unless changed?
+        connection.publish channel, nil
+        changed false
+      end
+
+      # Add +observer+ as an observer to this object.  The +object+ will
+      # receive a notification when #changed? returns true and #notify_observers
+      # is called.
+      #
+      # +func+ method is called on +object+ when notifications are sent.
+      def add_observer object, func = :update
+        observer_set = Latch.new
+        observing    = Latch.new
+
+        @sub_lock.synchronize do
+          observing.release if subscribers.key? channel
+
+          subscribers.fetch(channel) { |k|
+            Thread.new {
+              observer_set.await
+              start_listener(observing)
+            }
+            subscribers[k] = {}
+          }[object] = func
+        end
+
+        observer_set.release
+        observing.await
+      end
+
+      # Remove +observer+ so that it will no longer receive notifications.
+      def delete_observer o
+        @sub_lock.synchronize do
+          subscribers.fetch(channel, {}).delete o
+          if subscribers.fetch(channel,{}).empty?
+            subscribers.delete channel
+            connection.publish control_channel, 'quit'
+          end
+        end
+      end
+
+      private
+
+      def channel
+        "a" + Digest::MD5.hexdigest("#{self.class.name}#{object_id}")
+      end
+
+      def start_listener latch
+        connection.subscribe(channel, control_channel) do |on|
+          on.subscribe { |c| latch.release }
+
+          on.message do |c, message|
+            if c == control_channel && message == 'quit'
+              connection.unsubscribe
+            else
+              @sub_lock.synchronize do
+                subscribers.fetch(c, {}).each do |object,m|
+                  object.send m
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,149 @@
+require 'minitest/autorun'
+
+module Tusk
+  class TestCase < MiniTest::Unit::TestCase
+    module ObserverTests
+      class QueueingObserver
+        def initialize q
+          @q = q
+        end
+
+        def update
+          @q.push :foo
+        end
+      end
+
+      def test_changed?
+        o = build_observable
+        refute o.changed?
+        o.changed
+        assert o.changed?
+      end
+
+      def test_changed
+        o = build_observable
+        refute o.changed?
+        o.changed false
+        refute o.changed?
+        o.changed
+        assert o.changed
+      end
+
+      def test_delete_observers
+        o = build_observable
+
+        q = Queue.new
+
+        o.add_observer QueueingObserver.new q
+        o.delete_observers
+        o.changed
+        o.notify_observers
+        assert q.empty?
+      end
+
+      def test_count_observers
+        o = build_observable
+        assert_equal 0, o.count_observers
+
+        q = Queue.new
+
+        o.add_observer QueueingObserver.new q
+        assert_equal 1, o.count_observers
+
+        o.add_observer QueueingObserver.new q
+        assert_equal 2, o.count_observers
+
+        o.delete_observers
+        assert_equal 0, o.count_observers
+      end
+
+      def test_observer_fires
+        o = build_observable
+        q = Queue.new
+
+        o.add_observer QueueingObserver.new q
+
+        o.changed
+        o.notify_observers
+
+        assert_equal :foo, q.pop
+      end
+
+      def test_multiple_observers
+        o = build_observable
+        q = Queue.new
+
+        o.add_observer QueueingObserver.new q
+        o.add_observer QueueingObserver.new q
+
+        o.changed
+        o.notify_observers
+
+        assert_equal :foo, q.pop
+        assert_equal :foo, q.pop
+      end
+
+      def test_observer_only_fires_on_change
+        o = build_observable
+        q = Queue.new
+
+        o.add_observer QueueingObserver.new q
+
+        o.notify_observers
+        assert q.empty?
+      end
+
+      def test_delete_observer
+        o        = build_observable
+        q        = Queue.new
+        observer = QueueingObserver.new q
+
+        o.add_observer observer
+
+        o.changed
+        o.notify_observers
+
+        assert_equal :foo, q.pop
+
+        o.delete_observer observer
+
+        o.changed
+        o.notify_observers
+
+        assert q.empty?
+      end
+
+      def test_delete_never_added
+        o        = build_observable
+        q        = Queue.new
+        observer = QueueingObserver.new q
+
+        o.delete_observer observer
+        o.changed
+        o.notify_observers
+
+        assert q.empty?
+      end
+
+      def test_no_connection
+        mod = observer_module
+        obj = Class.new { include mod }.new
+
+        assert_raises(NameError) do
+          obj.changed
+          obj.notify_observers
+        end
+      end
+
+      private
+
+      def build_observable
+        raise NotImplementedError
+      end
+
+      def observer_module
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/test/observable/test_pg.rb

@@ -0,0 +1,57 @@
+require 'pg'
+require 'tusk/observable/pg'
+require 'helper'
+
+module Tusk
+  module Observable
+    class TestPg < TestCase
+      include ObserverTests
+
+      class Timer
+        include Tusk::Observable::PG
+
+        def tick
+          changed
+          notify_observers
+        end
+
+        def connection
+          Thread.current[:conn] ||= ::PG::Connection.new :dbname => 'postgres'
+        end
+      end
+
+      private
+
+      def build_observable
+        Timer.new
+      end
+
+      def observer_module
+        Tusk::Observable::PG
+      end
+    end
+
+    class TestClassPg < TestCase
+      include ObserverTests
+
+      def build_observable
+        Class.new {
+          extend Tusk::Observable::PG
+
+          def self.tick
+            changed
+            notify_observers
+          end
+
+          def self.connection
+            Thread.current[:conn] ||= ::PG::Connection.new :dbname => 'postgres'
+          end
+        }
+      end
+
+      def observer_module
+        Tusk::Observable::PG
+      end
+    end
+  end
+end

data/test/observable/test_redis.rb

@@ -0,0 +1,84 @@
+require 'redis'
+require 'tusk/observable/redis'
+require 'helper'
+
+module Tusk
+  module Observable
+    class TestRedis < TestCase
+      include ObserverTests
+
+      class Timer
+        include Tusk::Observable::Redis
+
+        def tick
+          changed
+          notify_observers
+        end
+
+        def connection
+          Thread.current[:redis] ||= ::Redis.new
+        end
+      end
+
+      class QueueingObserver
+        def initialize q
+          @q = q
+        end
+
+        def update
+          @q.push :foo
+        end
+      end
+
+      private
+
+      def build_observable
+        Timer.new
+      end
+
+      def observer_module
+        Tusk::Observable::Redis
+      end
+    end
+
+    class TestClassRedis < TestCase
+      include ObserverTests
+
+      def build_observable
+        Class.new {
+          extend Tusk::Observable::Redis
+
+          def self.tick
+            changed
+            notify_observers
+          end
+
+          def self.connection
+            Thread.current[:redis] ||= ::Redis.new
+          end
+        }
+      end
+
+      def observer_module
+        Tusk::Observable::Redis
+      end
+    end
+  end
+end
+
+Dir.chdir(File.join(File.dirname(__FILE__), '..')) do
+  `redis-server redis-test.conf`
+end
+
+at_exit {
+  next if $!
+
+  exit_code = MiniTest::Unit.new.run(ARGV)
+
+  processes = `ps -A -o pid,command | grep [r]edis-test`.split("\n")
+  pids = processes.map { |process| process.split(" ")[0] }
+  puts "Killing test redis server..."
+  pids.each { |pid| Process.kill("KILL", pid.to_i) }
+
+  exit exit_code
+}

data/test/redis-test.conf

@@ -0,0 +1 @@
+daemonize yes

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: tusk
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-07-22 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 2
+        - 11
+        version: "2.11"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: pg
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 39
+        segments: 
+        - 0
+        - 14
+        - 0
+        version: 0.14.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 3
+        - 10
+        version: "3.10"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 2
+        - 13
+        version: "2.13"
+  type: :development
+  version_requirements: *id004
+description: |-
+  Tusk is a minimal pub / sub system with multiple observer strategies.
+  Tusk builds upon the Observer API from stdlib in order to provide a mostly
+  consistent API for building cross thread or process pub / sub systems.
+  
+  Currently, Tusk supports Redis and PostgreSQL as message bus back ends.
+email: 
+- aaron@tenderlovemaking.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- CHANGELOG.rdoc
+- README.markdown
+files: 
+- .autotest
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.markdown
+- Rakefile
+- lib/tusk.rb
+- lib/tusk/latch.rb
+- lib/tusk/observable/pg.rb
+- lib/tusk/observable/redis.rb
+- test/helper.rb
+- test/observable/test_pg.rb
+- test/observable/test_redis.rb
+- test/redis-test.conf
+- .gemtest
+homepage: http://github.com/tenderlove/tusk
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: tusk
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Tusk is a minimal pub / sub system with multiple observer strategies
+test_files: 
+- test/observable/test_pg.rb
+- test/observable/test_redis.rb