celluloid_pubsub 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6f2cc5d47821ffd7978565d41a340327ab51b6fa
-  data.tar.gz: dee1d542db5124599409140c02e6f1f3c14a4552
+  metadata.gz: 9465c4977a3bc3e524ad74ede798b375706d2995
+  data.tar.gz: 488e312ddd2a283eb3c04ad688c7446c0af569ae
 SHA512:
-  metadata.gz: f1e2d9aa26ebef0c3444648016876a8365e99c04cdbe6d32f9059186512974a9ed1c5efc0835b287565be5e3e93fd721981b24a0d70670a55bfd744b89f62579
-  data.tar.gz: 8060745c4484bb5d5a8fed2cdfc2c3ba8b02ca80cda63a033e2cde0b0e4567408c3eff56e5280a24539ffcbbf73cd8298f404e82917770affa114fcb4878c0e5
+  metadata.gz: 2c7e91caa3c87ba614eb92e585924690108b848c88b342cb83c41ee92d55cfa05cecebe04734a8fccc7dd98b2dfe35b75a5609cd1c186209635f6ffeb0e72c4a
+  data.tar.gz: 75fc469556285f61305268b7c0c17666d371da9636b7f236e7b287eef83022f009178216abb3537e7e2767db95c6442672c2454283420dbae8d3f0b28703a376

data/celluloid_pubsub.gemspec

@@ -22,21 +22,21 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'celluloid-websocket-client', '0.0.1'
   s.add_runtime_dependency 'activesupport', '~> 4.1', '>= 4.1.0'
 
-  s.add_development_dependency 'rspec-rails', '~> 2.0', '>= 2.0'
-  s.add_development_dependency 'guard', '~> 2.6', '>= 2.6'
-  s.add_development_dependency 'guard-rspec', '~> 4.2', '>= 4.2'
-  s.add_development_dependency 'simplecov', '~> 0.9', '>= 0.9'
+  s.add_development_dependency 'rspec-rails', '~> 3.3', '>= 3.3'
+  s.add_development_dependency 'guard', '~> 2.13', '>= 2.13'
+  s.add_development_dependency 'guard-rspec', '~> 4.6', '>= 4.6'
+  s.add_development_dependency 'simplecov', '~> 0.10', '>= 0.10'
   s.add_development_dependency 'simplecov-summary', '~> 0.0.4', '>= 0.0.4'
   s.add_development_dependency 'mocha', '~> 1.1', '>= 1.1'
   s.add_development_dependency 'coveralls', '~> 0.7', '>= 0.7'
   s.add_development_dependency 'rvm-tester', '~> 1.1', '>= 1.1'
 
-  s.add_development_dependency 'rubocop', '0.29'
-  s.add_development_dependency 'phare', '~> 0.6', '>= 0.6'
+  s.add_development_dependency 'rubocop', '~> 0.33', '>= 0.33'
+  s.add_development_dependency 'phare', '~> 0.7', '>= 0.7'
   s.add_development_dependency 'yard', '~> 0.8', '>= 0.8.7'
   s.add_development_dependency 'yard-rspec', '~> 0.1', '>= 0.1'
-  s.add_development_dependency 'redcarpet', '~> 3.2', '>= 3.2.2'
+  s.add_development_dependency 'redcarpet', '~> 3.3', '>= 3.3'
   s.add_development_dependency 'github-markup', '~> 1.3', '>= 1.3.3'
-  s.add_development_dependency 'inch', '~> 0.5', '>= 0.5.10'
+  s.add_development_dependency 'inch', '~> 0.6', '>= 0.6'
   s.add_development_dependency 'guard-inch', '~> 0.1', '>= 0.1.0'
 end

data/examples/simple_test.rb

@@ -19,9 +19,7 @@ class Subscriber
   include Celluloid::Logger
 
   def initialize(options = {})
-    @client = CelluloidPubsub::Client.connect({ actor: Actor.current }.merge(options)) do |ws|
-      ws.subscribe('test_channel') # this will execute after the connection is opened
-    end
+    @client = CelluloidPubsub::Client.connect({ actor: Actor.current, channel: 'test_channel' }.merge(options))
   end
 
   def on_message(message)
@@ -46,9 +44,7 @@ class Publisher
   include Celluloid::Logger
 
   def initialize(options = {})
