websockethook 0.1.03 → 0.2.01

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f12e791fa2429ff43a0fe5834535487685cb8ee7
-  data.tar.gz: 8ab40acc4243e3709e58949a9afe5b3030c7bd58
+  metadata.gz: 345a7a56cda55cd3db3bd9b0b26599d2ee5f5b56
+  data.tar.gz: 2061804507bc06c370df8288fdbce5b34c5a4d10
 SHA512:
-  metadata.gz: 9bdffa58da91db7c2c0857879466dda153b736518b19e0c6ef76f6e04f50ecf299c3a877a5451382a572a23235ddfb4b082b56e53b37c584c95f2546a686d33f
-  data.tar.gz: c0387e1e207b2b01b6cdac83398c41e3c9db94f37b2924a6e83f9a0ab878e559ee316c7dd186fba9946cd01c16686ebac86338df2089df2acc5ae4347d7d23ad
+  metadata.gz: ec81675cce79fb343906c0493a50e21396f672ddceffeba9d904e1a2310a832972271d7f53eed69dcef0a3577238ba7490e58427579ea1c1916a8033d08f831b
+  data.tar.gz: 24d0253c0549891b91619e44ce441dcd78cae0a41ce47d6adaec7d423bca272243b44cc965c5d4cd4b74a2549639772bfad93d103ea30d456e0024816e1edc3e

data/lib/websockethook.rb

@@ -1,9 +1,10 @@
-require 'faye/websocket'
+require 'websocket-client-simple'
 require 'json'
-require 'eventmachine'
 
 class WebSocketHook
-  DEFAULT_HOST       = 'ws://websockethook.io'
+  attr_reader :host
+
+  DEFAULT_HOST       = 'wss://websockethook.io'
   DEFAULT_SLEEP      = 0.1
   DEFAULT_KEEP_ALIVE = true
   DEFAULT_PING       = 20
@@ -11,97 +12,56 @@ class WebSocketHook
   def initialize(options = {})
     @stopping = false
     initialize_host options
-    initialize_pause options
-    initialize_keep_alive options
-    initialize_ping options
+    # initialize_keep_alive options
   end
 
-  def listen(id=nil, &block)
-    fail 'Block must be provided' unless block && block.is_a?(Proc)
-    begin
-      @stopping = false
-      listener(id, &block)
-      restart = @keep_alive && !@stopping
-      if restart
-        block.call type: 'restart', message: 'restarting connection since it was lost'
-        sleep 5
-      end
-    end while restart
-  end
+  def listen(id=nil, &callback)
+    @ws = WebSocket::Client::Simple.connect(@host)
 
-  def stop
-    @stopping = true
-    stop_em
-  end
-
-  private
-
-  def initialize_host(options = {})
-    @host = options[:host] || DEFAULT_HOST
-    fail 'Host (:host) must be a URL' unless @host.is_a?(String)
-  end
+    this = self
+    @ws.on(:open)    { this.on_open(id, &callback) }
+    @ws.on(:message) {|message| this.on_message(message, &callback) }
+    @ws.on(:close)   { callback.call :closed }
+    @ws.on(:error)   { |er| callback.call :error, er }
 
-  def initialize_pause(options = {})
-    @pause = options[:sleep] || DEFAULT_SLEEP
-    fail 'Pause (:pause) must be a float or integer' unless @pause.is_a?(Float) || @pause.is_a?(Integer)
+    block(&callback)
   end
 
-  def initialize_keep_alive(options = {})
-    @keep_alive = options[:keep_alive] || DEFAULT_KEEP_ALIVE
-    fail 'Keep Alive (:keep_alive) must be a boolean (true/false)' unless @keep_alive == true || @keep_alive == false
-  end
-
-  def initialize_ping(options = {})
-    @ping = options[:ping] || DEFAULT_PING
-    fail 'Ping (:ping) must be an integer' unless @ping.is_a?(Integer)
+  def stop
+    unblock
+    @ws.close
   end
 
-  def stop_em
-    EM.stop
-  rescue
+  def on_open(id=nil, &callback)
+    callback.call :open
+    @ws.send({type:'register', id: id}.to_json) if id
   end
 
-  def listener(id, &block)
-    websocket(block) do |ws|
-      ws.on :open do
-        block.call type: 'open'
-        ws.send({type:'register',id:id}.to_json)
-      end
-      ws.on :message do |message|
-        data = nil
-        begin
-          data = JSON.parse(message.data, symbolize_names: true)
-        rescue => ex
-          block.call type: 'error', message: "Message received, but couldn't parse: #{ex.message}"
+  def on_message(message, &callback)
+    if message && message.data
+        data = JSON.parse(message.data) 
+        if data['type'] == 'registered'
+          callback.call :registered, data['data']
         end
-        content = data.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
-        data[:data][:url] = "#{@host.sub('ws://','http://')}#{data[:data][:path]}" if data[:type]=='registered' && data[:data] && data[:data][:path]
-        block.call(content) if data && block
+        callback.call :hook, {'id'=>data['id'], 'data' => data['data']} if data['type'] == 'hook'
       end
+  end
 
