pubnub-ruby 3.3.0.7 → 3.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4219b71d48f11981cf5a684cebd7798a8f1f257a
+  data.tar.gz: 9ae07ffce739b205e9218e5ca8ad5324d2c6101b
+SHA512:
+  metadata.gz: df2db6abb8b114a0a57c2926cfefc0d81ddc601b530ada6b954af44a82eea4af805af114dbf3e0ffeb6f4aa9b073d7aca76cf6070952809e510833ac90668205
+  data.tar.gz: c70ccaa069c49316cf3c0f9051a1e488e23792e47eea38ae9d65a66a1e1ebb0c6a4d15d7052d089676521f32ae29eaaa841f741102945443ddcd8d8cbffc7aed

data/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+pubnub-*.gem
+.ruby-version
+*.iml
+.idea/
+log/*
+*.log

data/.yardoc/checksums

@@ -0,0 +1,13 @@
+lib/pubnub/client.rb 24d210ab228a4803805472666581d982de7e7460
+lib/pubnub/configuration.rb 16cd59eb2bba2d60b411817fc12807e37a55342f
+lib/pubnub/crypto.rb 5795f15e8380ab4e4df7b66002ba27a0ef6773ca
+lib/pubnub/daemon.rb 887fe6589269f6244ac45542d278107a143cc04b
+lib/pubnub/em/client.rb 8132d65f67e1128dc94c2cd7a81fcb2672efb367
+lib/pubnub/em/connection.rb 0e07699d0469d8f072d9b93a711173e169bf6973
+lib/pubnub/em/request.rb 6e95650a088ac04a419d18235cfe84a872803bff
+lib/pubnub/em/response.rb e750b47b62843dc39bfdc006b60d6552143b3b8a
+lib/pubnub/error.rb dad9a587bdeb0d53dc217a4f3e156bc6787106c1
+lib/pubnub.rb eab5c5b85a1760514e2d3a7d200f2b5f53690d09
+lib/pubnub/request.rb affdaa20d405404058de3f0ae19bbf2ef222a172
+lib/pubnub/response.rb 47a9a785572eae36391ec7da9f214efa8f826876
+lib/version.rb 47184c709077ffbfe1336763c37cfd9cbc62cd77

data/LICENSE

@@ -0,0 +1,27 @@
+PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
+Copyright (c) 2013 PubNub Inc.
+http://www.pubnub.com/
+http://www.pubnub.com/terms
+
+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.
+
+PubNub Real-time Cloud-Hosted Push API and Push Notification Client Frameworks
+Copyright (c) 2013 PubNub Inc.
+http://www.pubnub.com/
+http://www.pubnub.com/terms

data/README.md

@@ -0,0 +1,259 @@
+##### YOU MUST HAVE A PUBNUB ACCOUNT TO USE THE API.
+##### http://www.pubnub.com/account
+
+## PubNub Gem version 3.4
+
+www.pubnub.com - PubNub Real-time Push Service in the Cloud. 
+
+PubNub is a Real-time Network for Mobile App, Web Apps for pushing updates and enabling real-time notifications and even games!
+
+### Upgrading from PubNub 3.3.x and Earlier
+PubNub 3.4 is NOT compatible with earlier versions of Pubnub Ruby Client.  If you are upgrading from 3.3.x, the changes you will need to make are minimal.
+
+### New Features of 3.4
+There are a lot of cool features introduced in the 3.4 version of the gem. Notably:
+
+* Ability to carry out requests asynchronously or synchronously
+* Message handling via callback, block, and return
+* Heroku and JRuby Support (JRuby requires calls to be made synchronously)
+
+#### Asynchronous vs Synchronous Responses
+Feedback from prior versions of the gem demonstrated that some users would like to 'fire and forget' PubNub calls. Others wanted to block, and take specific action, based on server response.
+
+In 3.4, you can now have both, even on a per-call basis!
+
+#### Message Handling: callback, block, return
+Feedback from users of prior versions demonstrated the need for flexibility in how received messages were handled. The general PubNub response pattern dictated that responses be sent to callbacks, however, there was also a non-addressed use case of simply assigning a variable on return.
+
+In 3.4, you can now have both, even on a per-call basis!
+
+### Code Examples
+
+#### Require
+```ruby
+require 'pubnub'
+```
+
+#### Init and instantiate a new PubNub instance
+
+```ruby
+pubnub = Pubnub.new(
+    :subscribe_key    => 'demo',
+    :publish_key      => 'demo',
+    :origin           => origin,
+    :error_callback   => lambda { |msg|
+      puts "SOMETHING TERRIBLE HAPPENED HERE: #{msg.inspect}"
+    },
+    :connect_callback => lambda { |msg|
+      puts "CONNECTED: #{msg.inspect}"
+    }
+)
+```
+
+* subscribe_key is your subscribe key
+* publish_key is your publish key
+* origin is your custom, PubNub origin (Contact support before production to get your own!)
+* error_callback is the callback for errors
+* connect_callback is the callback that lets you know when you're connected to the origin
+
+#### Making PubNub calls
+There are a few different ways to make any given PubNub call. How to do it depends first on whether or not you want the call to be blocking (synchronous), or not blocking (asynchronous).
+
+##### Asynchronous (non-blocking) calling
+
+If you wish to make asyncronous calls (implemented via EM), you have a few different patterns you can follow:
+
+```ruby
+# Lets use a callback for the first example...
+cb = lambda { |envelope| puts envelope.message }
+
+# Asynchronous is implicitly enabled by default, if you do not provide an :http_sync option
+pubnub.publish(:message => msg, :channel => channel, :callback => cb)
+
+# You can also explicitly request async with :http_sync => false
+pubnub.publish(:message => msg, :channel => channel, :callback => cb, :http_sync => true)
+
+# Alternatively, you can pass in the callback as a block
+
+pubnub.publish(:message => msg, :channel => channel, &cb)
+
+pubnub.publish(:message => msg, :channel => channel) do |envelope| 
+    puts envelope.message
+    puts envelope.channel
+    puts envelope.status_code
+    puts envelope.timetoken 
+end
+```
+
+##### Synchronous (blocking) calling
+Synchronous calling is required when using PubNub with JRuby.
+
+If you'd prefer to make your calls blocking (implemented via HTTParty), set :http_sync => true. Again, there is a bit of flexibility in how this can be done:
+
+```ruby
+
+# Lets use a callback for the first example...
+cb = lambda { |envelope| puts envelope.message }
+
+# Sync (blocking) with a callback (if you wanted to)
+pubnub.publish(:http_sync => true, :message => msg, :channel => channel, &cb)
+
+# Sync (blocking), with assignment via return
+myResponse = pubnub.publish(:http_sync => true, :message => msg, :channel => channel)
+puts "myR: #{myResponse}" 
+
+# Sync (blocking), with a block
+pubnub.publish(:http_sync => true, :message => msg, :channel => channel) do |envelope| 
+    puts envelope.message
+    puts envelope.channel
+    puts envelope.status_code
+    puts envelope.timetoken 
+end
+```
+
+#### Callback / Block calling sequence
+
+When you receive messages asynchronously from PubNub, your block or callback will be called once for each message received.  For example, if you are subscribed to a channel using the callback pattern, and you receive 3 messages from your call, the callback will be called 3 times, 1 time for each unique received message.
+
+Conceptually, the callback or block is fired once for each message in the raw server response:
+
+```
+foreach (message in response)
+    callbackOrBlock(message)
+```
+
+
+#### The Envelope Object and Pubnub::Response
+The callback (or block) will receive the message(s) in the form of an envelope hash. An envelope will contain the following keys:
+
+* message (aliased as 'msg') -> Holds message
+* channel -> Holds channel for current message
+* timetoken -> Timetoken of server response
+* status_code -> Server response status code
+* response -> Whole and unmodified server response
+
+Don't confuse the **message** with the **response**. In a given callback cycle, the **response** will always be the same, as its the raw server response. It may consist of one or more messages.
+
+Internally, the block or callback is iterates over the response array, similar to:
+
+```
+foreach (message in response)
+    callbackOrBlock(message)
+```
+
+In a given callback cycle, the **message** will be the currently iterated message item of the response.
+
+### Simple Usage Examples
+
+#### Init and instantiate a new PubNub instance
+
+```ruby
+pubnub = Pubnub.new(
+    :subscribe_key    => 'demo',
+    :publish_key      => 'demo',
+    :origin           => origin,
+    :uuid			   => "myUserID",
+    :error_callback   => lambda { |msg|
+      puts "SOMETHING TERRIBLE HAPPENED HERE: #{msg.inspect}"
+    },
+    :connect_callback => lambda { |msg|
+      puts "CONNECTED: #{msg.inspect}"
+    }
+)
+```
+
+#### Publish
+When publishing, send a string, number, array, or hash. PubNub automatically serializes it to JSON for you, so you don't have to.
+
+
+```ruby
+@my_callback = lambda { |envelope| puts(envelope.msg) }
+
+pubnub.publish(
+    :channel  => "hello_world"",
+    :message  => "hi",
+    :callback => @my_callback
+)
+```
+
+#### Subscribe
+
+```ruby
+pubnub.subscribe(
+    :channel  => :hello_world,
+    :callback => @my_callback
+)
+```
+
+#### History
+Retrieve previously published messages (requires activation via admin.pubnub.com)
+Optional start, end, and reverse option usage can be found in the tests.
+
+```ruby
+pubnub.history(
+    :channel  => channel,
+    :count    => 10, 
+    :callback => @my_callback
+)
+```
+
+#### Presence
+In real-time see people join and leave with occupancy summaries. (requires activation via admin.pubnub.com)
+
+```ruby
+pubnub.presence(
+    :channel  => :hello_world,
+    :callback => @my_callback
+)
+```
+
+#### Here_now 
+See who is "here now" in a channel at this very moment.
+
+```ruby
+pubnub.here_now(
+    :channel  => channel,
+    :callback => @my_callback
+)
+```
+
+#### UUID
+
+Session-UUID is automatic, so you will probably not end up ever using this. But if you need a UUID...
+
+```ruby
+pubnub.uuid
+```
+
+If you wish to manually set a custom UUID, pass in a uuid key in the initializer. See "Init and instantiate a new PubNub instance" for an example.
+
+
+#### Time 
+Get the current PubNub time. This is great to use as a "PubNub Ping"
+
+```ruby
+pubnub.time("callback" => @my_callback)
+```
+
+### Advanced Usage Examples
+
+Advanced usage examples can be found in the examples directory.
+
+#### demo_console
+A demo console app which shows how to use just about every PubNub Ruby call, just about every possible way!
+
+#### translator
+A chat room, with real-time translation! This is using PubNub for the real-time chat, and Bing translation services for babel.
+
+#### pubnub_livestream
+Demo rails chat app. It has also been tested with Heroku.
+
+#### sinatra
+Sinatra demo.
+
+#### sub_and_unsub_1
+Mixing up some async pubs and subs, using blocks and callbacks.
+
+#### serial_publish
+Publish 1000 times with an explicit 0.25s delay between publishes
+

data/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Ruby2::Application.load_tasks

data/VERSION

@@ -0,0 +1 @@
+3.4.0

data/examples/demo_console.rb

@@ -0,0 +1,198 @@
+require 'pubnub'
+
+puts 'Provide origin [demo.pubnub.com]:'
+origin = gets.chomp!
+origin = 'demo.pubnub.com' if origin == ''
+
+p = Pubnub.new(
+    :subscribe_key    => 'demo',
+    :publish_key      => 'demo',
+    :origin           => origin,
+    :error_callback   => lambda { |msg|
+      puts "SOMETHING TERRIBLE HAPPENED HERE: #{msg.inspect}"
+    },
+    :connect_callback => lambda { |msg|
+      puts "CONNECTED: #{msg.inspect}"
+    }
+)
+default_cb = lambda { |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+
+while(true)
+
+  ssl = false
+  while !%w(Y N).include? ssl
+    puts('Should next operation be ssl [Y/N]?')
+    ssl = gets.chomp!
+  end
+
+  sync_or_async = false
+  while !%w(S A).include? sync_or_async
+    puts('Should next operation be [S]ync or [A]sync?')
+    sync_or_async = gets.chomp!
+  end
+
+  block_or_parameter = false
+  while !%w(B P).include? block_or_parameter
+    puts('Do you want pass callback as [B]lock or [P]arameter?')
+    block_or_parameter = gets.chomp!
+  end
+
+  puts('1. subscribe')
+  puts('2. unsubscribe (leave)')
+  puts('3. publish')
+  puts('4. history')
+  puts('5. presence')
+  puts('6. here_now')
+  puts('7. time')
+  puts("\n\n")
+  puts('Enter a selection')
+  choice = gets.chomp!
+
+  case choice
+    when '1' #SUBSCRIBE
+
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.subscribe(:channel => channel, :callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.subscribe(:channel => channel, :http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.subscribe(:channel => channel, :callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.subscribe(:channel => channel, :http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+
+    when '2' #UNSUBSCRIBE
+
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.unsubscribe(:channel => channel, :callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.unsubscribe(:channel => channel, :http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.unsubscribe(:channel => channel, :callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.unsubscribe(:channel => channel, :http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+    when '3' #PUBLISH
+
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      puts('Enter message')
+      message = gets.chomp!
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.publish(:message => message, :channel => channel, :callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.publish(:message => message, :channel => channel, :http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.publish(:message => message, :channel => channel, :callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.publish(:message => message, :channel => channel, :http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+    when '4' #HISTORY
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      puts('Enter count')
+      count = gets.chomp!
+      if (count == '') then count = nil end
+
+      puts('Enter start')
+      history_start = gets.chomp!
+      if (history_start == '') then history_start = nil end
+
+      puts('Enter end')
+      history_end = gets.chomp!
+      if (history_end == '') then history_end = nil end
+
+      puts('Enter reverse (y/n)')
+      reverse = gets.chomp!
+      if (reverse == "" || reverse == "n") then reverse = false else reverse = true end
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.history(:channel => channel,
+                  :count => count,
+                  :start => history_start,
+                  :end => history_end,
+                  :reverse => reverse,
+                  :callback => default_cb,
+                  :http_sync => false,
+                  :ssl => ssl) do |envelope| puts(envelope.inspect) end
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.history(:channel => channel,
+                  :count => count,
+                  :start => history_start,
+                  :end => history_end,
+                  :reverse => reverse,
+                  :http_sync => false,
+                  :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.history(:channel => channel,
+                  :count => count,
+                  :start => history_start,
+                  :end => history_end,
+                  :reverse => reverse,
+                  :callback => default_cb,
+                  :http_sync => true,
+                  :ssl => ssl) do |envelope| puts(envelope.inspect) end
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.history(:channel => channel,
+                  :count => count,
+                  :start => history_start,
+                  :end => history_end,
+                  :reverse => true,
+                  :http_sync => false,
+                  :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+    when '5' #PRESENCE
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.presence(:channel => channel, :callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.presence(:channel => channel, :http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.presence(:channel => channel, :callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.presence(:channel => channel, :http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+    when '6' #HERE_NOW
+      puts('Enter channel')
+      channel = gets.chomp!
+
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.here_now(:channel => channel, :callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.here_now(:channel => channel, :http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.here_now(:channel => channel, :callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.here_now(:channel => channel, :http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+
+    when '7' #TIME
+      if sync_or_async == 'A' && block_or_parameter == 'P' #ASYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.time(:callback => default_cb, :http_sync => false, :ssl => ssl)
+      elsif sync_or_async == 'A' && block_or_parameter == 'B' #ASYNC AND CALLBACK AS PASSED AS BLOCK
+        p.time(:http_sync => false, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      elsif sync_or_async == 'S' && block_or_parameter == 'P' #SYNC AND CALLBACK AS PASSED AS PARAMETER
+        p.time(:callback => default_cb, :http_sync => true, :ssl => ssl)
+      elsif sync_or_async == 'S' && block_or_parameter == 'B' #SYNC AND CALLBACK AS PASSED AS BLOCK
+        p.time(:http_sync => true, :ssl => ssl){ |envelope| puts("\nchannel: #{envelope.channel}: \nmsg: #{envelope.message}") }
+      end
+
+    end
+end