-    @client = CelluloidPubsub::Client.connect({ actor: Actor.current }.merge(options)) do |ws|
-      ws.subscribe('test_channel2') # this will execute after the connection is opened
-    end
+    @client = CelluloidPubsub::Client.connect({ actor: Actor.current, channel: 'test_channel2' }.merge(options))
     @client.publish('test_channel', 'data' => 'my_message') # the message needs to be a Hash
   end
 

data/lib/celluloid_pubsub/client_pubsub.rb

@@ -28,7 +28,7 @@ module CelluloidPubsub
     class PubSubWorker
       include Celluloid
       include Celluloid::Logger
-      attr_accessor :actor, :connect_blk, :client, :options, :hostname, :port, :path
+      attr_accessor :actor, :client, :options, :hostname, :port, :path, :channel
 
       #  receives a list of options that are used to connect to the webserver and an actor to which the callbacks are delegated to
       #  when receiving messages from a channel
@@ -44,10 +44,10 @@ module CelluloidPubsub
       # @return [void]
       #
       # @api public
-      def initialize(options, &connect_blk)
+      def initialize(options)
         parse_options(options)
         raise "#{self}: Please provide an actor in the options list!!!" if @actor.blank?
-        @connect_blk = connect_blk
+        raise "#{self}: Please provide an channel in the options list!!!" if @channel.blank?
         @client = Celluloid::WebSocket::Client.new("ws://#{@hostname}:#{@port}#{@path}", Actor.current)
       end
 
@@ -66,6 +66,7 @@ module CelluloidPubsub
         raise 'Options is not a hash' unless options.is_a?(Hash)
         @options = options.stringify_keys!
         @actor = @options.fetch('actor', nil)
+        @channel = @options.fetch('channel', nil)
         @hostname = @options.fetch('hostname', CelluloidPubsub::WebServer::HOST)
         @port = @options.fetch('port', CelluloidPubsub::WebServer::PORT)
         @path = @options.fetch('path', CelluloidPubsub::WebServer::PATH)
@@ -147,6 +148,7 @@ module CelluloidPubsub
       def unsubscribe_all
         send_action('unsubscribe_all')
       end
+
       #  callback executes after connection is opened and delegates action to actor
       #
       # @return [void]
@@ -154,7 +156,7 @@ module CelluloidPubsub
       # @api public
       def on_open
         debug("#{self.class} websocket connection opened") if debug_enabled?
-        @connect_blk.call Actor.current
+        async.subscribe(@channel)
       end
 
       # callback executes when actor receives a message from a subscribed channel
@@ -245,8 +247,8 @@ module CelluloidPubsub
     # @return [CelluloidPubsub::Client::PubSubWorker]
     #
     # @api public
-    def self.connect(options = {}, &connect_blk)
-      CelluloidPubsub::Client::PubSubWorker.new(options, &connect_blk)
+    def self.connect(options = {})
+      CelluloidPubsub::Client::PubSubWorker.new(options)
     end
   end
 end

data/lib/celluloid_pubsub/version.rb

@@ -17,7 +17,7 @@ module CelluloidPubsub
     # minor release version
     MINOR = 0
     # tiny release version
-    TINY = 20
+    TINY = 21
     # prelease version ( set this only if it is a prelease)
     PRE = nil
 

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -10,7 +10,7 @@ describe CelluloidPubsub::Client do
     expected = nil
     CelluloidPubsub::Client::PubSubWorker.stubs(:new).returns(expected)
     res = CelluloidPubsub::Client.connect(options, &blk)
-    res.should eq expected
+    expect(res).to eq expected
   end
 end
 
@@ -19,11 +19,12 @@ describe CelluloidPubsub::Client::PubSubWorker do
   let(:options) { {} }
   let(:socket) { mock }
   let(:actor) { mock }
+  let(:channel) { 'some_channel' }
 
   before(:each) do
     Celluloid::WebSocket::Client.stubs(:new).returns(socket)
     socket.stubs(:text)
-    @worker = CelluloidPubsub::Client::PubSubWorker.new({ 'actor' => actor, enable_debug: true }, &blk)
+    @worker = CelluloidPubsub::Client::PubSubWorker.new({ 'actor' => actor, channel: channel, enable_debug: true }, &blk)
     @worker.stubs(:client).returns(socket)
     @worker.stubs(:debug)
     @worker.stubs(:async).returns(@worker)
