celluloid-io-pg-listener 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6688ff5db3f6b68ae8cb6c3d30d1c7324255285d
-  data.tar.gz: 1aa1956925611e9bbdda6a966dca67d872a0ebf9
+  metadata.gz: 1f0e16f28d6bd7ddda7c1cce2480269924c11690
+  data.tar.gz: 6d89f93dcdc3dea378d729e4d9adccb06e8427d0
 SHA512:
-  metadata.gz: 7d6313905452f4c1ba7521ea991688d53bca029de7bbec76df0ce16e791cc66d5e4bb8285a44f27e9855a2d1f84ffde0815f4cc9088ab349fd4a00b1848ac762
-  data.tar.gz: 67c96d9e54a750629e46f7cd996ded67a034e056ee537b72337acc1d0f319a05ce11d59db7392ad86397c9c893f39c58132f3f5f84681d5c5dcd9dbde1af015c
+  metadata.gz: c7e78c2385b61f25dcd7111460cd463f76b89feece98a31e27f5b7f82b3e5be097e0326dced44f2571f3da022203f072390d32e9cb3f3cd6a317cdd994ae76c7
+  data.tar.gz: 42ec7cf6cce2f8dbe724d1cb22b7f2e146f0eeca070479b1c602afe2d3031fe6f1d2c283f4a2b6fbd8cb013a2d68a9dcb0ddc53a61d707213212e5ef6e504eb5

data/.rspec

@@ -1,2 +1,2 @@
---format documentation
 --color
+--require spec_helper

data/.travis.yml

@@ -1,8 +1,12 @@
 language: ruby
+cache: bundler
 rvm:
-  - 2.1.2
+  - 2.1.5
   - 2.2.3
-before_install: gem install bundler -v 1.10.6
+before_install:
+  - gem install bundler -v 1.10.6
+  - bin/setup
+script: "bundle exec rspec spec"
 gemfile:
   - gemfiles/rails_4.2.4.gemfile
   - gemfiles/rails_3.2.22.gemfile

data/Gemfile

@@ -2,3 +2,4 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in celluloid-io-pg-listener.gemspec
 gemspec
+

data/README.md

@@ -2,6 +2,8 @@
 
 Simple way to NOTIFY and LISTEN to channels in PostgreSQL
 
+The goal is to integrate the listener client with a Rails project, and that is underway in the spec/ folder, but as yet unfinished.  Standalone the listener client works great.
+
 Inspired by https://gist.github.com/tpitale/3915671
 
 | Project                 |  Celluloid IO PG Listener   |
@@ -43,70 +45,134 @@ Find a data base that exists that you want to run notifications through.  Won't
 so doesn't matter which one you pick.  Then pick an arbitrary name for the channel.  Only requirement is that the server
 and the client use the same database name and channel name or they won't be communicating.
 
-In an irb session
+In an irb session start the server, taking care to:
+- replace the database names with your own
+- replace the channel name, if you want, they are arbitrary, and don't need to be "created" in the DB.
 
 ```ruby
 >> require "celluloid-io-pg-listener"
 
 => true
 
->> CelluloidIOPGListener::Server.new(dbname: "test_database", channel: "test_channel" )
+>> $CELLULOID_DEBUG=true
+=> true
 
-I, [2015-10-06T12:38:43.728686 #5880]  INFO -- : Server will send notifications to archer_test:test
+>> server = CelluloidIOPGListener::Examples::Server.new(dbname: "celluloid_io_pg_listener_test", channel: "users_insert")
 
-=> #<Celluloid::Proxy::Cell(CelluloidIOPGListener::Server:0x3ff732194f24) @dbname="test_database" @channel="test_channel" @sleep_interval=0.1 @run_interval=1>
+D, [2015-10-14T12:59:31.840206 #23209] DEBUG -- : Server will send notifications to celluloid_io_pg_listener_test:users_insert
 
-I, [2015-10-06T12:38:44.105265 #5880]  INFO -- : Notified test
+=> #<Celluloid::Proxy::Cell(CelluloidIOPGListener::Examples::Server:0x3ff71a6f6db8) @client_extracted_signature=#<CelluloidIOPGListener::Initialization::ClientExtractedSignature:0x007fee34dec310 @channel="users_insert", @conninfo_hash={:dbname=>"celluloid_io_pg_listener_test"}, @super_signature=[]>>
 
->> CelluloidIOPGListener::Listener.new(dbname: "test_database", channel: "test_channel" )
+>> server.start
+=> #<Celluloid::Proxy::Async(CelluloidIOPGListener::Examples::Server)>
 
-=> #<Celluloid::Proxy::Cell(CelluloidIOPGListener::Listener:0x3fd6ace33cb8) @dbname="test_database" @listening=true @pg_connection=#<PG::Connection:0x007fad59c5f978> @actions={"test_channel"=>:do_something}>
+D, [2015-10-14T12:59:36.115639 #23209] DEBUG -- : Notified users_insert
+D, [2015-10-14T12:59:37.107589 #23209] DEBUG -- : Notified users_insert
+D, [2015-10-14T12:59:38.112089 #23209] DEBUG -- : Notified users_insert
+D, [2015-10-14T12:59:39.112341 #23209] DEBUG -- : Notified users_insert
+```
+
+The notifications will just keep flowing, 1 per second as the example server is configured by default.  Now in another irb session:
 
