celluloid_pubsub 0.0.22 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fe9b479edc8ae87669502df2e243351d4e1ed661
-  data.tar.gz: 9334f13ffee94e5a64a849a079fdea00883e1964
+  metadata.gz: 81bb4bf2f3f59d8e2cea33053a7f89efb5af637d
+  data.tar.gz: 640efba60772877db2fdd2839b1359cc84578b19
 SHA512:
-  metadata.gz: c27edb339198ab3c647ae1421be96d3a1df46db3675907a8003d376d9176eafc8a0c17ef94235301c7ca19e0e18025f79cdc593346f205a20e0419d4f418152b
-  data.tar.gz: 208896557d1b7f8fe364a721bf9a49460853754470d491426d61fe067c03cb1a768632235d4066a98b9e1a8ebf7ac5faee8c927144e03296df90b3a762010220
+  metadata.gz: 70f8af8310490d573cbdb09b457da8695f91a7581e274e6793e0945a3f16a5021cad452f69165d874ae2714fe74d24545c775ed0a61dfaf856630700cd47bf8d
+  data.tar.gz: d4ff8d15ddbf405e136bbc0b17f502dc6ec4843f7e1ac7170711d45f57b3484762b7ed458a89392ed9fd2c330aa2f18fdff41784e7bbd53e8968d86e4de4fe73

data/celluloid_pubsub.gemspec

@@ -16,11 +16,11 @@ Gem::Specification.new do |s|
   s.test_files = s.files.grep(/^(spec)/)
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency 'celluloid', '~> 0.16', '~> 0.16.0'
+  s.add_runtime_dependency 'celluloid', '~> 0.16', '~> 0.16.0' # TODO: upgrade to version 0.17 - work in progress
   s.add_runtime_dependency 'celluloid-io', '~> 0.16', '>= 0.16.2'
   s.add_runtime_dependency 'reel', '~> 0.5', '>= 0.5.0'
-  s.add_runtime_dependency 'http', '~> 0.9.8', '>= 0.9.8' # TODO: remove this once fixed in reel gem
-  s.add_runtime_dependency 'celluloid-websocket-client', '0.0.1'
+  s.add_runtime_dependency 'http', '~> 0.9.8', '>= 0.9.8' # TODO: remove this once fixed in reel gem ( waiting for version 0.6.0 of reel to be stable)
+  s.add_runtime_dependency 'celluloid-websocket-client', '~> 0.0', '>= 0.0.1'
   s.add_runtime_dependency 'activesupport', '~> 4.1', '>= 4.1.0'
 
   s.add_development_dependency 'rspec-rails', '~> 3.3', '>= 3.3'

data/examples/simple_test.rb

@@ -19,7 +19,7 @@ class Subscriber
   include Celluloid::Logger
 
   def initialize(options = {})
-    @client = CelluloidPubsub::Client.connect({ actor: Actor.current, channel: 'test_channel' }.merge(options))
+    @client = CelluloidPubsub::Client.new({ actor: Actor.current, channel: 'test_channel' }.merge(options))
   end
 
   def on_message(message)
@@ -44,7 +44,7 @@ class Publisher
   include Celluloid::Logger
 
   def initialize(options = {})
