msngr 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80f389f5be19c06e918bbabc6758063ebc871298
+  data.tar.gz: d152dc1d6e25696fa09fc917248dfbb599483c1e
+SHA512:
+  metadata.gz: 249d9724441d3a927679ed6e8c88a7e3944c7812efe0a787f656bab7878796452d6d6c46d96a69f1f793680521b2989ab972c30251eff5e38bbf54d0aedde2a9
+  data.tar.gz: 53dc43080979cd573aae3ca906fe15abc4f61a07bcef3cdf15f6bde205766eabdeac76cb5b64aaa188af654012499161c40932708e788818a9050fd0e681e961

data/lib/msngr.rb

@@ -0,0 +1,18 @@
+require "msngr/version"
+require "msngr/receiver"
+require "msngr/messenger"
+
+module Msngr
+  module Clients; end
+  extend self
+
+  # Shorthand for writing Msngr::Messenger.new(*args).
+  #
+  # @param [Array] *args
+  # @return [Msngr::Messenger]
+  #
+  def new(*args)
+    Messenger.new(*args)
+  end
+end
+

data/lib/msngr/clients/redis.rb

@@ -0,0 +1,47 @@
+require "redis"
+
+class Msngr::Clients::Redis
+
+  # (Connectivity) Arguments to initialize the Redis instance with.
+  #
+  # @return [Array]
+  #
+  attr_reader :args
+
+  # Instantiances an instance of Msngr::Clients::Redis.
+  #
+  # @param [Array] *args the arguments to pass in to the Redis client.
+  #
+  def initialize(*args)
+    @args = args
+  end
+
+  # Yields all events/messages from the Redis server.
+  #
+  # @yield [event, message]
+  # @yieldparam [String] event the name of the received event.
+  # @yieldparam [String] message the message of the received event.
+  #
+  # @note This is an interface for Msngr::Messenger.
+  #
+  def on_message
+    connection.psubscribe("*") do |on|
+      on.pmessage { |_, event, message| yield event, message }
+    end
+  end
+
+  private
+
+  # Creates and returns a new instance of Redis using @args if present.
+  #
+  # @return [Redis]
+  #
+  def connection
+    if args.any?
+      Redis.new(*args)
+    else
+      Redis.new
+    end
+  end
+end
+

data/lib/msngr/messenger.rb

@@ -0,0 +1,103 @@
+require "thread"
+
+class Msngr::Messenger
+
+  # A client object interface to receive messages from.
+  #
+  # @return [Msngr::Clients::*]
+  #
+  attr_reader :client
+
+  # An Array of Receiver objects to dispatch callbacks/messages to.
+  #
+  # @return [Array<Receiver>]
+  #
+  attr_reader :receivers
+
+  # Initializes a new Messenger.
+  #
+  # @param [Msngr::Clients::*] client the to receive messages from.
+  # @return [Receiver]
+  #
+  def initialize(client)
+    @client    = client
+    @receivers = []
+    @mutex     = Mutex.new
+  end
+
+  # Creates and returns a new Receiver and adds it to @receivers so
+  # it'll receive messages matching the provided pattern.
+  #
+  # @param [Regexp] pattern
+  # @return [Receiver]
+  #
+  def subscribe(pattern)
+    Msngr::Receiver.new(pattern).tap do |receiver|
+      @mutex.synchronize { @receivers << receiver }
+    end
+  end
+
+  # Removes the Receiver from @receivers and invokes the receiver's
+  # @on_unsubscribe_callbacks.
+  #
+  # @param [Receiver] receiver
+  #
+  def unsubscribe(receiver)
+    @mutex.synchronize { @receivers.delete(receiver) }
+    dispatch(receiver.on_unsubscribe_callbacks, self)
+  end
+
+  # Listens on a new thread. Will auto-restart when crashed
+  # in an attempt to recover from exceptions.
+  #
+  def listen!
+    Thread.new do
+      loop do
+        begin
+          listen
+        rescue => e
+          puts "Messenger error occurred:"
+          puts "#{e.class.name}"
+          puts "#{e.backtrace.join("\n")}"
+          puts "Restarting.."
+          sleep 1
+        end
+      end
+    end
+  end
+
+  private
+
+  # Instructs the @client to yield events/messages when it receives them. Received
+  # events are matched with each Receiver's pattern and will dispatch the event's message
+  # to all subscribing Receiver instances that match the event's pattern.
+  #
+  def listen
+    client.on_message do |event, message|
+      subscribing_receivers(event) do |receiver|
+        dispatch(receiver.on_message_callbacks, message)
+      end
+    end
+  end
+
+  # Yields Receiver objects who's pattern matches the event.
+  #
+  # @param [String] event
+  # @yield [Receiver]
+  #
+  def subscribing_receivers(event)
+    receivers.each do |receiver|
+      yield receiver if receiver.pattern.match(event)
+    end
+  end
+
+  # Dispatches args to the provided callbacks.
+  #
+  # @param [Array<Proc>] callbacks
+  # @param [Array] *args an Array of arguments to call each Proc with.
+  #
+  def dispatch(callbacks, *args)
+    callbacks.each { |callback| callback.call(*args) }
+  end
+end
+