@@ -32,8 +33,8 @@ describe CelluloidPubsub::Client::PubSubWorker do
 
   describe '#initialize' do
     it 'creates a object' do
-      @worker.connect_blk.should_not be_nil
-      @worker.actor.should eq actor
+      expect(@worker.channel).to eq channel
+      expect(@worker.actor).to eq actor
     end
   end
 
@@ -46,25 +47,25 @@ describe CelluloidPubsub::Client::PubSubWorker do
 
     it 'parses options' do
       @worker.parse_options(custom_options)
-      @worker.actor.should eq(actor)
-      @worker.hostname.should eq(hostname)
-      @worker.port.should eq(port)
-      @worker.path.should eq(path)
+      expect(@worker.actor).to eq(actor)
+      expect(@worker.hostname).to eq(hostname)
+      expect(@worker.port).to eq(port)
+      expect(@worker.path).to eq(path)
     end
 
     it 'sets defaults' do
       @worker.parse_options({})
-      @worker.actor.should eq(nil)
-      @worker.hostname.should eq('0.0.0.0')
-      @worker.port.should eq(1234)
-      @worker.path.should eq('/ws')
+      expect(@worker.actor).to eq(nil)
+      expect(@worker.hostname).to eq('0.0.0.0')
+      expect(@worker.port).to eq(1234)
+      expect(@worker.path).to eq('/ws')
     end
   end
 
   describe '#debug_enabled?' do
     it 'checks if debug is enabled' do
       act = @worker.debug_enabled?
-      act.should eq(true)
+      expect(act).to eq(true)
     end
   end
 
@@ -89,14 +90,14 @@ describe CelluloidPubsub::Client::PubSubWorker do
       message.expects(:present?).returns(true)
       message.stubs(:[]).with('client_action').returns('successful_subscription')
       actual = @worker.succesfull_subscription?(message)
-      actual.should eq(true)
+      expect(actual).to eq(true)
     end
 
     it 'checks the message and returns false' do
       message.expects(:present?).returns(true)
       message.stubs(:[]).with('client_action').returns('something_else')
       actual = @worker.succesfull_subscription?(message)
-      actual.should eq(false)
+      expect(actual).to eq(false)
     end
   end
 
@@ -113,7 +114,7 @@ describe CelluloidPubsub::Client::PubSubWorker do
     let(:channel) { 'some_channel' }
     let(:data) { 'some_message' }
     it 'chats with the server' do