-    @client = CelluloidPubsub::Client.connect({ actor: Actor.current, channel: 'test_channel2' }.merge(options))
+    @client = CelluloidPubsub::Client.new({ 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

@@ -1,254 +1,232 @@
 module CelluloidPubsub
-  # class used to make a new connection in order to subscribe or publish to a channel
+  # worker that subscribes to a channel or publishes to a channel
+  # if it used to subscribe to a channel the worker will dispatch the messages to the actor that made the
+  # connection in the first place.
+  #
+  # @!attribute actor
+  #   @return [Celluloid::Actor] actor to which callbacks will be delegated to
+  #
+  # @!attribute connect_blk
+  #   @return [Proc] Block  that will execute after the connection is opened
+  #
+  # @!attribute client
+  #   @return [Celluloid::WebSocket::Client] A websocket client that is used to chat witht the webserver
+  #
+  # @!attribute options
+  #   @return [Hash] the options that can be used to connect to webser and send additional data
+  #
+  # @!attribute hostname
+  #   @return [String] The hostname on which the webserver runs on
+  #
+  # @!attribute port
+  #  @return [String] The port on which the webserver runs on
+  #
+  # @!attribute path
+  #   @return [String] The hostname on which the webserver runs on
   class Client
-    # worker that subscribes to a channel or publishes to a channel
-    # if it used to subscribe to a channel the worker will dispatch the messages to the actor that made the
-    # connection in the first place.
+    include Celluloid
+    include Celluloid::Logger
+    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
     #
-    # @!attribute actor
-    #   @return [Celluloid::Actor] actor to which callbacks will be delegated to
+    # @param  [Hash]  options the options that can be used to connect to webser and send additional data
+    # @option options [String] :actor The actor that made the connection
+    # @option options [String]:hostname The hostname on which the webserver runs on
+    # @option options [String] :port The port on which the webserver runs on
+    # @option options [String] :path The request path that the webserver accepts
     #
-    # @!attribute connect_blk
-    #   @return [Proc] Block  that will execute after the connection is opened
+    # @param [Proc] connect_blk  Block  that will execute after the connection is opened
     #
-    # @!attribute client
-    #   @return [Celluloid::WebSocket::Client] A websocket client that is used to chat witht the webserver
+    # @return [void]
     #
-    # @!attribute options
-    #   @return [Hash] the options that can be used to connect to webser and send additional data
+    # @api public
+    def initialize(options)
+      parse_options(options)
+      raise "#{self}: Please provide an actor in the options list!!!" if @actor.blank?
+      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
+
+    # check the options list for values and sets default values if not found
     #
-    # @!attribute hostname
-    #   @return [String] The hostname on which the webserver runs on
+    # @param  [Hash]  options the options that can be used to connect to webser and send additional data
+    # @option options [String] :actor The actor that made the connection
+    # @option options [String]:hostname The hostname on which the webserver runs on
+    # @option options [String] :port The port on which the webserver runs on
+    # @option options [String] :path The request path that the webserver accepts
     #
-    # @!attribute port
-    #  @return [String] The port on which the webserver runs on
+    # @return [void]
     #
-    # @!attribute path
-    #   @return [String] The hostname on which the webserver runs on
-    class PubSubWorker
-      include Celluloid
-      include Celluloid::Logger
-      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
-      #
-      # @param  [Hash]  options the options that can be used to connect to webser and send additional data
-      # @option options [String] :actor The actor that made the connection
-      # @option options [String]:hostname The hostname on which the webserver runs on
-      # @option options [String] :port The port on which the webserver runs on
-      # @option options [String] :path The request path that the webserver accepts
-      #
-      # @param [Proc] connect_blk  Block  that will execute after the connection is opened
-      #
-      # @return [void]
-      #
-      # @api public
-      def initialize(options)
-        parse_options(options)
-        raise "#{self}: Please provide an actor in the options list!!!" if @actor.blank?
-        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
-
-      # check the options list for values and sets default values if not found
-      #
-      # @param  [Hash]  options the options that can be used to connect to webser and send additional data
-      # @option options [String] :actor The actor that made the connection
-      # @option options [String]:hostname The hostname on which the webserver runs on
-      # @option options [String] :port The port on which the webserver runs on
-      # @option options [String] :path The request path that the webserver accepts
-      #
-      # @return [void]
-      #
-      # @api public
-      def parse_options(options)
-        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)
-      end
-
-      #  checks if debug is enabled
-      #
-      #
-      # @return [boolean]
-      #
-      # @api public
-      def debug_enabled?
-        @options.fetch('enable_debug', false).to_s == 'true'
-      end
+    # @api public
+    def parse_options(options)
+      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)
+    end
 
