pubnub 0.1.10 → 0.1.11

data/README

@@ -19,7 +19,7 @@ pubnub = Pubnub.new(
     "demo",  ## PUBLISH_KEY
     "demo",  ## SUBSCRIBE_KEY
     "demo",  ## SECRET_KEY
-    "demo",  ## CIPHER_KEY
+    "",      ## CIPHER_KEY (Cipher key is Optional)
     false    ## SSL_ON?
 )
 

data/examples/history_example.rb

@@ -6,11 +6,11 @@
 require 'rubygems'
 require 'pubnub'
 
-## declaring publish_key, subscribe_key, secret_key, cipher_key and ssl flag
+## declaring publish_key, subscribe_key, secret_key, cipher_key and ssl flag (Cipher key is Optional)
 publish_key   = 'demo'
 subscribe_key = 'demo'
 secret_key    = 'demo'
-cipher_key    = 'demo'
+cipher_key    = ''    # (Cipher key is Optional)
 ssl_on        = false
 
 ## Print usage if missing info.
@@ -31,8 +31,11 @@ pubnub = Pubnub.new(publish_key,subscribe_key,secret_key,cipher_key,ssl_on)
 
 ## Request Past Publishes (HISTORY)
 puts('Requesting History with history() Function')
-message = pubnub.history({
+pubnub.history({
   'channel' => 'hello_world',
-  'limit'   => 5
+  'limit'   => 5,
+  'callback' => lambda do |message|
+    puts(message)
+   end
 })
-puts(message)
+#puts(message)

data/examples/publish_example.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 ## -----------------------------------
 ## PubNub Ruby API Publish Example
 ## -----------------------------------
@@ -7,11 +6,11 @@
 require 'rubygems'
 require 'pubnub'
 
-## declaring publish_key, subscribe_key, secret_key, cipher_key, channel, ssl flag, messages
+## declaring publish_key, subscribe_key, secret_key, cipher_key, channel, ssl flag, messages (Cipher key is Optional)
 publish_key   = 'demo'
 subscribe_key = 'demo'
 secret_key    = 'demo'
-cipher_key    = ''
+cipher_key    = ''    # (Cipher key is Optional)
 ssl_on        = false
 channel       = 'hello_world'
 
@@ -40,22 +39,31 @@ pubnub = Pubnub.new(publish_key,subscribe_key,secret_key,cipher_key,ssl_on)
 puts("\nSending message in String format with publish() Function")
 info = pubnub.publish({
   'channel' => channel,
-  'message' => strMessage
+  'message' => strMessage,
+  'callback' => lambda do |message|
+    puts(message)
+  end
 })
 puts(info)
 
 ## Send Message (PUBLISH) -- Array
 puts("\nSending message in Array format with publish() Function")
-info = pubnub.publish({
+pubnub.publish({
   'channel' => channel,
-  'message' => arrMessage
+  'message' => arrMessage,
+  'callback' => lambda do |message|
+    puts(message)
+  end
 })
-puts(info)
+#puts(info)
 
 ## Send Message (PUBLISH) -- Object (Dictionary)
 puts("\nSending message in Dictionary Object format with publish() Function")
-info = pubnub.publish({
+pubnub.publish({
   'channel' => channel,
-  'message' => objMessage
+  'message' => objMessage,
+  'callback' => lambda do |message|
+    puts(message)
+  end
 })
-puts(info)
+#puts(info)

data/examples/subscribe_example.rb

@@ -6,11 +6,11 @@
 require 'rubygems'
 require 'pubnub'
 
-## declaring publish_key, subscribe_key, secret_key, cipher_key, ssl flag
+## declaring publish_key, subscribe_key, secret_key, cipher_key, ssl flag (Cipher key is Optional)
 publish_key   = 'demo'
 subscribe_key = 'demo'
 secret_key    = 'demo'
-cipher_key    = 'demo'
+cipher_key    = ''    # (Cipher key is Optional)
 ssl_on        = false
 channel       = 'hello_world'
 

data/lib/pubnub.rb

@@ -112,16 +112,17 @@ class Pubnub
   #*
   def publish(args)
     ## Fail if bad input.
-    if !(args['channel'] && args['message'])
-      puts('Missing Channel or Message')
+    if !(args['channel'] && args['message'] && args['callback'])
+      puts('Missing Channel or Message or Callback')
       return false
     end
 
     ## Capture User Input
     channel = args['channel']
     message = args['message']
+    callback = args['callback']
 
-    #encryption of message
+    # Encryption of message
     if @cipher_key.length > 0
       pc=PubnubCrypto.new(@cipher_key)
       if message.is_a? Array
@@ -144,15 +145,10 @@ class Pubnub
     end
 
     ## Send Message
-    return _request([
-      'publish',
-      @publish_key,
-      @subscribe_key,
-      signature,
-      channel,
-      '0',
-      message
-    ])
+    request = [ 'publish', @publish_key, @subscribe_key, signature, channel, '0', message ]
+    args['request'] = request
+    args['callback'] = callback
+    _request(args)
   end
 
   #**
@@ -181,51 +177,12 @@ class Pubnub
       return false
     end
 
-    ## Begin Subscribe
-    loop do
-      begin
-        timetoken = args['timetoken'] ? args['timetoken'] : 0
-
-        ## Wait for Message
-        response = _request([
-          'subscribe',
-          @subscribe_key,
-          channel,
-          '0',
-          timetoken.to_s
-        ])
-
-        messages          = response[0]
-        args['timetoken'] = response[1]
-
-        ## If it was a timeout
-        next if !messages.length
-
-        ## Run user Callback and Reconnect if user permits.
-        ## Capture the message and encrypt it
-        if @cipher_key.length > 0
-          pc = PubnubCrypto.new(@cipher_key)
-          messages.each do |message|
-            if message.is_a? Array
-              message=pc.decryptArray(message)
-            else
-              message=pc.decryptObject(message)
-            end
-            if !callback.call(message)
-              return
-            end
-          end
-        else
-          messages.each do |message|
-            if !callback.call(message)
-              return
-            end
-          end
-        end
-      rescue  Timeout::Error
-      rescue
-        sleep(1)
-      end
+    ## EventMachine loop
+    EventMachine.run do
+      timetoken = 0
+      request = [ 'subscribe', @subscribe_key, channel, '0', timetoken.to_s ]
+      args['request'] = request
+      _subscribe(args)
     end
   end
 
@@ -241,30 +198,22 @@ class Pubnub
     ## Capture User Input
     limit   = +args['limit'] ? +args['limit'] : 5
     channel = args['channel']
+    callback = args['callback']
 
     ## Fail if bad input.
     if (!channel)
       puts 'Missing Channel.'
       return false
     end
+    if (!callback)
+      puts 'Missing Callback.'
+      return false
+    end
 
     ## Get History
-    response = _request([ 'history', @subscribe_key, channel, '0', limit.to_s])
-    if @cipher_key.length > 0
-      myarr=Array.new()
-      response.each do |message|
-        pc=PubnubCrypto.new(@cipher_key)
-        if message.is_a? Array
-          message=pc.decryptArray(message)
-        else
-          message=pc.decryptObject(message)
-        end
-        myarr.push(message)
-      end
-      return myarr
-    else
-      return response
-    end
+    request = [ 'history', @subscribe_key, channel, '0', limit.to_s ]
+    args['request'] = request
+    _request(args)
   end
 
   #**
@@ -274,11 +223,10 @@ class Pubnub
   #*
   #* @return int timestamp.
   #*
-  def time()
-    return _request([
-      'time',
-      '0'
-    ])[0]
+  def time(args)
+    request = [ 'time', '0' ]
+    args['request'] = request
+    _request(args)
   end
 
   #**
@@ -295,53 +243,114 @@ class Pubnub
   private
 
   #**
-  #* Request URL
+  #* Request URL for subscribe
   #*
   #* @param array request of url directories.
   #* @return array from JSON response.
   #*
-  def _request(request)
-    ## Construct Request URL
-    url = '/' + request.map{ |bit| bit.split('').map{ |ch|
-        ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.index(ch) ?
-        '%' + ch.unpack('H2')[0].to_s.upcase : URI.encode(ch)
-      }.join('') }.join('/')
+  def _subscribe(args)
+    channel = args['channel']
+    callback = args['callback']
+    request = args['request']
 
+    # Construct Request
+    url = encode_URL(request);
     url = @origin + url
-    http_response = ''
-
-    EventMachine.run do
-      Fiber.new{
-        http = async_fetch(url)
-        http_response = http.response
-        EventMachine.stop
-      }.resume
-    end
-    if(http_response != '')
-      JSON.parse(http_response)
-    end
-  end
 
-  ## Non-blocking IO using EventMachine
-  def async_fetch(url)
-    f = Fiber.current
+    # Execute Request
+    http = EventMachine::HttpRequest.new(url, :connect_timeout => 310, :inactivity_timeout => 0).get
+    http.callback {
+      http_response = JSON.parse(http.response)
+      messages = http_response[0]
+      timetoken = http_response[1]
+
+      next if !messages.length
+
+      ## Run user Callback and Reconnect if user permits.
+      ## Capture the message and encrypt it
+      if @cipher_key.length > 0
+        pc = PubnubCrypto.new(@cipher_key)
+        messages.each do |message|
+          if message.is_a? Array
+            message=pc.decryptArray(message)
+          else
+            message=pc.decryptObject(message)
+          end
+          if !callback.call(message)
+            return
+          end
+        end
+      else
+        messages.each do |message|
+          if !callback.call(message)
+            return
+          end
+        end
+      end
 
-    request_options = {
-      :timeout => 310,  # set request timeout
-      :query => {'V' => '3.1', 'User-Agent' => 'Ruby', 'Accept-Encoding' => 'gzip'},  # set request headers
+      request = [ 'subscribe', @subscribe_key, channel, '0', timetoken.to_s ]
+      args['request'] = request
+      # Recusive call to _subscribe
+      _subscribe(args)
     }
+    http.errback  {
+      http.error
+      # TODO: check for time function and reconnect
+    }
+  end
 
-    http = EventMachine::HttpRequest.new(url).get request_options
-    http.callback { f.resume(http) }
-    http.errback  { f.resume(http) }
-
-    Fiber.yield
-
-    if http.error
-      p [:HTTP_ERROR, http.error]
-    end
-
-    http
+  #**
+  #* Request URL
+  #*
+  #* @param array request of url directories.
+  #* @return array from JSON response.
+  #*
+  def _request(args)
+    request = args['request']
+    callback = args['callback']
+    url = encode_URL(request)
+    url = @origin + url
+    EventMachine.run {
+      # Execute Request
+      http = EventMachine::HttpRequest.new(url, :connect_timeout => 310, :inactivity_timeout => 0).get
+      http.callback {
+        if request[0] == 'history'
+          response = JSON.parse(http.response)
+          if @cipher_key.length > 0
+            myarr=Array.new()
+            response.each do |message|
+              pc=PubnubCrypto.new(@cipher_key)
+              if message.is_a? Array
+                message=pc.decryptArray(message)
+              else
+                message=pc.decryptObject(message)
+              end
+              myarr.push(message)
+            end
+            callback.call(myarr)
+          else
+            callback.call(reponse)
+          end
+        elsif request[0] == 'publish'
+          callback.call(JSON.parse(http.response))
+        else
+          callback.call(JSON.parse(http.response))
+        end
+        EventMachine.stop
+      }
+      http.errback  {
+        puts http.error
+        EventMachine.stop
+      }
+    }
   end
 
+  def encode_URL(request)
+    ## Construct Request URL
+    url = '/' + request.map{ |bit| bit.split('').map{ |ch|
+        ' ~`!@#$%^&*()+=[]\\{}|;\':",./<>?'.index(ch) ?
+        '%' + ch.unpack('H2')[0].to_s.upcase : URI.encode(ch)
+      }.join('') }.join('/')
+    return url
+  end
 end

data/tests/unit_test.rb

@@ -13,11 +13,11 @@
 require 'rubygems'
 require 'pubnub'
 
-## declaring publish_key, subscribe_key, secret_key, cipher_key, message, ssl_on
+## declaring publish_key, subscribe_key, secret_key, cipher_key, message, ssl_on (Cipher key is Optional)
 publish_key   = ARGV[0] || 'demo'
 subscribe_key = ARGV[1] || 'demo'
 secret_key    = ARGV[2] || 'demo'
-cipher_key    = ARGV[3] || 'demo'
+cipher_key    = ARGV[3] || ''    # (Cipher key is Optional)
 ssl_on        = false
 channel       = 'hello_world'
 message       = 'Hi. (顶顅Ȓ)'
@@ -38,33 +38,41 @@ end
 ## ---------------------------------------------------------------------------
 ## UUID generation
 ## ---------------------------------------------------------------------------
-uuid=pubnub.UUID()
+uuid = pubnub.UUID()
 test( uuid.length > 0, 'PubNub Client API UUID: ' + uuid )
 
 ## ---------------------------------------------------------------------------
 ## PubNub Server Time
 ## ---------------------------------------------------------------------------
-timestamp = pubnub.time()
-test( timestamp > 0, 'PubNub Server Time: ' + timestamp.to_s )
+pubnub.time({'callback' => lambda do |message|
+     print 'PubNub Server Time: ', message ## print message
+  end
+})
 
 ## ---------------------------------------------------------------------------
 ## PUBLISH
 ## ---------------------------------------------------------------------------
-pubish_success = pubnub.publish({
+pubnub.publish({
   'channel' => channel,
-   'message' => message
+  'message' => message,
+  'callback' => lambda do |message|
+    puts(message)
+  end
 })
-test( pubish_success[0] == 1, 'Publish First Message Success' )
+#test( pubish_success[0] == 1, 'Publish First Message Success' )
 
 ## ---------------------------------------------------------------------------
 ## HISTORY
 ## ---------------------------------------------------------------------------
-history = pubnub.history({
+pubnub.history({
   'channel' => channel,
-  'limit'   => 5
+  'limit'   => 5,
+  'callback' => lambda do |message|
+    puts(message)
+  end
 })
-puts(history)
-test( history.length >= 1, 'Display History' )
+#puts(history)
+#test( history.length >= 1, 'Display History' )
 
 ## ---------------------------------------------------------------------------
 ## Subscribe

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 10
-  version: 0.1.10
+  - 11
+  version: 0.1.11
 platform: ruby
 authors: 
 - Luke Carpenter / PubNub.com