data/lib/msngr/receiver.rb

@@ -0,0 +1,61 @@
+require "thread"
+
+class Msngr::Receiver
+
+  # Event pattern to match.
+  #
+  # @return [String]
+  #
+  attr_reader :pattern
+
+  # Array of Procs to invoke when a message is received.
+  #
+  # @return [Array<Proc>]
+  #
+  attr_reader :on_message_callbacks
+
+  # Array of Procs to invoke when unsubscribed from a Messenger.
+  #
+  # @return [Array<Proc>]
+  #
+  attr_reader :on_unsubscribe_callbacks
+
+  # Initializes a new Receiver.
+  #
+  # @param [Regexp] pattern the pattern to listen for.
+  # @return [Receiver]
+  #
+  def initialize(pattern = /.+/)
+    @pattern                  = pattern
+    @on_message_callbacks     = []
+    @on_unsubscribe_callbacks = []
+    @mutex                    = Mutex.new
+  end
+
+  # Define a callback that invokes on each received message.
+  #
+  # @param [Proc] block
+  #
+  # @example
+  #   receiver.on_message do |message|
+  #     puts "Message Received: #{message}"
+  #   end
+  #
+  def on_message(&block)
+    @mutex.synchronize { @on_message_callbacks << block }
+  end
+
+  # Define a callback that invokes when unsubscribed from a Messenger.
+  #
+  # @param [Proc] block
+  #
+  # @example
+  #   receiver.on_unsubscribe do |messenger|
+  #     puts "Unsubscribed From: #{messenger}"
+  #   end
+  #
+  def on_unsubscribe(&block)
+    @mutex.synchronize { @on_unsubscribe_callbacks << block }
+  end
+end
+

data/lib/msngr/version.rb

@@ -0,0 +1,4 @@
+module Msngr
+  VERSION = "0.0.1"
+end
+

data/spec/lib/msngr/clients/redis_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "msngr/clients/redis"
+
+describe Msngr::Clients::Redis do
+
+  let(:client) { Msngr::Clients::Redis.new }
+
+  it "should initialize without redis options" do
+    client.should have(0).args
+  end
+
+  it "should initialize with arguments" do
+    client = Msngr::Clients::Redis.new(host: "127.0.0.1", port: 6379)
+    client.args.should == [{host: "127.0.0.1", port: 6379}]
+  end
+
+  it "should establish a connection without any args" do
+    Redis.expects(:new)
+    client.send(:connection)
+  end
+
+  it "should establish a connection with args" do
+    options = { host: "127.0.0.1", port: 6379 }
+    client = Msngr::Clients::Redis.new(options)
+    Redis.expects(:new).with(options)
+    client.send(:connection)
+  end
+
+  it "should yield a message" do
+    connection, on = mock, mock
+
+    client.stubs(:connection).returns(connection)
+    connection.expects(:psubscribe).with("*").yields(on)
+    on.expects(:pmessage).yields("", "room.1", "John joined the room!")
+
+    client.on_message do |event, message|
+      event.should == "room.1"
+      message.should == "John joined the room!"
+    end
+  end
+end
+

