celluloid_pubsub 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e37179d0afaad2f44c4b8e6d24fab235586cde36
-  data.tar.gz: a44ccf96280f12254beaa58a4694720945a16f1b
+  metadata.gz: 2e2bb403ba535ddc3097815566d5d19936ea86e1
+  data.tar.gz: 4919d72301e1b6bd5afb05742a28e897cbd0b194
 SHA512:
-  metadata.gz: f5592c3b5661b3c5e4a1c808e47c7f6340377e02a245b5de43ae612219cd2e833d3e3a4194b9dff3f8102692ee34a775872e3d8b5c48c5f254025bd561d5cd0d
-  data.tar.gz: 3251df4e8410b870d6a0ee5c02e837d58c279257035c15db294615cbf418a3f16359ddc24dbbb0b170cc0565db615501da951fe820277e8f7f5178c42b55600f
+  metadata.gz: 830e2d740aec3fe17a899f1623f0a7a4844ac9fe69348df0b3ce335f4a27decf0dea5af19039259da9dc3875061a1d6017aec676bda51003eab6d6c006cb4421
+  data.tar.gz: 558c3876da55ee779fea5d336f984fff2163b8420dae64a95b4680950eb9931db5ce6b551a2464250fe01987b0af55bceadfa8fb664c059f7efd46fbc78a3a30

data/.gitignore

@@ -15,3 +15,5 @@ Gemfile.lock
 /nbproject/
 /.git-rewrite/
 .yardoc/
+doc/
+bin/

data/.travis.yml

@@ -5,9 +5,9 @@ before_install:
 rvm:
 - 1.9.3
 - 2.0.0
-- 2.1
+- 2.1.5
 - 2.2
 env:
  - RAILS_ENV=test RACK_ENV=test 
 notifications:
-  email: false
+  email: false

data/Rakefile

@@ -3,6 +3,7 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'coveralls/rake/task'
 require 'yard'
+require 'yard-rspec'
 Coveralls::RakeTask.new
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
@@ -16,10 +17,12 @@ end
 #  Dummy::Application.load_tasks
 #  Rake::Task["db:test:prepare"].invoke
 # end
+YARD::Config.options[:load_plugins] = true
+YARD::Config.load_plugins
 
 YARD::Rake::YardocTask.new do |t|
-  t.files = ['lib/**/*.rb'] # optional
-  t.options = ['--any', '--extra', '--opts', '--markup-provider=redcarpet', '--markup=markdown'] # optional
+  t.files = ['lib/**/*.rb', 'spec/**/*_spec.rb'] # optional
+  t.options = ['--any', '--extra', '--opts', '--markup-provider=redcarpet', '--markup=markdown', '--debug'] # optional
   t.stats_options = ['--list-undoc'] # optional
 end
 
@@ -44,7 +47,7 @@ task :all do |_t|
   if ENV['TRAVIS']
     exec(' bundle exec phare &&  bundle exec rake  spec && bundle exec rake coveralls:push')
   else
-    exec('bundle exec phare && bundle exec rake spec')
+    exec('bundle exec rubocop -a . && bundle exec phare && bundle exec rake spec')
   end
 end
 

data/celluloid_pubsub.gemspec

@@ -33,8 +33,8 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rubocop', '0.29'
   s.add_development_dependency 'phare', '~> 0.6', '>= 0.6'
-  s.add_development_dependency 'scss-lint', '~> 0.34', '>= 0.34'
   s.add_development_dependency 'yard', '~> 0.8.7', '>= 0.8.7'
+  s.add_development_dependency 'yard-rspec', '~> 0.1', '>= 0.1'
   s.add_development_dependency 'redcarpet', '~> 3.2.2', '>= 3.2.2'
   s.add_development_dependency 'github-markup', '~> 1.3.3', '>= 1.3.3'
   s.add_development_dependency 'inch', '~> 0.5.10'

data/lib/celluloid_pubsub/reactor.rb

@@ -2,15 +2,13 @@ require_relative './registry'
 module CelluloidPubsub
   # The reactor handles new connections. Based on what the client sends it either subscribes to a channel
   # or will publish to a channel or just dispatch to the server if command is neither subscribe, publish or unsubscribe
+  #
   # @!attribute websocket
   #   @return [Reel::WebSocket] websocket connection
   #
   # @!attribute server
   #   @return [CelluloidPubsub::Webserver] the server actor to which the reactor is connected to
   #