-I, [2015-10-06T12:40:38.110541 #5952]  INFO -- : Client will for notifications on test_database:test_channel
-I, [2015-10-06T12:40:38.110822 #5952]  INFO -- : Starting Listening
-I, [2015-10-06T12:40:50.117444 #5952]  INFO -- : Received notification: ["test", 5968, "1444160450"]
-I, [2015-10-06T12:40:50.117518 #5952]  INFO -- : Doing Something with Payload: 1444160450 on test
-I, [2015-10-06T12:40:50.117541 #5952]  INFO -- : 1444160450
-I, [2015-10-06T12:40:51.107977 #5952]  INFO -- : Received notification: ["test", 5968, "1444160451"]
-I, [2015-10-06T12:40:51.108071 #5952]  INFO -- : Doing Something with Payload: 1444160451 on test
-I, [2015-10-06T12:40:51.108104 #5952]  INFO -- : 1444160451
-I, [2015-10-06T12:40:52.112797 #5952]  INFO -- : Received notification: ["test", 5968, "1444160452"]
-I, [2015-10-06T12:40:52.112881 #5952]  INFO -- : Doing Something with Payload: 1444160452 on test
-I, [2015-10-06T12:40:52.112911 #5952]  INFO -- : 1444160452
 ```
+>> CelluloidIOPGListener::Examples::ListenerClientByInheritance.new(dbname: "celluloid_io_pg_listener_test", channel: "users_insert", callback_method: :foo_bar)
 
-The Listener class included is just a proof of concept.  It shows you how to use the Client module to make your own listener class that does what you need done.
+=> #<Celluloid::Proxy::Cell(CelluloidIOPGListener::Examples::ListenerClientByInheritance:0x3fe50d93f15c) @client_extracted_signature=#<CelluloidIOPGListener::Initialization::ClientExtractedSignature:0x007fca1b27c738 @channel="users_insert", @conninfo_hash={:dbname=>"celluloid_io_pg_listener_test"}, @super_signature=[{}]> @callback_method=:foo_bar @listening=true @pg_connection=#<PG::Connection:0x007fca1b287b38> @actions={"users_insert"=>:foo_bar}>
 
-```ruby
-module CelluloidIOPGListener
-  # An example Client class
-  class Listener
+I, [2015-10-14T12:59:46.127120 #23223]  INFO -- : Received notification: ["users_insert", 23220, "1444852786"]
+I, [2015-10-14T12:59:47.127021 #23223]  INFO -- : Received notification: ["users_insert", 23220, "1444852787"]
+I, [2015-10-14T12:59:48.127152 #23223]  INFO -- : Received notification: ["users_insert", 23220, "1444852788"]
+I, [2015-10-14T12:59:49.127509 #23223]  INFO -- : Received notification: ["users_insert", 23220, "1444852789"]
+```
 
-    include CelluloidIOPGListener::Client
+Simply exit the sessions to end the test.
 
-    def initialize(dbname:, channel:)
-      info "Client will for notifications on #{dbname}:#{channel}"
-      @dbname = dbname
-      async.start_listening
-      async.listen(channel, :do_something)
-    end
+Or keep the client running, and only exit the server and do a real test.
+
+If you have downloaded the gem source, cd to the gem's directory, and run `bin/setup` to create the test database.
+
+Open `psql` and `\c celluloid_io_pg_listener_test`
+
+```
+pboling=# \c celluloid_io_pg_listener_test
+You are now connected to database "celluloid_io_pg_listener_test" as user "pboling".
+celluloid_io_pg_listener_test=# insert into users (name) values ('jack');
+NOTICE:  INSERT TRIGGER called on users
+INSERT 0 1
+celluloid_io_pg_listener_test=# insert into users (name) values ('jill');
+NOTICE:  INSERT TRIGGER called on users
+INSERT 0 1
+celluloid_io_pg_listener_test=# \q
+```
+
+In the irb session with the Client still running you will see new notifications:
+
+```
+I, [2015-10-14T13:42:55.511294 #25295]  INFO -- : Received notification: ["users_insert", 25304, "{\"table\" : \"users\", \"id\" : 1, \"name\" : \"jack\", \"type\" : \"INSERT\"}"]
+I, [2015-10-14T13:43:03.841323 #25295]  INFO -- : Received notification: ["users_insert", 25304, "{\"table\" : \"users\", \"id\" : 2, \"name\" : \"jill\", \"type\" : \"INSERT\"}"]
+```
 
-    def do_something(channel, payload)
-      unlisten_wrapper(channel, payload) do
-        info payload
+A more advanced client could be made to deserialize that JSON and get real work done.  That's where you come in! ;)
+
+The example [Client (Listener) class included with the gem](https://github.com/pboling/celluloid-io-pg-listener/blob/master/lib/celluloid-io-pg-listener/examples/client.rb) is just a proof of concept.  It shows you how to use the `CelluloidIOPGListener::Client` module to make your own listener class that does what you need done.  You could, for example, push the payload of the notification to Redis, to be worked by Sidekiq or Resque.
+
+```ruby
+module CelluloidIOPGListener
+  module Examples
+    class Client
+
+      include CelluloidIOPGListener::Client
+
+      # Defining initialize is optional,
+      #   unless you have custom args you need to handle
+      #   aside from those used by the CelluloidIOPGListener::Client
+      # But if you do define it, use a splat,
+      #   hash or array splat should work,
+      #   depending on your signature needs.
+      # With either splat, only pass the splat params to super,
+      #   and handle all other params locally.
+      #
+      # def initialize(optional_arg = nil, *options)
+      #   @optional_arg = optional_arg # handle it here, don't pass it on!
+      #   super(*options)
+      # end
+
+      def insert_callback(channel, payload)
+        # <-- within the unlisten_wrapper's block if :insert_callback is the callback_method
+        debug "#{self.class} channel is #{channel}"
+        debug "#{self.class} payload is #{payload}"
       end
-    end
 
+    end
   end
 end
 ```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies, and setup the test environment, including creating a role and a database. Then, run `appraisal rake` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+### Running the tests
+
+Setup has been implemented with `bin/setup`, so review the file to see what it will do before you:
+
+    bin/setup
+
+Run the specs with rake:
+
+    appraisal rake
+
+Or, run the specs without rake:
+
+    appraisal rspec
+
+NOTE: If you need to recreate `db/structure.sql` from the contents of the test database:
+
+    cd spec/apps
+    SKIP_RAILS_ROOT_OVERRIDE=true bundle exec rake db:structure:dump
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/celluloid-io-pg-listener. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
@@ -136,7 +202,6 @@ For example:
 spec.add_dependency 'celluloid-io-pg-listener', '~> 0.1'
 ```
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -5,4 +5,23 @@ require "celluloid-io-pg-listener"
 
 RSpec::Core::RakeTask.new(:spec)
 
+require "rails"
+require "active_record"
+
+# this logging style not compatible with Travis
+# ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/spec/apps/log/debug.log")
+ActiveRecord::Migration.verbose = false
+
+database_yml_filepath = File.dirname(__FILE__) + "/spec/apps/config/database.yml"
+configs = YAML.load_file(database_yml_filepath)
+if RUBY_PLATFORM == "java"
+  configs["test"]["adapter"] = "jdbcpostgresql"
+end
+ActiveRecord::Base.configurations = configs
+
+db_name = (ENV["DB"] || "test").to_sym
+ActiveRecord::Base.establish_connection(db_name)
+
+require "active_record/railtie"
+
 task :default => :spec

data/bin/setup

@@ -5,3 +5,22 @@ IFS=$'\n\t'
 bundle install
 
 # Do any other automated setup that you need to do here
+# NOTE: Assumes current user has ability to create roles in psql
+puser=$(whoami)
+# On Travis the user is postgres for psql
+if test "$puser" = 'travis'; then
+  puser=postgres
+fi
+psql -f bin/setup.sql -U $puser
+echo "Setup Role foss"
+psql -U $puser << EOF
+CREATE DATABASE celluloid_io_pg_listener_test;
+ALTER DATABASE celluloid_io_pg_listener_test OWNER TO "foss";
+EOF
+echo "Setup Database celluloid_io_pg_listener_test"
+
+cd spec/apps
+bundle install
+SKIP_RAILS_ROOT_OVERRIDE=true bundle exec rake test_db_setup
+
+cd ../..

data/bin/setup.sql

@@ -0,0 +1,12 @@
+DO
+$body$
+BEGIN
+  IF NOT EXISTS (
+      SELECT *
+      FROM   pg_catalog.pg_user
+      WHERE  usename = 'foss') THEN
+
+    CREATE ROLE foss WITH CREATEDB LOGIN;
+  END IF;
+END
+$body$

data/celluloid-io-pg-listener.gemspec

@@ -23,7 +23,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency "pg", ">= 0.18.3"
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rspec-rails"
-  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "rspec-rails", "~> 3.3"
+  spec.add_development_dependency "appraisal", "~> 2.1"
+  spec.add_development_dependency "activerecord", ">= 3.2"
+  spec.add_development_dependency "database_cleaner", "~> 1.5"
+  spec.add_development_dependency "test-unit", "~> 3.1"
+  spec.add_development_dependency "pry", "~> 0.10"
+
 end

data/gemfiles/rails_3.2.22.gemfile.lock

@@ -62,6 +62,7 @@ GEM
       timers (>= 4.1.1)
     celluloid-supervision (0.20.5)
       timers (>= 4.1.1)
+    database_cleaner (1.5.0)
     diff-lcs (1.2.5)
     erubis (2.7.0)
     hike (1.2.3)
@@ -141,9 +142,11 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord
   appraisal
   bundler (~> 1.10)
   celluloid-io-pg-listener!
+  database_cleaner
   pg
   rails (~> 3.2.22)
   rake (~> 10.0)

data/gemfiles/rails_4.2.4.gemfile.lock

@@ -70,6 +70,7 @@ GEM
       timers (>= 4.1.1)
     celluloid-supervision (0.20.5)
       timers (>= 4.1.1)
+    database_cleaner (1.5.0)
     diff-lcs (1.2.5)
     erubis (2.7.0)
     globalid (0.3.6)
@@ -154,9 +155,11 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord
   appraisal
   bundler (~> 1.10)
   celluloid-io-pg-listener!
+  database_cleaner
   pg
   rails (~> 4.2.4)
   rake (~> 10.0)

data/lib/celluloid-io-pg-listener.rb

@@ -6,6 +6,11 @@ require "pg"
 # Define the namespace this gem uses
 module CelluloidIOPGListener; end
 
+require "celluloid-io-pg-listener/initialization/client_extracted_signature"
+require "celluloid-io-pg-listener/initialization/argument_extraction"
+require "celluloid-io-pg-listener/initialization/async_listener"
 require "celluloid-io-pg-listener/client"
-require "celluloid-io-pg-listener/server"
-require "celluloid-io-pg-listener/listener"
+require "celluloid-io-pg-listener/examples/client"
+require "celluloid-io-pg-listener/examples/server"
+require "celluloid-io-pg-listener/examples/listener_client_by_inheritance"
+require "celluloid-io-pg-listener/examples/notify_server_by_inheritance"

data/lib/celluloid-io-pg-listener/client.rb

@@ -2,19 +2,31 @@
 module CelluloidIOPGListener
   module Client
 
+    class InvalidClient < StandardError; end
+
     def self.included(base)
       base.send(:include, Celluloid)
       base.send(:include, Celluloid::IO)
       base.send(:include, Celluloid::Internals::Logger)
+      # order of prepended modules is critical if they are enhancing
+      #   the same method(s), and they are.
+      base.prepend CelluloidIOPGListener::Initialization::AsyncListener
+      base.prepend CelluloidIOPGListener::Initialization::ArgumentExtraction
     end
 
     def unlisten_wrapper(channel, payload, &block)
-      info "Doing Something with Payload: #{payload} on #{channel}"
-      instance_eval(&block)
+      if block_given?
+        debug "Acting on payload: #{payload} on #{channel}"
+        instance_eval(&block)
+      else
+        info "Not acting on payload: #{payload} on #{channel}"
+      end
     rescue => e
-      info "#{self.class} disconnected from #{channel} via #{e.class} #{e.message}"
+      info "#{self.class}##{callback_method} disconnected from #{channel} via #{e.class} #{e.message}"
       unlisten(channel)
       terminate
+      # Rescue the error in a daemon-error-reporter to send to Airbrake or other reporting service?
+      raise
     end
 
     def actions
@@ -22,7 +34,7 @@ module CelluloidIOPGListener
     end
 
     def pg_connection
-      @pg_connection ||= PG.connect( dbname: @dbname )
+      @pg_connection ||= PG.connect(conninfo_hash)
     end
 
     def notify(channel, value)
@@ -35,10 +47,7 @@ module CelluloidIOPGListener
     end
 
     def start_listening
-      info "Starting Listening"
-
       @listening = true
-
       wait_for_notify do |channel, pid, payload|
         info "Received notification: #{[channel, pid, payload].inspect}"
         send(actions[channel], channel, payload)

data/lib/celluloid-io-pg-listener/examples/client.rb

@@ -0,0 +1,29 @@
+module CelluloidIOPGListener
+  module Examples
+    class Client
+
+      include CelluloidIOPGListener::Client
+
+      # Defining initialize is optional,
+      #   unless you have custom args you need to handle
+      #   aside from those used by the CelluloidIOPGListener::Client
+      # But if you do define it, use a splat,
+      #   hash or array splat should work,
+      #   depending on your signature needs.
+      # With either splat, only pass the splat params to super,
+      #   and handle all other params locally.
+      #
+      # def initialize(optional_arg = nil, *options)
+      #   @optional_arg = optional_arg # handle it here, don't pass it on!
+      #   super(*options)
+      # end
+
+      def insert_callback(channel, payload)
+        # <-- within the unlisten_wrapper's block if :insert_callback is the callback_method
+        debug "#{self.class} channel is #{channel}"
+        debug "#{self.class} payload is #{payload}"
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/examples/double_super_example.rb

@@ -0,0 +1,45 @@
+module InitializerEnhancer
+
+  def initialize(callback_method:)
+    # Class including this one must define the callback method
+    define_singleton_method(callback_method) {
+      super("banana") # <- Works just like you hoped it would.
+    }
+    super()
+  end
+
+end
+
+class SillyMonkey
+
+  prepend InitializerEnhancer
+
+  def initialize
+    puts "LOL Nothing happened."
+  end
+
+  def eat_thing(thing)
+    raise RuntimeError, "I ate a #{thing}"
+  end
+
+end
+
+class HappyMonkey < SillyMonkey
+
+  def eat_thing(thing)
+    puts "Dreaming about #{thing}"
+  end
+
+end
+
+# >> a = HappyMonkey.new(callback_method: "eat_thing")
+# LOL Nothing happened.
+#             => #<HappyMonkey:0x007fc77a988340>
+# >> a.eat_thing
+# "banana"
+# => nil
+# >> b = SillyMonkey.new(callback_method: "eat_thing")
+# LOL Nothing happened.
+#             => #<SillyMonkey:0x007fc77a95a530>
+# >> b.eat_thing
+# RuntimeError: I ate a banana

data/lib/celluloid-io-pg-listener/examples/listener_client_by_inheritance.rb

@@ -0,0 +1,34 @@
+module CelluloidIOPGListener
+  module Examples
+    class ListenerClientByInheritance < CelluloidIOPGListener::Examples::Client
+
+      #
+      # When you are:
+      #   * sub-classing a class that includes the Client and defines initialize
+      #
+      # If you
+      #   * defining a custom / overridden initialize method in the sub-class
+      #
+      # The Client may not work.
+      #   * the initialize overrides may happen out of normal order,
+      #     and may not work as expected.
+      #
+      # Working Example of overridden initialize follows!
+      #
+      def initialize(a = nil, b = nil, bus: nil, fat: nil, **args)
+        # Unlike in the original class, the prepends have been usurped since this overridden method is now highest precedence.
+        super(subclassed_client: true, **args)
+        # The initialize overrides will be called by super, and thus you have to be careful how you pass on the arguments to super.
+      end
+
+      # callback_method does *not* accept a block parameter
+      def foo_bar(channel, payload)
+        # <-- within the unlisten_wrapper's block if :foo_bar is the callback_method
+        debug "#{self.class}##{__method__} channel: #{channel}"
+        debug "#{self.class}##{__method__} payload: #{payload}"
+        raise RuntimeError, "This example only works on the users_insert channel, you are notifying #{channel} with #{payload}" unless channel == "users_insert"
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/examples/notify_server_by_inheritance.rb

@@ -0,0 +1,7 @@
+module CelluloidIOPGListener
+  module Examples
+    class NotifyServerByInheritance < CelluloidIOPGListener::Examples::Client
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/examples/server.rb

@@ -0,0 +1,51 @@
+# Simple example of a server for sending notifications through postgresql that can be listened for.
+module CelluloidIOPGListener
+  module Examples
+    class Server
+
+      include Celluloid
+      include Celluloid::IO
+      include Celluloid::Internals::Logger
+      prepend CelluloidIOPGListener::Initialization::ArgumentExtraction
+
+      def initialize(*args)
+        debug "Server will send notifications to #{dbname}:#{channel}"
+      end
+
+      # Defaults:
+      #   1/10th of a second sleep intervals
+      #   1 second run intervals
+      def start(run_interval: 1, sleep_interval: 0.1)
+        @sleep_interval = sleep_interval
+        @run_interval = run_interval
+        async.run
+      end
+
+      def run
+        now = Time.now.to_f
+        sleep now.ceil - now + @sleep_interval
+        # There is no way to pass anything into the block, which is why this server isn't all that useful.
+        # The client is intended to listen to notifications coming from other sources,
+        #   like a PG TRIGGER than sends a notification on INSERT, for example.
+        every(@run_interval) { ping }
+      end
+
+      # Helps with testing by making the notify synchronous.
+      def ping
+        notify(channel, Time.now.to_i)
+        debug "Notified #{channel}"
+      end
+
+      private
+
+      def pg_connection
+        @pg_connection ||= PG.connect(conninfo_hash)
+      end
+
+      def notify(channel, value)
+        pg_connection.exec("NOTIFY #{channel}, '#{value}';")
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/initialization/argument_extraction.rb

@@ -0,0 +1,34 @@
+module CelluloidIOPGListener
+  # Prepended to classes including the CelluloidIOPGListener::Client
+  # Takes the arguments relevant to the CelluloidIOPGListener::Client module
+  #   and extracts it leaving the rest of the arguments to be passed to the
+  #   initializer of classes including the CelluloidIOPGListener::Client
+  module Initialization
+    module ArgumentExtraction
+
+      # 1st initialize override invoked
+      def initialize(*args)
+        @client_extracted_signature = CelluloidIOPGListener::Initialization::ClientExtractedSignature.new(*args)
+        # When called from a sub-class of a class including Client
+        #   and the sub-class overrides initialize,
+        #   then the execution order changes,
+        #   and this method may no longer have a super.
+        # However, due to the nature of the initialize method we can't tell if we have a legitimate super or not.
+        super(*@client_extracted_signature.super_signature)
+      end
+
+      def dbname
+        conninfo_hash[:dbname]
+      end
+
+      def channel
+        @client_extracted_signature.channel
+      end
+
+      def conninfo_hash
+        @client_extracted_signature.conninfo_hash
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/initialization/async_listener.rb

@@ -0,0 +1,55 @@
+module CelluloidIOPGListener
+  # Prepended to classes including the CelluloidIOPGListener::Client
+  module Initialization
+    module AsyncListener
+
+      # 2nd initialize override invoked
+      # @callback_method  - Name of the method to be called when notifications are heard
+      #                     Default: :unlisten_wrapper (just to have a guaranteed method with the correct arity)
+      def initialize(*args)
+        hash_arg = args.last.is_a?(Hash) ? args.pop : {}
+        warn "[#{self.class}] You have not specified a callback_method, so :unlisten_wrapper will be used." unless hash_arg[:callback_method]
+        @callback_method = hash_arg.delete(:callback_method) || :unlisten_wrapper
+        # Doesn't appear to be any other way to make it work with subclassing,
+        #   due to the way Celluloid Proxies the class, and hijacks the inheritance chains
+        subclassed_client = hash_arg.delete(:subclassed_client) || false
+        args << hash_arg unless hash_arg.empty?
+
+        enhance_callback_method unless @callback_method == :unlisten_wrapper
+
+        # When called from a sub-class of a class including Client
+        #   and the sub-class overrides initialize,
+        #   then the execution order changes,
+        #   and this method may no longer have a super.
+        # However, due to the nature of the initialize method we can't tell if we have a legitimate super or not.
+        super(*args) if !subclassed_client
+
+        debug "Listening for notifications on #{dbname}:#{channel} with callback to #{@callback_method}"
+        async.start_listening
+        async.listen(channel, @callback_method)
+      end
+
+      def callback_method
+        @callback_method
+      end
+
+      private
+
+      def enhance_callback_method
+        # The class including CelluloidIOPGListener::Client must define
+        #   the method named by @callback_method
+        define_singleton_method(@callback_method) do |channel, payload|
+          unlisten_wrapper(channel, payload) do
+            if defined?(super)
+              super(channel, payload)
+            else
+              error "LISTENER ERROR: #{payload}"
+              raise CelluloidIOPGListener::Client::InvalidClient, "#{self.class} does not define a method :#{@callback_method} with arguments (channel, payload)"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/initialization/client_extracted_signature.rb

@@ -0,0 +1,41 @@
+module CelluloidIOPGListener
+  module Initialization
+    #
+    # Null Object Pattern, just in case there are no options passed to initialize
+    #
+    # @conninfo_hash    - Extracted (actually removed!) PG database connection options, such as would be sent to:
+    #                       PG.connect( *args ) # PG::Connection.new( *args )
+    #                     Options must be the same named parameters that PG.connect() expects in its argument hash
+    #                     The other parameter formats are accepted by PG::Connection.new are not supported here.
+    #                     Named after, and structurally identical to, PG::Connection#conninfo_hash
+    # @super_signature  - Arguments passed on to super, supports any type of argument signature / arity supported by Ruby itself.
+    # @channel          - The channel to listen to notifications on
+    #                     Default: None, raises an error if not provided.
+    #
+    class ClientExtractedSignature
+
+      # see http://deveiate.org/code/pg/PG/Connection.html for key meanings
+      KEYS = [:host, :hostaddr, :port, :dbname, :user, :password, :connect_timeout, :options, :tty, :sslmode, :krbsrvname, :gsslib, :service]
+
+      attr_reader :super_signature
+      attr_reader :conninfo_hash
+      attr_reader :channel
+
+      # args - an array
+      def initialize(*args)
+        hash_arg = args.last.is_a?(Hash) ? args.pop : {}
+        # Extract the channel first, as it is required
+        @channel = hash_arg.delete(:channel) || raise(ArgumentError, "[#{self.class}] :channel is required, but got #{args} and #{hash_arg}")
+        # Extract the args for PG.connect
+        @conninfo_hash = (hash_arg.keys & KEYS).
+          each_with_object({}) { |k,h| h.update(k => hash_arg.delete(k)) }.
+          # Future proof. Provide a way to send in any PG.connect() options not explicitly defined in KEYS
+          merge(hash_arg.delete(:conninfo_hash) || {})
+        # Add any other named parameters back to the args for super
+        args << hash_arg unless hash_arg.empty?
+        @super_signature = args
+      end
+
+    end
+  end
+end

data/lib/celluloid-io-pg-listener/version.rb

@@ -1,3 +1,3 @@
 module CelluloidIOPGListener
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid-io-pg-listener
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Peter Boling
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-10-06 00:00:00.000000000 Z
+date: 2015-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid-io
@@ -70,44 +70,100 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
 description: Asynchronously LISTEN for Postgresql NOTIFY messages with payloads and
   Do Something
 email:
@@ -127,6 +183,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- bin/setup.sql
 - celluloid-io-pg-listener.gemspec
 - gemfiles/rails_3.2.22.gemfile
 - gemfiles/rails_3.2.22.gemfile.lock
@@ -134,8 +191,14 @@ files:
 - gemfiles/rails_4.2.4.gemfile.lock
 - lib/celluloid-io-pg-listener.rb
 - lib/celluloid-io-pg-listener/client.rb
-- lib/celluloid-io-pg-listener/listener.rb
-- lib/celluloid-io-pg-listener/server.rb
+- lib/celluloid-io-pg-listener/examples/client.rb
+- lib/celluloid-io-pg-listener/examples/double_super_example.rb
+- lib/celluloid-io-pg-listener/examples/listener_client_by_inheritance.rb
+- lib/celluloid-io-pg-listener/examples/notify_server_by_inheritance.rb
+- lib/celluloid-io-pg-listener/examples/server.rb
+- lib/celluloid-io-pg-listener/initialization/argument_extraction.rb
+- lib/celluloid-io-pg-listener/initialization/async_listener.rb
+- lib/celluloid-io-pg-listener/initialization/client_extracted_signature.rb
 - lib/celluloid-io-pg-listener/version.rb
 homepage: https://github.com/pboling/celluloid-io-pg-listener
 licenses:

data/lib/celluloid-io-pg-listener/listener.rb

@@ -1,21 +0,0 @@
-module CelluloidIOPGListener
-  # An example Client class
-  class Listener
-
-    include CelluloidIOPGListener::Client
-
-    def initialize(dbname:, channel:)
-      info "Client will for notifications on #{dbname}:#{channel}"
-      @dbname = dbname
-      async.start_listening
-      async.listen(channel, :do_something)
-    end
-
-    def do_something(channel, payload)
-      unlisten_wrapper(channel, payload) do
-        info payload
-      end
-    end
-
-  end
-end

data/lib/celluloid-io-pg-listener/server.rb

@@ -1,38 +0,0 @@
-# Simple example of a server for sending notifications through postgresql that can be listened for.
-class CelluloidIOPGListener::Server
-
-  include Celluloid
-  include Celluloid::IO
-  include Celluloid::Internals::Logger
-
-  # Defaults:
-  #   1/10th of a second sleep intervals
-  #   1 second run intervals
-  def initialize(dbname:, channel:, run_interval: 1, sleep_interval: 0.1)
-    info "Server will send notifications to #{dbname}:#{channel}"
-    @dbname = dbname
-    @channel = channel
-    @sleep_interval = sleep_interval
-    @run_interval = run_interval
-    async.run
-  end
-
-  def run
-    now = Time.now.to_f
-    sleep now.ceil - now + @sleep_interval
-    # There is no way to pass anything into the block, which is why this server isn't all that useful.
-    # The client is intended to listen to notifications coming from other sources,
-    #   like a PG TRIGGER than sends a notification on INSERT, for example.
-    every(@run_interval) { notify(@channel, Time.now.to_i) }
-    info "Notified #{@channel}"
-  end
-
-  def pg_connection
-    @pg_connection ||= PG.connect( dbname: @dbname )
-  end
-
-  def notify(channel, value)
-    pg_connection.exec("NOTIFY #{channel}, '#{value}';")
-  end
-
-end