data/spec/lib/msngr/messenger_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+require "msngr/receiver"
+require "msngr/messenger"
+
+describe Msngr::Messenger do
+
+  let(:client)    { mock }
+  let(:messenger) { Msngr::Messenger.new(client) }
+
+  it "should initialize with an empty array of receivers" do
+    messenger.receivers.should be_empty
+  end
+
+  it "should create a new Receiver and add it to @receivers" do
+    receiver = messenger.subscribe(/.+/)
+    messenger.should have(1).receivers
+    messenger.receivers.first.should == receiver
+  end
+
+  it "should unsubscribe a receiver" do
+    receiver = messenger.subscribe(/.+/)
+    messenger.expects(:dispatch).
+      with(receiver.on_unsubscribe_callbacks, messenger)
+    messenger.unsubscribe(receiver)
+    messenger.should have(0).receivers
+  end
+
+  it "should start listening on a separate thread" do
+    Thread.expects(:new).yields
+    messenger.expects(:loop).yields
+    messenger.expects(:listen).once
+    messenger.listen!
+  end
+
+  it "should display a backtrace on error and restart" do
+    Thread.expects(:new).yields
+    messenger.expects(:loop).yields
+    messenger.expects(:listen).raises.then.returns
+    messenger.expects(:puts).times(4)
+    messenger.expects(:sleep)
+    messenger.listen!
+  end
+
+  it "should listen to the client but not dispatch" do
+    messenger.subscribe(/room\.2/)
+    client.expects(:on_message).yields("room.1", "Hi John")
+    messenger.expects(:dispatch).never
+    messenger.send(:listen)
+  end
+
+  it "should listen to the client and dispatch a message" do
+    messenger.subscribe(/room\.1/).on_message { |m| m.should == "Hi John" }
+    client.expects(:on_message).yields("room.1", "Hi John")
+    messenger.send(:listen)
+  end
+
+  it "should listen to the client and dispatch 3 messages" do
+    3.times do
+      messenger.subscribe(/room\.1/).tap do |receiver|
+        cb = proc {}
+        cb.expects(:call).with("Hi John")
+        receiver.on_message(&cb)
+      end
+    end
+
+    2.times do
+      messenger.subscribe(/room\.2/).tap do |receiver|
+        cb = proc {}
+        cb.expects(:call).never
+        receiver.on_message(&cb)
+      end
+    end
+
+    client.expects(:on_message).yields("room.1", "Hi John")
+    messenger.send(:listen)
+  end
+end
+

data/spec/lib/msngr/receiver_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "msngr/receiver"
+
+describe Msngr::Receiver do
+
+  let(:receiver) { Msngr::Receiver.new }
+
+  it "should initialize with a default wildcard pattern" do
+    receiver.pattern.should == /.+/
+  end
+
+  it "should initialize with a custom pattern" do
+    pattern = /rooms\.1/
+    Msngr::Receiver.new(pattern).pattern.should == pattern
+  end
+
+  it "should define an message callback" do
+    callback = proc { |msg| "invoked: #{msg}" }
+    receiver.on_message(&callback)
+
+    callbacks = receiver.on_message_callbacks
+    callbacks.size.should == 1
+    callbacks.first.call("message").should == "invoked: message"
+  end
+
+  it "should define an unsubscribe callback" do
+    callback = proc { |msngr| "unsubscribed from: #{msngr}" }
+    receiver.on_unsubscribe(&callback)
+
+    callbacks = receiver.on_unsubscribe_callbacks
+    callbacks.size.should == 1
+
+    object = Object.new
+    callbacks.first.call(object).should == "unsubscribed from: #{object}"
+  end
+end
+

data/spec/lib/msngr_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+require "msngr"
+
+describe Msngr do
+
+  it "should instantiate an instance of Msngr::Messenger" do
+    Msngr.new(mock).class.should == Msngr::Messenger
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require "simplecov"
+require "bundler"
+SimpleCov.start
+Bundler.require
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: msngr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael van Rooijen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+description: A light-weight Ruby library for multi-threaded Ruby applications that
+  allows threads to share a single service connection for more efficient messaging.
+email:
+- meskyanichi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- "./lib/msngr.rb"
+- "./lib/msngr/clients/redis.rb"
+- "./lib/msngr/messenger.rb"
+- "./lib/msngr/receiver.rb"
+- "./lib/msngr/version.rb"
+- "./spec/lib/msngr/clients/redis_spec.rb"
+- "./spec/lib/msngr/messenger_spec.rb"
+- "./spec/lib/msngr/receiver_spec.rb"
+- "./spec/lib/msngr_spec.rb"
+- "./spec/spec_helper.rb"
+homepage: https://github.com/meskyanichi/msngr/
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A light-weight Ruby library for multi-threaded Ruby applications that allows
+  threads to share a single service connection for more efficient messaging.
+test_files: []