-  # @!attribute mutex
-  #   @return [Mutex] mutex used to lock when subscribing to a channel
-  #
   # @!attribute channels
   #   @return [Array] array of channels to which the current reactor has subscribed to
   class Reactor
@@ -18,10 +16,10 @@ module CelluloidPubsub
     include Celluloid::IO
     include Celluloid::Logger
 
-    attr_accessor :websocket, :server, :mutex, :channels
+    attr_accessor :websocket, :server, :channels
 
     #  rececives a new socket connection from the server
-    #  and initiates a new mutex that can be used when subsribing to a channel
+    #  and listens for messages
     #
     # @param  [Reel::WebSocket] websocket
     #
@@ -30,7 +28,6 @@ module CelluloidPubsub
     # @api public
     def work(websocket, server)
       @server = server
-      @mutex = Mutex.new
       @channels = []
       @websocket = websocket
       info "Streaming changes for #{websocket.url}" if @server.debug_enabled?
@@ -44,11 +41,14 @@ module CelluloidPubsub
     # @return [void]
     #
     # @api public
+    #
+    # :nocov:
     def run
       while message = @websocket.read
         handle_websocket_message(message)
       end
     end
+    # :nocov:
 
     # method used to parse a JSON object into a Hash object
     #
@@ -170,11 +170,11 @@ module CelluloidPubsub
     # @api public
     def unsubscribe_client(channel)
       return unless channel.present?
-      @channels.delete(channel)
+      @channels.delete(channel) unless @channels.blank?
       @websocket.close if @channels.blank?
       @server.subscribers[channel].delete_if do |hash|
         hash[:reactor] == Actor.current
-      end
+      end if @server.subscribers[channel].present?
     end
 
     # the method will terminate the current actor
@@ -200,13 +200,9 @@ module CelluloidPubsub
     # @api public
     def start_subscriber(channel, message)
       return unless channel.present?
-      begin
-        add_subscriber_to_channel(channel, message)
-        debug "Subscribed to #{channel} with #{message}" if @server.debug_enabled?
-        @websocket << message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json
-      rescue => e
-        raise [e, e.respond_to?(:backtrace) ? e.backtrace : '', channel, message].inspect
-      end
+      add_subscriber_to_channel(channel, message)
+      debug "Subscribed to #{channel} with #{message}" if @server.debug_enabled?
+      @websocket << message.merge('client_action' => 'successful_subscription', 'channel' => channel).to_json
     end
 
     # adds the curent actor the list of the subscribers for a particular channel

data/lib/celluloid_pubsub/version.rb

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

data/lib/celluloid_pubsub/web_server.rb

@@ -51,12 +51,15 @@ module CelluloidPubsub
     # @return [void]
     #
     # @api public
+    #
+    # :nocov:
     def initialize(options = {})
       parse_options(options)
       @subscribers = {}
       info "CelluloidPubsub::WebServer example starting on #{@hostname}:#{@port}" if debug_enabled?
       super(@hostname, @port, { spy: @spy, backlog: @backlog }, &method(:on_connection))
     end
+    # :nocov:
 
     #  receives a list of options that are used to configure the webserver
     #

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -3,7 +3,135 @@
 require 'spec_helper'
 
 describe CelluloidPubsub::Client do
+  let(:options) { {} }
+  let(:blk) { proc { |a| puts a } }
+
+  it 'runs the connect method' do
+    expected = nil
+    CelluloidPubsub::Client::PubSubWorker.stubs(:new).returns(expected)
+    res = CelluloidPubsub::Client.connect(options, &blk)
+    res.should eq expected
+  end
 end
 
 describe CelluloidPubsub::Client::PubSubWorker do