-      # subscribes to a channel . need to be used inside the connect block passed to the actor
-      #
-      # @param [string] channel
-      #
-      # @return [void]
-      #
-      # @api public
-      def subscribe(channel)
-        subscription_data = { 'client_action' => 'subscribe', 'channel' => channel }
-        debug("#{self.class} tries to subscribe  #{subscription_data}") if debug_enabled?
-        async.chat(subscription_data)
-      end
+    #  checks if debug is enabled
+    #
+    #
+    # @return [boolean]
+    #
+    # @api public
+    def debug_enabled?
+      @options.fetch('enable_debug', false).to_s == 'true'
+    end
 
-      # checks if the message has the successfull subscription action
-      #
-      # @param [string] message
-      #
-      # @return [void]
-      #
-      # @api public
-      def succesfull_subscription?(message)
-        message.present? && message['client_action'].present? && message['client_action'] == 'successful_subscription'
-      end
+    # subscribes to a channel . need to be used inside the connect block passed to the actor
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def subscribe(channel)
+      subscription_data = { 'client_action' => 'subscribe', 'channel' => channel }
+      debug("#{self.class} tries to subscribe  #{subscription_data}") if debug_enabled?
+      async.chat(subscription_data)
+    end
 
-      # publishes to a channel some data (can be anything)
-      #
-      # @param [string] channel
-      # @param [#to_s] data
-      #
-      # @return [void]
-      #
-      # @api public
-      def publish(channel, data)
-        send_action('publish', channel, data)
-      end
+    # checks if the message has the successfull subscription action
+    #
+    # @param [string] message
+    #
+    # @return [void]
+    #
+    # @api public
+    def succesfull_subscription?(message)
+      message.present? && message['client_action'].present? && message['client_action'] == 'successful_subscription'
+    end
 
-      # unsubscribes current client from a channel
-      #
-      # @param [string] channel
-      #
-      # @return [void]
-      #
-      # @api public
-      def unsubscribe(channel)
-        send_action('unsubscribe', channel)
-      end
+    # publishes to a channel some data (can be anything)
+    #
+    # @param [string] channel
+    # @param [#to_s] data
+    #
+    # @return [void]
+    #
+    # @api public
+    def publish(channel, data)
+      send_action('publish', channel, data)
+    end
 
-      # unsubscribes all clients subscribed to a channel
-      #
-      # @param [string] channel
-      #
-      # @return [void]
-      #
-      # @api public
-      def unsubscribe_clients(channel)
-        send_action('unsubscribe_clients', channel)
-      end
+    # unsubscribes current client from a channel
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe(channel)
+      send_action('unsubscribe', channel)
+    end
 
-      # unsubscribes all clients from all channels
-      #
-      # @return [void]
-      #
-      # @api public
-      def unsubscribe_all
-        send_action('unsubscribe_all')
-      end
+    # unsubscribes all clients subscribed to a channel
+    #
+    # @param [string] channel
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_clients(channel)
+      send_action('unsubscribe_clients', channel)
+    end
 
-      #  callback executes after connection is opened and delegates action to actor
-      #
-      # @return [void]
-      #
-      # @api public
-      def on_open
-        debug("#{self.class} websocket connection opened") if debug_enabled?
-        async.subscribe(@channel)
-      end
+    # unsubscribes all clients from all channels
+    #
+    # @return [void]
+    #
+    # @api public
+    def unsubscribe_all
+      send_action('unsubscribe_all')
+    end
 
-      # callback executes when actor receives a message from a subscribed channel
-      # and parses the message using JSON.parse and dispatches the parsed
-      # message to the original actor that made the connection
-      #
-      # @param [JSON] data
-      #
-      # @return [void]
-      #
-      # @api public
-      def on_message(data)
-        debug("#{self.class} received  plain #{data}") if debug_enabled?
-        message = JSON.parse(data)
-        debug("#{self.class} received JSON  #{message}") if debug_enabled?
-        @actor.async.on_message(message)
-      end
+    #  callback executes after connection is opened and delegates action to actor
+    #
+    # @return [void]
+    #
+    # @api public
+    def on_open
+      debug("#{self.class} websocket connection opened") if debug_enabled?
+      async.subscribe(@channel)
+    end
 