-      @worker.connect_blk.expects(:call)
+      @worker.expects(:subscribe).with(channel)
       @worker.on_open
     end
   end

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -1,214 +1,214 @@
- # encoding:utf-8
-
- require 'spec_helper'
-
- describe CelluloidPubsub::Reactor do
-   let(:websocket) { mock }
-   let(:server) { mock }
-
-   before(:each) do
-     subject.stubs(:async).returns(subject)
-     server.stubs(:debug_enabled?).returns(false)
-     server.stubs(:async).returns(server)
-     server.stubs(:handle_dispatched_message)
-     server.stubs(:subscribers).returns({})
-     websocket.stubs(:read)
-     subject.stubs(:inspect).returns(subject)
-     subject.stubs(:run)
-     subject.work(websocket, server)
-     subject.stubs(:unsubscribe_from_channel).returns(true)
-     Celluloid::Actor.stubs(:kill).returns(true)
-   end
-
-   describe '#work' do
-     it 'works ' do
-       subject.expects(:run)
-       subject.work(websocket, server)
-       subject.websocket.should eq websocket
-       subject.server.should eq server
-       subject.channels.should eq []
-     end
-   end
-
-   #  describe '#rub' do
-   #    let(:data) { 'some message' }
-   #
-   #    it 'works ' do
-   #      subject.unstub(:run)
-   #      websocket.stubs(:read).returns(data)
-   #        subject.expects(:handle_websocket_message).with(data)
-   #      subject.run
-   #    end
-   #  end
-
-   describe '#parse_json_data' do
-     let(:data) { 'some message' }
-     let(:expected) { data.to_json }
-
-     it 'works with hash ' do
-       JSON.expects(:parse).with(data).returns(expected)
-       actual = subject.parse_json_data(data)
-       actual.should eq expected
-     end
-
-     it 'works with exception parsing  ' do
-       JSON.expects(:parse).with(data).raises(StandardError)
-       actual = subject.parse_json_data(data)
-       actual.should eq data
-     end
-   end
-
-   describe '#handle_websocket_message' do
-     let(:data) { 'some message' }
-     let(:json_data) { { a: 'b' } }
-
-     it 'handle_websocket_message' do
-       subject.expects(:parse_json_data).with(data).returns(json_data)
-       subject.expects(:handle_parsed_websocket_message).with(json_data)
-       subject.handle_websocket_message(data)
-     end
-   end
-
-   describe '#handle_parsed_websocket_message' do
-     it 'handle_websocket_message with a hash' do
-       data = { 'client_action' => 'b' }
-       data.expects(:stringify_keys).returns(data)
-       subject.expects(:delegate_action).with(data)
-       subject.handle_parsed_websocket_message(data)
-     end
-
-     it 'handle_websocket_message with something else than a hash' do
-       data = 'some message'
-       subject.expects(:handle_unknown_action).with(data)
-       subject.handle_parsed_websocket_message(data)
-     end
-   end
-
-   describe '#delegate_action' do
-     it 'unsubscribes all' do
-       data = { 'client_action' => 'unsubscribe_all' }
-       subject.expects(:unsubscribe_all).returns('bla')
-       subject.delegate_action(data)
-     end
-
-     it 'unsubscribes all' do
-       data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
-       subject.expects(:unsubscribe).with(data['channel'])
-       subject.delegate_action(data)
-     end
-
-     it 'subscribes to channell' do
-       data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
-       subject.expects(:start_subscriber).with(data['channel'], data)
-       subject.delegate_action(data)
-     end
-
-     it 'publish' do
-       data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
-       server.expects(:publish_event).with(data['channel'], data['data'].to_json)
-       subject.delegate_action(data)
-     end
-
-     it 'handles unknown' do
-       data = { 'client_action' => 'some action', 'channel' => 'some channel' }
-       subject.expects(:handle_unknown_action).with(data)
-       subject.delegate_action(data)
-     end
-   end
-
-   describe '#handle_unknown_action' do
-     it 'handles unknown' do
-       data = 'some data'
-       server.expects(:handle_dispatched_message)
-       subject.handle_unknown_action(data)
-     end
-   end
-
-   describe '#unsubscribe_client' do
-     let(:channel) { 'some channel' }
-     it 'returns nil' do
-       act = subject.unsubscribe('')
-       act.should eq(nil)
-     end
-
-     it 'unsubscribes' do
-       subject.channels.stubs(:blank?).returns(false)
-       subject.channels.expects(:delete).with(channel)
-       act = subject.unsubscribe(channel)
-       act.should eq(nil)
-     end
-
-     it 'unsubscribes' do
-       subject.channels.stubs(:blank?).returns(true)
-       subject.websocket.expects(:close)
-       act = subject.unsubscribe(channel)
-       act.should eq(nil)
-     end
-
-     it 'unsubscribes' do
-       subject.channels.stubs(:blank?).returns(false)
-       subject.channels.stubs(:delete)
-       server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
-       subject.unsubscribe(channel)
-       server.subscribers[channel].should eq([])
-     end
-   end
-
-   describe '#shutdown' do
-     it 'shutdowns' do
-       subject.expects(:terminate)
-       subject.shutdown
-     end
-   end
-
-   describe '#start_subscriber' do
-     let(:channel) { 'some channel' }
-     let(:message) { { a: 'b' } }
-
-     it 'subscribes ' do
-       act = subject.start_subscriber('', message)
-       act.should eq(nil)
-     end
-
-     it 'subscribes ' do
-       subject.stubs(:add_subscriber_to_channel).with(channel, message)
-       subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
-       subject.start_subscriber(channel, message)
-     end
-
-     #    it 'raises error' do
-     #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
-     #
-     #      expect do
-     #        subject.start_subscriber(channel, message)
-     #      end.to raise_error(StandardError) { |e|
-     #        expect(e.message).to include(channel)
-     #      }
-     #    end
-   end
-
-   describe '#add_subscriber_to_channel' do
-     let(:channel) { 'some channel' }
-     let(:message) { { a: 'b' } }
-
-     it 'adds subscribed' do
-       CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
-       CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
-       server.subscribers[channel] = []
-       server.subscribers[channel].expects(:<<).with(reactor: subject, message: message)
-       subject.add_subscriber_to_channel(channel, message)
-       subject.channels.should include(channel)
-     end
-   end
-
-   describe '#unsubscribe_all' do
-     let(:channel) { 'some channel' }
-     let(:message) { { a: 'b' } }
-
-     it 'adds subscribed' do
-       CelluloidPubsub::Registry.stubs(:channels).returns([channel])
-       subject.expects(:unsubscribe_from_channel).with(channel)
-       subject.unsubscribe_all
-     end
-   end
- end
+# encoding:utf-8
+
+require 'spec_helper'
+
+describe CelluloidPubsub::Reactor do
+  let(:websocket) { mock }
+  let(:server) { mock }
+
+  before(:each) do
+    subject.stubs(:async).returns(subject)
+    server.stubs(:debug_enabled?).returns(false)
+    server.stubs(:async).returns(server)
+    server.stubs(:handle_dispatched_message)
+    server.stubs(:subscribers).returns({})
+    websocket.stubs(:read)
+    subject.stubs(:inspect).returns(subject)
+    subject.stubs(:run)
+    subject.work(websocket, server)
+    subject.stubs(:unsubscribe_from_channel).returns(true)
+    Celluloid::Actor.stubs(:kill).returns(true)
+  end
+
+  describe '#work' do
+    it 'works ' do
+      subject.expects(:run)
+      subject.work(websocket, server)
+      expect(subject.websocket).to eq websocket
+      expect(subject.server).to eq server
+      expect(subject.channels).to eq []
+    end
+  end
+
+  #  describe '#rub' do
+  #    let(:data) { 'some message' }
+  #
+  #    it 'works ' do
+  #      subject.unstub(:run)
+  #      websocket.stubs(:read).returns(data)
+  #        subject.expects(:handle_websocket_message).with(data)
+  #      subject.run
+  #    end
+  #  end
+
+  describe '#parse_json_data' do
+    let(:data) { 'some message' }
+    let(:expected) { data.to_json }
+
+    it 'works with hash ' do
+      JSON.expects(:parse).with(data).returns(expected)
+      actual = subject.parse_json_data(data)
+      expect(actual).to eq expected
+    end
+
+    it 'works with exception parsing  ' do
+      JSON.expects(:parse).with(data).raises(StandardError)
+      actual = subject.parse_json_data(data)
+      expect(actual).to eq data
+    end
+  end
+
+  describe '#handle_websocket_message' do
+    let(:data) { 'some message' }
+    let(:json_data) { { a: 'b' } }
+
+    it 'handle_websocket_message' do
+      subject.expects(:parse_json_data).with(data).returns(json_data)
+      subject.expects(:handle_parsed_websocket_message).with(json_data)
+      subject.handle_websocket_message(data)
+    end
+  end
+
+  describe '#handle_parsed_websocket_message' do
+    it 'handle_websocket_message with a hash' do
+      data = { 'client_action' => 'b' }
+      data.expects(:stringify_keys).returns(data)
+      subject.expects(:delegate_action).with(data)
+      subject.handle_parsed_websocket_message(data)
+    end
+
+    it 'handle_websocket_message with something else than a hash' do
+      data = 'some message'
+      subject.expects(:handle_unknown_action).with(data)
+      subject.handle_parsed_websocket_message(data)
+    end
+  end
+
+  describe '#delegate_action' do
+    it 'unsubscribes all' do
+      data = { 'client_action' => 'unsubscribe_all' }
+      subject.expects(:unsubscribe_all).returns('bla')
+      subject.delegate_action(data)
+    end
+
+    it 'unsubscribes all' do
+      data = { 'client_action' => 'unsubscribe', 'channel' => 'some channel' }
+      subject.expects(:unsubscribe).with(data['channel'])
+      subject.delegate_action(data)
+    end
+
+    it 'subscribes to channell' do
+      data = { 'client_action' => 'subscribe', 'channel' => 'some channel' }
+      subject.expects(:start_subscriber).with(data['channel'], data)
+      subject.delegate_action(data)
+    end
+
+    it 'publish' do
+      data = { 'client_action' => 'publish', 'channel' => 'some channel', 'data' => 'some data' }
+      server.expects(:publish_event).with(data['channel'], data['data'].to_json)
+      subject.delegate_action(data)
+    end
+
+    it 'handles unknown' do
+      data = { 'client_action' => 'some action', 'channel' => 'some channel' }
+      subject.expects(:handle_unknown_action).with(data)
+      subject.delegate_action(data)
+    end
+  end
+
+  describe '#handle_unknown_action' do
+    it 'handles unknown' do
+      data = 'some data'
+      server.expects(:handle_dispatched_message)
+      subject.handle_unknown_action(data)
+    end
+  end
+
+  describe '#unsubscribe_client' do
+    let(:channel) { 'some channel' }
+    it 'returns nil' do
+      act = subject.unsubscribe('')
+      expect(act).to eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(false)
+      subject.channels.expects(:delete).with(channel)
+      act = subject.unsubscribe(channel)
+      expect(act).to eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(true)
+      subject.websocket.expects(:close)
+      act = subject.unsubscribe(channel)
+      expect(act).to eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(false)
+      subject.channels.stubs(:delete)
+      server.stubs(:subscribers).returns("#{channel}" => [{ reactor: subject }])
+      subject.unsubscribe(channel)
+      expect(server.subscribers[channel]).to eq([])
+    end
+  end
+
+  describe '#shutdown' do
+    it 'shutdowns' do
+      subject.expects(:terminate)
+      subject.shutdown
+    end
+  end
+
+  describe '#start_subscriber' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+
+    it 'subscribes ' do
+      act = subject.start_subscriber('', message)
+      expect(act).to eq(nil)
+    end
+
+    it 'subscribes ' do
+      subject.stubs(:add_subscriber_to_channel).with(channel, message)
+      subject.websocket.expects(:<<).with(message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json)
+      subject.start_subscriber(channel, message)
+    end
+
+    #    it 'raises error' do
+    #      subject.stubs(:add_subscriber_to_channel).raises(StandardError)
+    #
+    #      expect do
+    #        subject.start_subscriber(channel, message)
+    #      end.to raise_error(StandardError) { |e|
+    #        expect(e.message).to include(channel)
+    #      }
+    #    end
+  end
+
+  describe '#add_subscriber_to_channel' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+
+    it 'adds subscribed' do
+      CelluloidPubsub::Registry.channels.stubs(:include?).with(channel).returns(false)
+      CelluloidPubsub::Registry.channels.expects(:<<).with(channel)
+      server.subscribers[channel] = []
+      server.subscribers[channel].expects(:<<).with(reactor: subject, message: message)
+      subject.add_subscriber_to_channel(channel, message)
+      expect(subject.channels).to include(channel)
+    end
+  end
+
+  describe '#unsubscribe_all' do
+    let(:channel) { 'some channel' }
+    let(:message) { { a: 'b' } }
+
+    it 'adds subscribed' do
+      CelluloidPubsub::Registry.stubs(:channels).returns([channel])
+      subject.expects(:unsubscribe_from_channel).with(channel)
+      subject.unsubscribe_all
+    end
+  end
+end