+  let(:blk) { proc { |a| puts a } }
+  let(:options) { {} }
+  let(:socket) { mock }
+  let(:actor) { mock }
+
+  before(:each) do
+    Celluloid::WebSocket::Client.stubs(:new).returns(socket)
+    socket.stubs(:text)
+    @worker = CelluloidPubsub::Client::PubSubWorker.new({ 'actor' => actor }, &blk)
+    @worker.stubs(:client).returns(socket)
+    @worker.stubs(:debug)
+    @worker.stubs(:async).returns(@worker)
+    actor.stubs(:async).returns(actor)
+  end
+
+  describe '#initialize' do
+    it 'creates a object' do
+      @worker.connect_blk.should_not be_nil
+      @worker.actor.should eq actor
+    end
+  end
+
+  describe '#parse_options' do
+    let(:actor) { mock }
+    let(:hostname) { '127.0.0.1' }
+    let(:port) { 9999 }
+    let(:path) { '/some_path' }
+    let(:custom_options) { { actor: actor, hostname: hostname, port: port, path: path } }
+
+    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)
+    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')
+    end
+  end
+
+  describe '#debug_enabled?' do
+    it 'checks if debug is enabled' do
+      CelluloidPubsub::WebServer.expects(:debug_enabled?).returns(true)
+      act = @worker.debug_enabled?
+      act.should eq(true)
+    end
+  end
+
+  describe '#subscribe' do
+    let(:channel) { 'some_channel' }
+    it 'chats with the server' do
+      @worker.expects(:chat).with('client_action' => 'subscribe', 'channel' => channel)
+      @worker.subscribe(channel)
+    end
+  end
+
+  describe '#publish' do
+    let(:channel) { 'some_channel' }
+    let(:data) { 'some_message' }
+    it 'chats with the server' do
+      @worker.expects(:chat).with('client_action' => 'publish', 'channel' => channel, 'data' => data)
+      @worker.publish(channel, data)
+    end
+  end
+
+  describe '#on_open' do
+    let(:channel) { 'some_channel' }
+    let(:data) { 'some_message' }
+    it 'chats with the server' do
+      @worker.connect_blk.expects(:call)
+      @worker.on_open
+    end
+  end
+
+  describe '#on_message' do
+    let(:channel) { 'some_channel' }
+    let(:data) { 'some_message' }
+    it 'chats with the server' do
+      JSON.expects(:parse).with(data).returns(data)
+      @worker.actor.expects(:async).returns(actor)
+      @worker.actor.expects(:on_message).with(data)
+      @worker.on_message(data)
+    end
+  end
+
+  describe '#on_close' do
+    let(:channel) { 'some_channel' }
+    let(:code) { 'some_message' }
+    let(:reason) { 'some reason' }
+
+    it 'chats with the server' do
+      @worker.client.expects(:terminate)
+      @worker.actor.expects(:on_close).with(code, reason)
+      @worker.on_close(code, reason)
+    end
+  end
+
+  describe '#chat' do
+    let(:channel) { 'some_channel' }
+    let(:data) { 'some_message' }
+    let(:data_hash) { { a: 'some mesage ' } }
+    let(:json) { { action: 'message', message: data } }
+    it 'chats witout hash' do
+      JSON.expects(:dump).with(json).returns(json)
+      @worker.client.expects(:text).with(json)
+      @worker.send(:chat, data)
+    end
+
+    it 'chats with a hash' do
+      @worker.client.expects(:text).with(data_hash.to_json)
+      @worker.send(:chat, data_hash)
+    end
+  end
 end

data/spec/lib/celluloid_pubsub/reactor_spec.rb

@@ -3,4 +3,212 @@
 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)
+  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_client).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_client('')
+      act.should eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(false)
+      subject.channels.expects(:delete).with(channel)
+      act = subject.unsubscribe_client(channel)
+      act.should eq(nil)
+    end
+
+    it 'unsubscribes' do
+      subject.channels.stubs(:blank?).returns(true)
+      subject.websocket.expects(:close)
+      act = subject.unsubscribe_client(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_client(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])
+      server.subscribers.stubs(:[]).with(channel).returns([{ reactor: subject, message: message }])
+      subject.websocket.expects(:close)
+      subject.expects(:shutdown)
+      subject.unsubscribe_all
+    end
+  end
 end

data/spec/lib/celluloid_pubsub/registry_spec.rb

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

data/spec/lib/celluloid_pubsub/web_server_spec.rb

@@ -3,4 +3,47 @@
 require 'spec_helper'
 
 describe CelluloidPubsub::WebServer do
+  it 'should have host constant' do
+    CelluloidPubsub::WebServer::HOST.should 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
+    CelluloidPubsub::WebServer::PATH.should eq('/ws')
+  end
+  let(:options) { {} }
+  let(:web_server) { mock }
+
+  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

data/spec/spec_helper.rb

@@ -46,3 +46,11 @@ RSpec.configure do |config|
     end
   end
 end
+
+# class used for testing actions
+class TestActor
+  include Celluloid
+  include Celluloid::Logger
+end
+
+TestActor.supervise_as(:test_actor)