-      # callback executes when connection closes
-      #
-      # @param [String] code
-      #
-      # @param [String] reason
-      #
-      # @return [void]
-      #
-      # @api public
-      def on_close(code, reason)
-        @client.terminate
-        terminate
-        debug("#{self.class} dispatching on close  #{code} #{reason}") if debug_enabled?
-        @actor.async.on_close(code, reason)
-      end
+    # callback executes when actor receives a message from a subscribed channel
+    # and parses the message using JSON.parse and dispatches the parsed
+    # message to the original actor that made the connection
+    #
+    # @param [JSON] data
+    #
+    # @return [void]
+    #
+    # @api public
+    def on_message(data)
+      debug("#{self.class} received  plain #{data}") if debug_enabled?
+      message = JSON.parse(data)
+      debug("#{self.class} received JSON  #{message}") if debug_enabled?
+      @actor.async.on_message(message)
+    end
 
-    private
+    # callback executes when connection closes
+    #
+    # @param [String] code
+    #
+    # @param [String] reason
+    #
+    # @return [void]
+    #
+    # @api public
+    def on_close(code, reason)
+      @client.terminate
+      terminate
+      debug("#{self.class} dispatching on close  #{code} #{reason}") if debug_enabled?
+      @actor.async.on_close(code, reason)
+    end
 
-      # method used to send an action to the webserver reactor , to a chanel and with data
-      #
-      # @param [String] action
-      # @param [String] channel
-      # @param [Hash] data
-      #
-      # @return [void]
-      #
-      # @api private
-      def send_action(action, channel = nil, data = {})
-        publishing_data = { 'client_action' => action }
-        publishing_data = publishing_data.merge('channel' => channel) if channel.present?
-        publishing_data = publishing_data.merge('data' => data) if data.present?
-        debug(" #{self.class}  sends:  #{publishing_data}") if debug_enabled?
-        async.chat(publishing_data)
-      end
+  private
 
-      # method used to send messages to the webserver
-      # checks too see if the message is a hash and if it is it will transform it to JSON and send it to the webser
-      # otherwise will construct a JSON object that will have the key action with the value 'message" and the key message witth the parameter's value
-      #
-      # @param [Hash] message
-      #
-      # @return [void]
-      #
-      # @api private
-      def chat(message)
-        final_message = nil
-        if message.is_a?(Hash)
-          debug("#{self.class} sends #{message.to_json}") if debug_enabled?
-          final_message = message.to_json
-        else
-          text_messsage = JSON.dump(action: 'message', message: message)
-          debug("#{self.class} sends JSON  #{text_messsage}") if debug_enabled?
-          final_message = text_messsage
-        end
-        @client.text final_message
-      end
+    # method used to send an action to the webserver reactor , to a chanel and with data
+    #
+    # @param [String] action
+    # @param [String] channel
+    # @param [Hash] data
+    #
+    # @return [void]
+    #
+    # @api private
+    def send_action(action, channel = nil, data = {})
+      publishing_data = { 'client_action' => action }
+      publishing_data = publishing_data.merge('channel' => channel) if channel.present?
+      publishing_data = publishing_data.merge('data' => data) if data.present?
+      debug(" #{self.class}  sends:  #{publishing_data}") if debug_enabled?
+      async.chat(publishing_data)
     end
 
-    # method used to make a new connection to the webserver
-    # after the connection is opened it will execute the block that is passed as argument
+    # method used to send messages to the webserver
+    # checks too see if the message is a hash and if it is it will transform it to JSON and send it to the webser
+    # otherwise will construct a JSON object that will have the key action with the value 'message" and the key message witth the parameter's value
     #