-      handle_ws(ws, :error, block) { @hooks.each { |hook| ws.send({ type: 'register', id: hook }.to_json) } }
-      handle_ws(ws, :close, block) { stop_em }
-      handle_ws(ws, :error, block) { stop_em }
-    end
+  def block(&callback)
+    begin
+      sleep 0.1
+    end while !@stopping
+    callback.call :stopped
+    @stopping = false
   end
 
-  def websocket(callback_block, &socket_block)
-    EM.run do
-      ws_settings = { ping: @ping }
-      ws = Faye::WebSocket::Client.new(@host, nil, ws_settings)
-      socket_block.call(ws)
-    end
-    callback_block.call(type: 'stopped')
-  rescue => ex
-    callback_block.call type: 'error', message: ex.message
-  rescue Interrupt
-    stop
-    callback_block.call(type: 'stopped')
+  def unblock
+    @stopping = true
   end
 
-  def handle_ws(ws, action, callback_block, &_block)
-    ws.on action do
-      callback_block.call(type: action.to_s)
-    end
+  def initialize_host(options = {})
+    @host = options[:host] || DEFAULT_HOST
+    fail 'Host (:host) must be a URL' unless @host.is_a?(String)
   end
+
 end

data/spec/websockethook_spec.rb

@@ -10,49 +10,51 @@ describe WebSocketHook do
   end
 
   it 'can open and close' do
-    expect(@logger).to receive(:log).with({type: 'open'})
-    expect(@logger).to receive(:log).with({type: 'close'})
-    expect(@logger).to receive(:log).with({type: 'stopped'})
+    expect(@logger).to receive(:log).with(:open)
+    expect(@logger).to receive(:log).with(:closed)
+    expect(@logger).to receive(:log).with(:stopped)
 
-    @ws.listen 'test' do |msg|
+    @ws.listen do |msg|
       @logger.log(msg)
       @ws.stop
     end
-
   end
 
   it 'can trigger a hook with data' do
-    expect(@logger).to receive(:log).with({type: 'open'})
-    expect(@logger).to receive(:log).with({type: 'registered', data: anything()})
-    expect(@logger).to receive(:log).with({type: 'hook', id: anything(), data: {this_is_a:'test'}})
-    expect(@logger).to receive(:log).with({type: 'close'})
-    expect(@logger).to receive(:log).with({type: 'stopped'})
-
-    @ws.listen do |msg|
-      @logger.log(msg)
+    expect(@logger).to receive(:log).with(:open,nil)
+    expect(@logger).to receive(:log).with(:registered, {'id'=>anything(),'path'=>anything()})
+    expect(@logger).to receive(:log).with(:hook, {'id'=> anything(), 'data' => {'this_is_a' => 'test'}})
+    expect(@logger).to receive(:log).with(:closed,nil)
+    expect(@logger).to receive(:log).with(:stopped,nil)
+
+    @ws.listen do |type,msg|
+      @logger.log(type,msg)
       
-      if msg[:type] == 'registered'
-        hook_url = msg[:data][:url]
-        RestClient.post(hook_url,this_is_a:'test')        
+      if type == :registered
+        host = @ws.host.sub(/^ws/,'http')
+        url = "#{host}#{msg['path']}"
+        RestClient.post(url,this_is_a:'test')        
       end
 
-      @ws.stop if msg[:type] == 'hook'
+      if type == :hook
+        @ws.stop 
+      end
     end    
   end
 
   it 'can register a custom id' do
     id = "test_#{SecureRandom.hex(4)}"
 
-    expect(@logger).to receive(:log).with({type: 'open'})
-    expect(@logger).to receive(:log).with({type: 'registered', data: anything()})
-    expect(@logger).to receive(:log).with({type: 'registered', data: {id:id, path:"/hook/#{id}",url:"http://websockethook.io/hook/#{id}"}})
-    expect(@logger).to receive(:log).with({type: 'close'})
-    expect(@logger).to receive(:log).with({type: 'stopped'})
+    expect(@logger).to receive(:log).with(:open, nil)
+    expect(@logger).to receive(:log).with(:registered, {'id'=>anything(),'path'=>anything()})
+    expect(@logger).to receive(:log).with(:registered, {'id'=>id, 'path'=>"/hook/#{id}"})
+    expect(@logger).to receive(:log).with(:closed, nil)
+    expect(@logger).to receive(:log).with(:stopped, nil)
 
-    @ws.listen id do |msg|
-      @logger.log(msg)
+    @ws.listen id do |type,msg|
+      @logger.log(type,msg)
       
-      if msg[:type] == 'registered' && msg[:data][:id] == id
+      if type == :registered && msg['id'] == id
         @ws.stop
       end
     end    

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: websockethook
 version: !ruby/object:Gem::Version
-  version: 0.1.03
+  version: 0.2.01
 platform: ruby
 authors:
 - Maciej Skierkowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-13 00:00:00.000000000 Z
+date: 2016-05-23 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: faye-websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.10.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -117,4 +103,3 @@ summary: A library for use the free web.sockethook.io service
 test_files:
 - "./spec/spec_helper.rb"
 - "./spec/websockethook_spec.rb"
-has_rdoc: