wamp_rails 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19e8fd3cd6bce5cd796b61ffd66bf192e9111d8c
+  data.tar.gz: 074bc2d2a48553b137d91aa5891d6460c76c7b47
+SHA512:
+  metadata.gz: 41802f7ba79647f9b93778fb368c667126aa8ff5550d8f7c8b956b17a99ce56b48182e719e7938cf5645ceb25449c5e4b80328d1654b93cecb3ff4b21a36c861
+  data.tar.gz: f08c277926435a50a89e0307274d9a8dc49b3049d1daea47416a8e331463dbfe2309141b4502211e58e14d0fcdd895d9e3ec820e62fc35be0d0edd832479ad23

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.13.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Eric Chapman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,142 @@
+# WampRails
+
+This library allows the GEM [wamp_client](https://github.com/ericchapman/ruby_wamp_client) 
+to be integrated into a Rails application.
+
+The 'wamp_client' GEM uses the Event Machine implementation of Web Sockets to
+connect to the WAMP router.  This requires the Rails application to spin off
+an independent thread where the EM reactor will run.
+
+The library also wraps the connection logic under the library so that the 
+Rails application doesn't need to handle it.
+
+All calls to the library are implemented as "commands".  When a call is made to
+the client, the library will create a command and do the following
+
+ - If the thread is the same thread as the EM reactor, it will immediately
+   execute the command
+ - Else place the command into the queue that the reactor will check on every
+   tick
+   
+This ensures that the Rails application does not need to worry about the thread.
+
+This however has the side effect where all calls to the library are executed
+synchronously (they will block the current thread) unless the callback is nil.
+
+## Initialize
+
+The client is initialized as shown below.  The options are the same as
+'wamp_client' with the addition of the 'name' option which is used for
+logging.
+
+``` ruby
+options = {
+  name: 'main router',
+  uri: 'ws://router.example.com,
+  realm: 'realm1'
+}
+
+wamp_client = WampRails::Client.new(options)
+wamp_client.open
+```
+
+## Routes
+
+Routes are created using the 'routes' block.  This must be called BEFORE
+'open'.  Below is an example
+
+``` ruby
+options = {
+  uri: 'ws://router.example.com,
+  realm: 'realm1'
+}
+
+wamp_client = WampRails::Client.new(options)
+
+# Configure the Routes
+wamp_client.routes do
+  add_subscription 'topic', MySubscriptionClass
+  add_subscription 'topic.*', MyWildcardSubscriptionClass, {wildcard: true}
+  
+  add_procedure 'procedure.', MyPrefixProcedureClass, {prefix: true}
+end
+
+wamp_client.open
+```
+
+When 'routes' is used, the client object will automatically re-register/subscribe
+to the procedures/topics on reconnect.  Otherwise if 'register' or 'subscribe'
+are going to be called directly, then the system must wait for the connection
+to become active by calling
+
+``` ruby
+wamp_client.wait_for_active
+```
+
+## Commands
+
+The client currently supports the following commands from the WampClient library
+
+ - call
+ - publish
+ - register
+ - subscribe
+ 
+The methods have the same parameters as the WampClient library
+
+## Controllers
+
+The 'register' and 'subscribe' commands require 'handlers' to be implemented.
+In order to ensure thread safety and consistency with Rails, the handlers
+are implemented as 'controller' classes.
+
+When a call or publish is received, the library will instantiate the supplied
+class with following methods available
+
+ - args (Array) - The arguments
+ - kwargs (Hash) - The keyword arguments
+ - details (Hash) - The details
+ - client [WampRails::Client) - The client.  This can be used if the 
+   handler needs to send a Wamp message
+
+### Register
+To create a register controller, create a class that subclasses from
+'WampRails::Controller::Procedure' and implements 'handler'.  See below
+
+``` ruby
+class MyRegisterController < WampRails:::Controller::Procedure
+
+  def handler
+    the_args = self.args
+    the_kwargs = self.kwargs
+    the_details = self.details
+    the_client = self.client
+   
+    # Do Something
+   
+    # Return the result (see WampClient for more details on implementing procedures)
+    true
+  end
+
+end
+```
+
+### Subscribe
+To create a subscribe controller, create a class that subclasses from
+'WampRails::Controller::Subscription' and implements 'handler'.  See below
+
+``` ruby
+class MySubscribeController < WampRails:::Controller::Subscription
+
+  def handler
+    the_args = self.args
+    the_kwargs = self.kwargs
+    the_details = self.details
+    the_client = self.client
+   
+    # Do Something
+   
+  end
+
+end
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wamp_rails"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/wamp_rails.rb

@@ -0,0 +1,40 @@
+=begin
+
+Copyright (c) 2016 Eric Chapman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+=end
+
+require 'wamp_rails/version'
+require 'wamp_rails/error'
+require 'wamp_rails/commands/base_command'
+require 'wamp_rails/commands/base_handler'
+require 'wamp_rails/commands/call'
+require 'wamp_rails/commands/publish'
+require 'wamp_rails/commands/register'
+require 'wamp_rails/commands/subscribe'
+require 'wamp_rails/controllers/base_controller'
+require 'wamp_rails/controllers/procedure'
+require 'wamp_rails/controllers/subscription'
+require 'wamp_rails/client'
+

data/lib/wamp_rails/client.rb

@@ -0,0 +1,206 @@
+require 'thread'
+require 'wamp_client/connection'
+
+module WampRails
+
+  class Client
+    attr_accessor :options, :wamp, :cmd_queue, :thread, :name, :active, :verbose
+    attr_accessor :registrations, :subscriptions
+
+    # Called when the WAMP session presents a challenge
+    # @param authmethod [String]
+    # @param extra [Hash]
+    @on_challenge
+    def on_challenge(&on_challenge)
+      @on_challenge = on_challenge
+    end
+
+    # Returns true if the connection is active
+    def is_active?
+      self.active
+    end
+
+    # Waits for the session to become active
+    def wait_for_active
+      until self.is_active?
+      end
+    end
+
+    # Constructor for creating a client.  Options are
+    # @param options [Hash] The different options to pass to the connection
+    # @option options [String] :name - The name of the WAMP Client
+    # @option options [WampClient::Connection] :wamp - Allows a different WAMP to be passed in
+    # @option options [String] :uri The uri of the WAMP router to connect to
+    # @option options [String] :realm The realm to connect to
+    # @option options [String, nil] :protocol The protocol (default if wamp.2.json)
+    # @option options [String, nil] :authid The id to authenticate with
+    # @option options [Array, nil] :authmethods The different auth methods that the client supports
+    # @option options [Hash] :headers Custom headers to include during the connection
+    # @option options [WampClient::Serializer::Base] :serializer The serializer to use (default is json)
+    def initialize(options=nil)
+      self.options = options || {}
+      self.cmd_queue = Queue.new
+      self.registrations = []
+      self.subscriptions = []
+      self.name = self.options[:name] || 'default'
+      self.wamp = self.options[:wamp] || WampClient::Connection.new(self.options)
+      self.verbose = self.options[:verbose]
+      self.active = false
+
+      # WAMP initialization.   Note that all callbacks are called on the reactor thread
+      self.wamp.on_connect do
+        puts "WAMP Rails Client #{self.name} connection established" if self.verbose
+      end
+
+      self.wamp.on_join do |session, details|
+        puts "WAMP Rails Client #{self.name} was established" if self.verbose
+        self.active = true
+
+        # Register the procedures
+        self.registrations.each do |registration|
+          self._queue_command(registration)
+        end
+
+        # Subscribe to the topics
+        self.subscriptions.each do |subscription|
+          self._queue_command(subscription)
+        end
+      end
+
+      self.wamp.on_leave do |reason, details|
+        puts "WAMP Rails Client #{self.name} left because '#{reason}'" if self.verbose
+        self.active = false
+      end
+
+      self.wamp.on_disconnect do |reason|
+        puts "WAMP Rails Client #{self.name} disconnected because '#{reason}'" if self.verbose
+        self.active = false
+      end
+
+      self.wamp.on_challenge do |authmethod, extra|
+        if @on_challenge
+          @on_challenge.call(authmethod, extra)
+        else
+          puts "WAMP Rails Client #{self.name} auth challenge was received but no method was implemented." if self.verbose
+          nil
+        end
+      end
+
+      # Catch SIGINT
+      Signal.trap('INT') { self.close }
+      Signal.trap('TERM') { self.close }
+    end
+
+    # Opens the connection
+    def open
+      # Create the background thread
+      self.thread = Thread.new do
+        EM.tick_loop do
+          unless self.cmd_queue.empty?
+            command = self.cmd_queue.pop
+            self._execute_command(command)
+          end
+        end
+        self.wamp.open
+      end
+    end
+
+    # Closes the connection
+    def close
+      self.wamp.close
+    end
+
+    #region Route Methods
+
+    # Used to configure the routes for the client
+    def routes(&block)
+      self.instance_eval(&block)
+    end
+
+    # Adds a procedure to the client
+    def add_procedure(procedure, klass, options=nil)
+      options ||= {}
+      raise WampRails::Error.new('"add_procedure" must be called BEFORE "open"') if self.thread
+      self.registrations << WampRails::Command::Register.new(procedure, klass, options, self)
+    end
+
+    # Adds a subscription to the client
+    def add_subscription(topic, klass, options=nil)
+      options ||= {}
+      raise WampRails::Error.new('"add_subscription" must be called BEFORE "open"') if self.thread
+      self.subscriptions << WampRails::Command::Subscribe.new(topic, klass, options, self)
+    end
+
+    #endregion
+
+    #region WAMP Methods
+
+    # Performs a WAMP call
+    # @note This method is blocking if the callback is not nil
+    def call(procedure, args=nil, kwargs=nil, options={}, &callback)
+      command = WampRails::Command::Call.new(procedure, args, kwargs, options, self)
+      self._queue_command(command, callback)
+    end
+
+    # Performs a WAMP publish
+    # @note This method is blocking if the callback is not nil
+    def publish(topic, args=nil, kwargs=nil, options={}, &callback)
+      command = WampRails::Command::Publish.new(topic, args, kwargs, options, self)
+      self._queue_command(command, callback)
+    end
+
+    # Performs a WAMP register
+    # @note This method is blocking if the callback is not nil
+    def register(procedure, klass, options={}, &callback)
+      command = WampRails::Command::Register.new(procedure, klass, options, self)
+      self._queue_command(command, callback)
+    end
+
+    # Performs a WAMP subscribe
+    # @note This method is blocking if the callback is not nil
+    def subscribe(topic, klass, options={}, &callback)
+      command = WampRails::Command::Subscribe.new(topic, klass, options, self)
+      self._queue_command(command, callback)
+    end
+
+    #endregion
+
+    #region Private Methods
+
+    # Queues the command and blocks it the callback is not nil
+    # @param [WampRails::Command::Base] - The command to queue
+    # @param [Block] - The block to call when complete
+    def _queue_command(command, callback=nil)
+
+      # If the current thread is the EM thread, execute the command.  Else put it in the queue
+      if self.thread == Thread.current
+        self._execute_command(command)
+      else
+        self.cmd_queue.push(command)
+      end
+
+      # If the callback is defined, block until it finishes
+      if callback
+        callback_args = command.queue.pop
+        callback.call(callback_args.result, callback_args.error, callback_args.details)
+      end
+    end
+
+    # Executes the command
+    # @param [WampRails::Command::Base] - The command to execute
+    def _execute_command(command)
+      begin
+        unless self.is_active?
+          raise WampRails::Error.new("WAMP Rails Client #{self.name} is currently not active.")
+        end
+
+        command.execute
+      rescue Exception => e
+        puts e.to_s if self.verbose
+        command.callback(nil, {error: 'wamp_rails.error', args: [e.to_s], kwargs: nil}, nil)
+      end
+    end
+    #endregion
+
+  end
+end

data/lib/wamp_rails/commands/base_command.rb

@@ -0,0 +1,39 @@
+module WampRails
+  module Command
+    class BaseCommand
+      attr_accessor :queue, :client
+
+      # The callback object to place in the queue
+      class CallbackArgs
+        attr_accessor :result, :error, :details
+        def initialize(result, error, details)
+          self.result = result
+          self.error = error
+          self.details = details
+        end
+      end
+
+      def initialize(client)
+        self.queue = Queue.new
+        self.client = client
+      end
+
+      # Returns the session from the client
+      def session
+        self.client.wamp.session
+      end
+
+
+      # Executes the command.  This is called by the library in the EM Thread
+      def execute
+        # Override when sub classing
+      end
+
+      # Used in sub-classes to handle the response
+      def callback(result, error, details)
+        self.queue.push(CallbackArgs.new(result, error, details))
+      end
+
+    end
+  end
+end

data/lib/wamp_rails/commands/base_handler.rb

@@ -0,0 +1,20 @@
+module WampRails
+  module Command
+    class BaseHandler < BaseCommand
+      attr_accessor :klass
+
+      def handler
+        lambda { |args, kwargs, details|
+          object = klass.new(args, kwargs, details, client)
+          object.handler
+        }
+      end
+
+      def initialize(client, klass)
+        super(client)
+        self.klass = klass
+      end
+
+    end
+  end
+end

data/lib/wamp_rails/commands/call.rb

@@ -0,0 +1,24 @@
+module WampRails
+  module Command
+
+    class Call < BaseCommand
+      attr_accessor :procedure, :args, :kwargs, :options
+
+      def initialize(procedure, args, kwargs, options, client)
+        super(client)
+        self.procedure = procedure
+        self.args = args
+        self.kwargs = kwargs
+        self.options = options
+      end
+
+      def execute
+        session.call(procedure, args, kwargs, options) do |result, error, details|
+          self.callback(result, error, details)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/wamp_rails/commands/publish.rb

@@ -0,0 +1,24 @@
+module WampRails
+  module Command
+
+    class Publish < BaseCommand
+      attr_accessor :topic, :args, :kwargs, :options
+
+      def initialize(topic, args, kwargs, options, client)
+        super(client)
+        self.topic = topic
+        self.args = args
+        self.kwargs = kwargs
+        self.options = options
+      end
+
+      def execute
+        session.publish(topic, args, kwargs, options) do |result, error, details|
+          self.callback(result, error, details)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/wamp_rails/commands/register.rb

@@ -0,0 +1,23 @@
+module WampRails
+  module Command
+    class Register < BaseHandler
+      attr_accessor :procedure, :options
+
+      def initialize(procedure, klass, options, client)
+        super(client, klass)
+        self.procedure = procedure
+        self.options = options
+
+        unless self.klass < WampRails::Controller::Procedure
+          raise WampRails::Error.new('klass must be a WampRails::Controller::Procedure class')
+        end
+      end
+
+      def execute
+        session.register(procedure, handler, options) do |result, error, details|
+          self.callback(result, error, details)
+        end
+      end
+    end
+  end
+end

data/lib/wamp_rails/commands/subscribe.rb

@@ -0,0 +1,23 @@
+module WampRails
+  module Command
+    class Subscribe < BaseHandler
+      attr_accessor :topic, :klass, :options
+
+      def initialize(topic, klass, options, client)
+        super(client, klass)
+        self.topic = topic
+        self.options = options
+
+        unless self.klass < WampRails::Controller::Subscription
+          raise WampRails::Error.new('klass must be a WampRails::Controller::Subscription class')
+        end
+      end
+
+      def execute
+        session.subscribe(topic, handler, options) do |result, error, details|
+          self.callback(result, error, details)
+        end
+      end
+    end
+  end
+end

data/lib/wamp_rails/controllers/base_controller.rb

@@ -0,0 +1,34 @@
+module WampRails
+  module Controller
+    class BaseController
+
+      def initialize(args, kwargs, details, client)
+        @args = args || []
+        @kwargs = kwargs || {}
+        @details = details || {}
+        @client = client
+      end
+
+      def handler
+        raise WampRails::Error.new('WampRails::Controller::Base is an abstract class. "handler" must be defined')
+      end
+
+      def args
+        @args
+      end
+
+      def kwargs
+        @kwargs
+      end
+
+      def details
+        @details
+      end
+
+      def client
+        @client
+      end
+
+    end
+  end
+end

data/lib/wamp_rails/controllers/procedure.rb

@@ -0,0 +1,9 @@
+require 'wamp_rails/error'
+
+module WampRails
+  module Controller
+    class Procedure < BaseController
+
+    end
+  end
+end

data/lib/wamp_rails/controllers/subscription.rb

@@ -0,0 +1,9 @@
+require 'wamp_rails'
+
+module WampRails
+  module Controller
+    class Subscription < BaseController
+
+    end
+  end
+end

data/lib/wamp_rails/error.rb

@@ -0,0 +1,5 @@
+module WampRails
+  class Error < Exception
+
+  end
+end

data/lib/wamp_rails/version.rb

@@ -0,0 +1,3 @@
+module WampRails
+  VERSION = '0.0.2'
+end

data/spec/client_spec.rb

@@ -0,0 +1,129 @@
+require 'spec_helper'
+
+describe WampRails::Client do
+  before(:each) {
+    @client = described_class.new({wamp: WampRailsTest::TestConnection.new({})})
+    @client.routes do
+      add_procedure 'route.procedure', WampRailsTest::TestProcedureController
+      add_subscription 'route.topic', WampRailsTest::TestSubscriptionController
+    end
+    @client.open
+    @client.wait_for_active
+  }
+
+  after(:each) {
+    @client.close
+  }
+
+  describe 'commands' do
+    describe 'call' do
+      it 'sends a call command' do
+        @client.call('test.procedure', ['test'], {test: true}) do |result, error, details|
+          expect(result.count).to eq(4)
+          expect(result[0]).to eq('test.procedure')
+          expect(error).to be_nil
+        end
+      end
+
+      it 'processes an error' do
+        @client.call('test.procedure', ['test'], {test: true}, {error: true}) do |result, error, details|
+          expect(result).to be_nil
+          expect(error[:error]).to eq('wamp_rails.error')
+          expect(error[:args][0]).to eq('test exception')
+        end
+      end
+
+    end
+
+    describe 'publish' do
+      it 'sends a publish command' do
+        @client.publish('test.topic', ['test'], {test: true}) do |result, error, details|
+          expect(result.count).to eq(4)
+          expect(result[0]).to eq('test.topic')
+          expect(error).to be_nil
+        end
+      end
+
+      it 'processes an error' do
+        @client.publish('test.topic', ['test'], {test: true}, {error: true}) do |result, error, details|
+          expect(result).to be_nil
+          expect(error[:error]).to eq('wamp_rails.error')
+          expect(error[:args][0]).to eq('test exception')
+        end
+      end
+    end
+
+    describe 'register' do
+      it 'sends a register command' do
+        @client.register('test.procedure', WampRailsTest::TestProcedureController, {test: true}) do |result, error, details|
+          expect(result.count).to eq(4)
+          expect(result[0]).to eq('test.procedure')
+          expect(error).to be_nil
+        end
+      end
+
+      it 'processes an error' do
+        @client.register('test.procedure', WampRailsTest::TestProcedureController, {error: true}) do |result, error, details|
+          expect(result).to be_nil
+          expect(error[:error]).to eq('wamp_rails.error')
+          expect(error[:args][0]).to eq('test exception')
+        end
+      end
+
+      it 'raises an error when the class is incorrect' do
+        expect {
+          @client.register('test.procedure', Exception) do |result, error, details|
+            expect(result).to be_nil
+            expect(error[:error]).to eq('wamp_rails.error')
+          end
+        }.to raise_exception(WampRails::Error)
+      end
+    end
+
+    describe 'subscribe' do
+      it 'sends a subscribe command' do
+        @client.subscribe('test.topic', WampRailsTest::TestSubscriptionController, {test: true}) do |result, error, details|
+          expect(result.count).to eq(3)
+          expect(result[0]).to eq('test.topic')
+          expect(error).to be_nil
+        end
+      end
+
+      it 'processes an error' do
+        @client.subscribe('test.topic', WampRailsTest::TestSubscriptionController, {error: true}) do |result, error, details|
+          expect(result).to be_nil
+          expect(error[:error]).to eq('wamp_rails.error')
+          expect(error[:args][0]).to eq('test exception')
+        end
+      end
+
+      it 'raises an error when the class is incorrect' do
+        expect {
+          @client.subscribe('test.topic', Exception) do |result, error, details|
+            expect(result).to be_nil
+            expect(error[:error]).to eq('wamp_rails.error')
+          end
+        }.to raise_exception(Exception)
+      end
+    end
+
+    describe 'controllers' do
+
+      describe 'register' do
+        it 'calls the controller' do
+          @client.call('route.procedure', [4], {number: 5}) do |r, e, d|
+            expect(r[0][0]).to eq(9)
+          end
+        end
+      end
+
+      describe 'subscribe' do
+        it 'calls the controller' do
+          @client.publish('route.topic', [5], {number:4}) do |r, e, d|
+            expect(WampRailsTest::TestSubscriptionController.count).to eq(9)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+require_relative '../lib/wamp_rails'
+
+require 'wamp_rails'
+
+Dir[File.expand_path('spec/support/**/*.rb')].each { |f| require f }

data/spec/support/test_connection.rb

@@ -0,0 +1,18 @@
+require 'wamp_client/connection'
+
+module WampRailsTest
+  class TestConnection < WampClient::Connection
+
+    def open
+      EM.run do
+        self.session = WampRailsTest::TestSession.new
+        @on_join.call(self.session, {})
+      end
+    end
+
+    def close
+      EM.stop
+    end
+
+  end
+end

data/spec/support/test_procedure_controller.rb

@@ -0,0 +1,11 @@
+require 'wamp_rails'
+
+module WampRailsTest
+  class TestProcedureController < WampRails::Controller::Procedure
+
+    def handler
+      [(args[0] + kwargs[:number]), details, client]
+    end
+
+  end
+end

data/spec/support/test_session.rb

@@ -0,0 +1,60 @@
+module WampRailsTest
+  class TestSession
+    attr_accessor :calls, :registrations, :publishes, :subscriptions
+
+    def initialize
+      self.clear
+    end
+
+    def is_open?
+      true
+    end
+
+    def clear
+      self.calls = {}
+      self.registrations = {}
+      self.publishes = {}
+      self.subscriptions = {}
+    end
+
+    def call(procedure, args, kwargs, options, &callback)
+      self.calls[procedure] = { p: procedure, a: args, k: kwargs, o:options, c: callback }
+      raise Exception.new('test exception') if options[:error]
+
+      object = self.registrations[procedure]
+      handler = object != nil ? object[:h] : nil
+      if handler
+        response = handler.call(args, kwargs, {procedure: procedure, session: self})
+        callback.call([response], nil, {}) if callback
+      else
+        callback.call([procedure, args, kwargs, options], nil, {}) if callback
+      end
+    end
+
+    def register(procedure, handler, options=nil, interrupt=nil, &callback)
+      self.registrations[procedure] = { p: procedure, h: handler, o:options, i: interrupt, c:callback }
+      raise Exception.new('test exception') if options[:error]
+      callback.call([procedure, handler, options, interrupt], nil, {}) if callback
+    end
+
+    def publish(topic, args, kwargs, options, &callback)
+      self.publishes[topic] = { t: topic, a: args, k: kwargs, o:options, c: callback }
+      raise Exception.new('test exception') if options[:error]
+
+      object = self.subscriptions[topic]
+      handler = object != nil ? object[:h] : nil
+      if handler
+        handler.call(args, kwargs, {topic: topic, session: self})
+        callback.call([true], nil, {}) if callback
+      else
+        callback.call([topic, args, kwargs, options], nil, {}) if callback
+      end
+    end
+
+    def subscribe(topic, handler, options={}, &callback)
+      self.subscriptions[topic] = { t: topic, h: handler, o:options, c:callback }
+      raise Exception.new('test exception') if options[:error]
+      callback.call([topic, handler, options], nil, {}) if callback
+    end
+  end
+end

data/spec/support/test_subscription_controller.rb

@@ -0,0 +1,15 @@
+module WampRailsTest
+  class TestSubscriptionController < WampRails::Controller::Subscription
+    @@count = 0
+
+    def self.count
+      @@count
+    end
+
+    def handler
+      @@count = args[0] + kwargs[:number]
+      nil
+    end
+
+  end
+end

data/spec/wamp_rails_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe WampRails do
+  it "has a version number" do
+    expect(WampRails::VERSION).not_to be nil
+  end
+
+  it "does something useful" do
+    expect(false).to eq(true)
+  end
+end

data/wamp_rails.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wamp_rails/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wamp_rails"
+  spec.version       = WampRails::VERSION
+  spec.authors       = ['Eric Chapman']
+  spec.email         = ['eric.chappy@gmail.com']
+  spec.summary       = %q{Web Application Messaging Protocol Client for Rails}
+  spec.description   = %q{An implementation of The Web Application Messaging Protocol (WAMP)}
+  spec.homepage      = 'https://github.com/ericchapman/ruby_wamp_rails'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'codecov'
+
+  spec.add_dependency 'wamp_client', '~> 0.0.7'
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: wamp_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Eric Chapman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: wamp_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.7
+description: An implementation of The Web Application Messaging Protocol (WAMP)
+email:
+- eric.chappy@gmail.com
+executables:
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/wamp_rails.rb
+- lib/wamp_rails/client.rb
+- lib/wamp_rails/commands/base_command.rb
+- lib/wamp_rails/commands/base_handler.rb
+- lib/wamp_rails/commands/call.rb
+- lib/wamp_rails/commands/publish.rb
+- lib/wamp_rails/commands/register.rb
+- lib/wamp_rails/commands/subscribe.rb
+- lib/wamp_rails/controllers/base_controller.rb
+- lib/wamp_rails/controllers/procedure.rb
+- lib/wamp_rails/controllers/subscription.rb
+- lib/wamp_rails/error.rb
+- lib/wamp_rails/version.rb
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_connection.rb
+- spec/support/test_procedure_controller.rb
+- spec/support/test_session.rb
+- spec/support/test_subscription_controller.rb
+- spec/wamp_rails_spec.rb
+- wamp_rails.gemspec
+homepage: https://github.com/ericchapman/ruby_wamp_rails
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Web Application Messaging Protocol Client for Rails
+test_files:
+- spec/client_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_connection.rb
+- spec/support/test_procedure_controller.rb
+- spec/support/test_session.rb
+- spec/support/test_subscription_controller.rb
+- spec/wamp_rails_spec.rb