-    # @param  [Hash]  options the options that can be used to connect to webser and send additional data
-    # @option options [String] :actor The actor that made the connection
-    # @option options [String]:hostname The hostname on which the webserver runs on
-    # @option options [String] :port The port on which the webserver runs on
-    # @option options [String] :path The request path that the webserver accepts
-    #
-    # @param [Proc] connect_blk Block  that will execute after the connection is opened
+    # @param [Hash] message
     #
-    # @return [CelluloidPubsub::Client::PubSubWorker]
+    # @return [void]
     #
-    # @api public
-    def self.connect(options = {})
-      CelluloidPubsub::Client::PubSubWorker.new(options)
+    # @api private
+    def chat(message)
+      final_message = nil
+      if message.is_a?(Hash)
+        final_message = message.to_json
+        debug("#{self.class} sends #{message.to_json}") if debug_enabled?
+      else
+        final_message = JSON.dump(action: 'message', message: message)
+        debug("#{self.class} sends JSON  #{final_message}") if debug_enabled?
+      end
+      @client.text final_message
     end
   end
 end

data/lib/celluloid_pubsub/version.rb

@@ -15,9 +15,9 @@ module CelluloidPubsub
     # major release version
     MAJOR = 0
     # minor release version
-    MINOR = 0
+    MINOR = 1
     # tiny release version
-    TINY = 22
+    TINY = 0
     # prelease version ( set this only if it is a prelease)
     PRE = nil
 

data/spec/lib/celluloid_pubsub/client_pubsub_spec.rb

@@ -3,32 +3,23 @@
 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)
-    expect(res).to eq expected
-  end
-end
-
-describe CelluloidPubsub::Client::PubSubWorker do
   let(:blk) { proc { |a| puts a } }
   let(:options) { {} }
   let(:socket) { mock }
   let(:actor) { mock }
+  let(:connection) { 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, channel: channel, enable_debug: true }, &blk)
+    Celluloid::WebSocket::Client.stubs(:new).returns(connection)
+    @worker = CelluloidPubsub::Client.new({ 'actor' => actor, channel: channel, enable_debug: true }, &blk)
     @worker.stubs(:client).returns(socket)
-    @worker.stubs(:debug)
+    @worker.stubs(:debug).returns(true)
     @worker.stubs(:async).returns(@worker)
     actor.stubs(:async).returns(actor)
+    socket.stubs(:terminate).returns(true)
+    connection.stubs(:terminate).returns(true)
+    connection.stubs(:text).returns(true)
   end
 
   describe '#initialize' do
@@ -132,12 +123,11 @@ describe CelluloidPubsub::Client::PubSubWorker do
 
   describe '#on_close' do
     let(:channel) { 'some_channel' }
-    let(:code) { 'some_message' }
-    let(:reason) { 'some reason' }
+    let(:code) { 'some_code' }
+    let(:reason) { 'some_reason' }
 
     it 'chats with the server' do
-      @worker.client.expects(:terminate)
-      @worker.actor.expects(:on_close).with(code, reason)
+      actor.expects(:on_close).with(code, reason).returns(true)
       @worker.on_close(code, reason)
     end
   end
@@ -149,12 +139,12 @@ describe CelluloidPubsub::Client::PubSubWorker do
     let(:json) { { action: 'message', message: data } }
     it 'chats witout hash' do
       JSON.expects(:dump).with(json).returns(json)
-      @worker.client.expects(:text).with(json)
+      connection.expects(:text).with(json)
       @worker.send(:chat, data)
     end
 
     it 'chats with a hash' do
-      @worker.client.expects(:text).with(data_hash.to_json)
+      connection.expects(:text).with(data_hash.to_json)
       @worker.send(:chat, data_hash)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid_pubsub
 version: !ruby/object:Gem::Version
-  version: 0.0.22
+  version: 0.1.0
 platform: ruby
 authors:
 - bogdanRada
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-07 00:00:00.000000000 Z
+date: 2015-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: celluloid
@@ -94,14 +94,20 @@ dependencies:
   name: celluloid-websocket-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
 - !ruby/object:Gem::Dependency