data/spec/lib/celluloid_pubsub/registry_spec.rb

@@ -5,6 +5,6 @@ require 'spec_helper'
 describe CelluloidPubsub::Registry do
   it 'has class atributes' do
     act = CelluloidPubsub::Registry.respond_to?(:channels)
-    act.should eq true
+    expect(act).to eq true
   end
 end

data/spec/lib/celluloid_pubsub/web_server_spec.rb

@@ -1,49 +1,49 @@
- # encoding:utf-8
+# encoding:utf-8
 
- require 'spec_helper'
+require 'spec_helper'
 
- describe CelluloidPubsub::WebServer do
-   it 'should have host constant' do
-     CelluloidPubsub::WebServer::HOST.should eq('0.0.0.0')
-   end
+describe CelluloidPubsub::WebServer do
+  it 'should have host constant' do
+    expect(CelluloidPubsub::WebServer::HOST).to eq('0.0.0.0')
+  end
 
-   it 'should have host constant' do
-     CelluloidPubsub::WebServer::PORT.should eq(1234)
-   end
+  it 'should have host constant' do
+    expect(CelluloidPubsub::WebServer::PORT).to eq(1234)
+  end
 
-   it 'should have host constant' do
-     CelluloidPubsub::WebServer::PATH.should eq('/ws')
-   end
-   let(:options) { {} }
-   let(:web_server) { mock }
+  it 'should have host constant' do
+    expect(CelluloidPubsub::WebServer::PATH).to eq('/ws')
+  end
+  let(:options) { {} }
+  let(:web_server) { mock }
 
-   before(:each) do
-     CelluloidPubsub::WebServer.stubs(:new).returns(web_server)
-   end
+  before(:each) do
+    CelluloidPubsub::WebServer.stubs(:new).returns(web_server)
+  end
 
-   #  it '#initialize with default values ' do
-   #    web_server.parse_options({})
-   #    web_server.hostname.should eq(CelluloidPubsub::WebServer::HOST)
-   #    web_server.port.should eq(CelluloidPubsub::WebServer::PORT)
-   #    web_server.path.should eq(CelluloidPubsub::WebServer::PATH)
-   #    web_server.backlog.should eq(1024)
-   #    web_server.spy.should eq(false)
-   #  end
-   #
-   #  describe '#with custom values' do
-   #    let(:hostname) { '192.0.0.1' }
-   #    let(:port) { 13_456 }
-   #    let(:path) { '/pathy' }
-   #    let(:backlog) { 2048 }
-   #    let(:spy) { true }
-   #
-   #    it '#initialize with custom values ' do
-   #      web_server.parse_options(hostname: hostname, port: port, path: path, spy: spy, backlog: backlog)
-   #      web_server.hostname.should eq(hostname)
-   #      web_server.port.should eq(port)
-   #      web_server.path.should eq(path)
-   #      web_server.backlog.should eq(backlog)
-   #      web_server.spy.should eq(spy)
-   #    end
-   #  end
- end
+  #  it '#initialize with default values ' do
+  #    web_server.parse_options({})
+  #    web_server.hostname.should eq(CelluloidPubsub::WebServer::HOST)
+  #    web_server.port.should eq(CelluloidPubsub::WebServer::PORT)
+  #    web_server.path.should eq(CelluloidPubsub::WebServer::PATH)
+  #    web_server.backlog.should eq(1024)
+  #    web_server.spy.should eq(false)
+  #  end
+  #
+  #  describe '#with custom values' do
+  #    let(:hostname) { '192.0.0.1' }
+  #    let(:port) { 13_456 }
+  #    let(:path) { '/pathy' }
+  #    let(:backlog) { 2048 }
+  #    let(:spy) { true }
+  #
+  #    it '#initialize with custom values ' do
+  #      web_server.parse_options(hostname: hostname, port: port, path: path, spy: spy, backlog: backlog)
+  #      web_server.hostname.should eq(hostname)
+  #      web_server.port.should eq(port)
+  #      web_server.path.should eq(path)
+  #      web_server.backlog.should eq(backlog)
+  #      web_server.spy.should eq(spy)
+  #    end
+  #  end
+end

data/spec/spec_helper.rb

@@ -28,8 +28,6 @@ end
 require 'bundler/setup'
 require 'celluloid_pubsub'
 
-require 'rspec/autorun'
-
 RSpec.configure do |config|
   require 'rspec/expectations'
   config.include RSpec::Matchers

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid_pubsub
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-27 00:00:00.000000000 Z
+date: 2015-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -110,80 +110,80 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.13'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4.6'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0.10'
 - !ruby/object:Gem::Dependency
   name: simplecov-summary
   requirement: !ruby/object:Gem::Requirement
@@ -268,36 +268,42 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.33'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.29'
+        version: '0.33'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.29'
+        version: '0.33'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.33'
 - !ruby/object:Gem::Dependency
   name: phare
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -344,20 +350,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: github-markup
   requirement: !ruby/object:Gem::Requirement
@@ -384,20 +390,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.5'
+        version: '0.6'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.10
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: guard-inch
   requirement: !ruby/object:Gem::Requirement