pubnub 3.7.12 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9e8b8244c03f5eb4b0035cb7c37cdda29ad8f353
-  data.tar.gz: 686f762c16665459605d52e7de28636035d72d9e
+  metadata.gz: e0512836ddac41d65e78cddee27b54853241cd86
+  data.tar.gz: 883bcfb86ff7e58bc37d8e67bba7d59139bfeb47
 SHA512:
-  metadata.gz: c237393688ae8bdc7194ebbbe3a3093da68240dbe0292ce28519c99b10e62ce19289708e718b79c8f6bb29ce74059925454e9be7580f78f7e811583ab35ec7bc
-  data.tar.gz: e3b348410c6c0fb034f705dc668d2f52489b1121054f764b0cc40d091e3674b0f5e9e3baaf67d0536f5a8191d87fbf9c656fde1e749c912d68f6e90e2689c3e2
+  metadata.gz: dc68aaaf81ea34defb2840f9ed024e5a55466e81516cb216cbe4ad71ba51b336a1282e539e57f32e65d96852eda33c7690122bbae040e55ee7a3c324facc710b
+  data.tar.gz: 8a23871da7617c78af0a6c1c3158d6a5f4572b09e4a619c482b97df11c6228052a062dd1bce279cf2264b40541386071070d1bc3a5421da578509b640368a7e7

data/.codeclimate.yml

@@ -0,0 +1,15 @@
+engines:
+  rubocop:
+    enabled: true
+  bundler-audit:
+    enblaed: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+exclude_paths:
+  - spec/
+  - coverage/
+  - fixtures/
+  - doc/

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  Exclude:
+    - 'spec/**/*'
+    - 'examples/**/*'
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/MethodLength:
+  Max: 15

data/.travis.yml

@@ -1,7 +1,20 @@
+sudo: false
+
+addons:
+    code_climate:
+        repo_token: 48739096f72763cbed9bd407efd2ed33151ce5663fb3181455128f06d6123ef3
+
+before_install:
+  - gem update bundler
+
 language: ruby
 rvm:
  - 2.3.0
  - 2.2.4
- - 2.1.8
-# uncomment this line if your project needs to run something other than `rake`:
-script: bundle exec rspec
+ - 2.1.7
+ - 2.0.0
+ - jruby-19mode
+
+bundler_args: --without development
+
+script: bundle exec rspec

data/.yardoc/checksums

@@ -0,0 +1,43 @@
+lib/pubnub.rb eb7f01e386b06769829f45ac7d001aad7254119a
+lib/pubnub/pam.rb c6cdf1879fca3d703dad0fa6ecca58f0b8894c13
+lib/pubnub/uuid.rb 33563f03c2aea357c386d2f91a7c3ef26ff3a3cf
+lib/pubnub/error.rb 6b96649885cd1c3de96f821f3590bcc3e1395820
+lib/pubnub/event.rb 36023e22f017bde04e18d20b89691e84003fa3d6
+lib/pubnub/heart.rb a263c7d2913ccd396fc932398dd302800be4b82e
+lib/pubnub/client.rb 988032f198ac50ce67865ae572291d1308d2e6a8
+lib/pubnub/crypto.rb c3caeaba0a44a2729464ee5fb6718249496eac93
+lib/pubnub/version.rb b2fea94fd0d793092b883e95d8982019916f27e9
+lib/pubnub/message.rb 5da91b8b159d440240e0ad763e37d3df8552a5a9
+lib/pubnub/envelope.rb b9da1b7ddcccee44c51df2fb789dca8c434b4c9a
+lib/pubnub/formatter.rb 15d5464dafeab35edcfd5d86df8c1b68e8a2cf24
+lib/pubnub/events/time.rb 1a88e84be926ae51fe52a032142f0116632da651
+lib/pubnub/single_event.rb 85191ba35ba485aa3f108fe7eac36c1041e60123
+lib/pubnub/events/audit.rb dd6ac0736c809a9e63b15448e435e98924ef3619
+lib/pubnub/events/state.rb 677fbcf2866e5ea3dcf506e0a540067ace61aec3
+lib/pubnub/events/leave.rb 8dda492448fc8cb33b101ba21e96ffa554db196e
+lib/pubnub/events/grant.rb a8dc04173a9d57519ae9112d312a7fe578429910
+lib/pubnub/events/revoke.rb ac7d3bcdabf491b1af3e7e95e3b023f2da07fdf5
+lib/pubnub/client/events.rb 0d6bd04d7aae195b5190ae8afd55497c5d9eaec9
+lib/pubnub/configuration.rb 8b199e9ccfe80828b31dfa01da99b5e5b3ea4ecd
+lib/pubnub/origin_manager.rb 5f934b69b4b0d39ab6597decc212effd12b946c1
+lib/pubnub/error_envelope.rb e21af49602929d1a601e07723848d9da1ddb6b9d
+lib/pubnub/events/publish.rb 2e843863546cd0afbd74c57938cfa060798a8ab4
+lib/pubnub/events/history.rb 3ce7d86289afef712728b5ae12114d6761dc053e
+lib/pubnub/subscribe_event.rb 00c0461f72e764d696025bbcb86df8263d10f919
+lib/pubnub/events/presence.rb 506a944a207cbab2757909af01a465419c6a7e3e
+lib/pubnub/events/here_now.rb 01a9ca0835e2cb0b042428c29ab3bf3d57fe873d
+lib/pubnub/events/heartbeat.rb 04c95ae8b447d288b28c37b398791d135e2b6917
+lib/pubnub/events/where_now.rb 02bdab075c465b30062bb37707cc8bdee8592494
+lib/pubnub/events/subscribe.rb 726e626b63b4f13096b40a5af29501f7d6d02df4
+lib/pubnub/validators/client.rb 607d6d6cc41c3144daf66e02abd3585174aef1e4
+lib/pubnub/validators/publish.rb 07d2fdee5a4b74a8930aa795384fe8e203e700c8
+lib/pubnub/request_dispatcher.rb 1782644846a394269710f9dccb83fe40403ddc71
+lib/pubnub/client/connections.rb 0d8b34717ed6aeebc82c54178f5dc447711c0199
+lib/pubnub/validators/subscribe.rb 78e1804e52339b7a6df6c7cd979a24deb9f20418
+lib/pubnub/client/paged_history.rb 20b30727fb42877e89eb0194d1ff77f6d0a2016c
+lib/pubnub/subscribe_event/adding.rb b6a58f851de9bc757f54f82ad0c0e86ea095883b
+lib/pubnub/subscribe_event/removing.rb 23a2489984f69285c6d6fab597178e9beb97bcec
+lib/pubnub/subscribe_event/formatter.rb 161505568d65171ee2592557a648d3150b6ab0c0
+lib/pubnub/subscribe_event/heartbeat.rb 5314e027caa0ac2f37e4789fa8b759997cd77a8b
+lib/pubnub/events/channel_registration.rb 4e9e358712beb9e486302569f62ce880ff4a3584
+lib/pubnub/validators/common_validator.rb d7c547f2d8a060ce326b1d0b6507376bed91a752

data/.yardopts

@@ -0,0 +1,2 @@
+--markup-provider=redcarpet
+--markup=markdown

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+##### 3.8.0
+* Release of celluloid version of pubnub gem. It's complete rewrite but public API doesn't change.

data/Gemfile

@@ -2,13 +2,17 @@ source 'https://rubygems.org'
 
 gemspec
 
-group :development do
-  gem 'rspec', '2.14'
+group :test do
+  gem 'rubocop'
+  gem 'simplecov', require: false
+  gem 'coveralls', require: false
+  gem 'rspec'
   gem 'vcr'
   gem 'rr'
-  gem 'pry'
   gem 'webmock'
-  # gem 'awesome_print'
-  # gem 'ruby-prof'
-  # gem 'memory_profiler'
 end
+
+group :development do
+  gem 'pry'
+  gem 'awesome_print'
+end

data/Gemfile.lock

@@ -1,56 +1,136 @@
 PATH
   remote: .
   specs:
-    pubnub (3.7.12)
-      eventmachine (~> 1.0)
+    pubnub (4.0.0beta14)
+      celluloid (~> 0.16)
+      httpclient (~> 2.6)
       json (~> 1.8)
-      net-http-persistent (~> 2.9)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.4.0)
-    coderay (1.1.1)
-    crack (0.4.3)
+    addressable (2.3.8)
+    ast (2.1.0)
+    astrolabe (1.3.1)
+      parser (~> 2.2)
+    awesome_print (1.6.1)
+    celluloid (0.17.3)
+      celluloid-essentials
+      celluloid-extras
+      celluloid-fsm
+      celluloid-pool
+      celluloid-supervision
+      timers (>= 4.1.1)
+    celluloid-essentials (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-extras (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-fsm (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-pool (0.20.5)
+      timers (>= 4.1.1)
+    celluloid-supervision (0.20.5)
+      timers (>= 4.1.1)
+    coderay (1.1.0)
+    coveralls (0.8.10)
+      json (~> 1.8)
+      rest-client (>= 1.6.8, < 2)
+      simplecov (~> 0.11.0)
+      term-ansicolor (~> 1.3)
+      thor (~> 0.19.1)
+      tins (~> 1.6.0)
+    crack (0.4.2)
       safe_yaml (~> 1.0.0)
     diff-lcs (1.2.5)
-    eventmachine (1.2.0.1)
-    hashdiff (0.3.0)
+    docile (1.1.5)
+    domain_name (0.5.25)
+      unf (>= 0.0.5, < 1.0.0)
+    ffi (1.9.10-java)
+    hitimes (1.2.3)
+    http-cookie (1.0.2)
+      domain_name (~> 0.5)
+    httpclient (2.7.1)
     json (1.8.3)
     method_source (0.8.2)
-    net-http-persistent (2.9.4)
-    pry (0.10.4)
+    mime-types (2.99)
+    netrc (0.11.0)
+    parser (2.2.2.6)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
       slop (~> 3.4)
-    rr (1.2.0)
-    rspec (2.14.0)
-      rspec-core (~> 2.14.0)
-      rspec-expectations (~> 2.14.0)
-      rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.8)
-    rspec-expectations (2.14.5)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.6)
+    pry (0.10.1-java)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+      spoon (~> 0.0)
+    rainbow (2.0.0)
+    rest-client (1.8.0)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 3.0)
+      netrc (~> 0.7)
+    rr (1.1.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
+    rspec-core (3.3.2)
+      rspec-support (~> 3.3.0)
+    rspec-expectations (3.3.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-mocks (3.3.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.3.0)
+    rspec-support (3.3.0)
+    rubocop (0.34.1)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
     safe_yaml (1.0.4)
+    simplecov (0.11.1)
+      docile (~> 1.1.0)
+      json (~> 1.8)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.0)
     slop (3.6.0)
-    vcr (3.0.3)
-    webmock (2.1.0)
+    spoon (0.0.4)
+      ffi
+    term-ansicolor (1.3.2)
+      tins (~> 1.0)
+    thor (0.19.1)
+    timers (4.1.1)
+      hitimes
+    tins (1.6.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.1)
+    vcr (2.9.3)
+    webmock (1.21.0)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
-      hashdiff
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.6)
+  awesome_print
+  bundler (~> 1.7)
+  coveralls
   pry
   pubnub!
   rr
-  rspec (= 2.14)
+  rspec
+  rubocop
+  simplecov
   vcr
   webmock
 
 BUNDLED WITH
-   1.13.6
+   1.10.6

data/LICENSE.txt

@@ -3,6 +3,8 @@ Copyright (c) 2013-2014 PubNub Inc.
 http://www.pubnub.com/
 http://www.pubnub.com/terms
 
+MIT License
+
 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

data/README.md

@@ -1,12 +1,9 @@
-## Celluloid Beta version
-We're happy to announce new ruby Pubnub client version is ready for public beta - you can find in celluloid branch in this repository.
-It uses celluloid instead of eventmachine and it's compatible with Ruby 2.0+, JRuby 1.7+, and Rubinius 2.0.
-Basic usage remains unchanged and it's backward compatible so you don't have to change your code!
-Give it a try and share with us your thoughts!
+[![Coverage Status](https://coveralls.io/repos/github/pubnub/ruby/badge.svg?branch=master)](https://coveralls.io/github/pubnub/ruby?branch=master)
+[![Build Status](https://travis-ci.org/pubnub/ruby.svg?branch=master)](https://travis-ci.org/pubnub/ruby)
 
 # Please direct all Support Questions and Concerns to Support@PubNub.com
 
-## PubNub Gem version 3.7.12
+## PubNub Gem version 3.8.0
 
 ##### YOU MUST HAVE A PUBNUB ACCOUNT TO USE THE API.
 ##### http://www.pubnub.com/account
@@ -16,30 +13,29 @@ www.pubnub.com - PubNub Real-time Push Service in the Cloud.
 
 The PubNub Network is a blazingly fast Global Messaging Service for building real-time web and mobile apps. Thousands of apps and developers rely on PubNub for delivering human-perceptive real-time experiences that scale to millions of users worldwide. PubNub delivers the infrastructure needed to build amazing Mobile, MMO games, social apps, business collaborative solutions, and more.
 
-### Travis
-[![Build Status](https://travis-ci.org/pubnub/ruby.svg?branch=master)](https://travis-ci.org/pubnub/ruby)
+### Upgrading from PubNub 3.6.x / 3.7.x
+
+Main change is that we're no longer using EventMachine. Right now Celluloid is used. Public API remain unchanged.
+If you encounter any issues while upgrading from EventMachine version, please contact us at support@pubnub.com you can also find eventmachine version in "eventmachine" branch of this repo.
 
 ### Upgrading from PubNub 3.5.x
 
-We've made the response format compatible across all operations. This may break existing parsing of whereNow, leave, state, and PAM responses. So if you are monitoring these operation responses, please be sure to modify your code accordingly.
+We've made the response format compatible across all operations. This may break existing parsing of where_now, leave, state, and PAM responses. So if you are monitoring these operation responses, please be sure to modify your code accordingly.
 
 Examples of affected operations can be found [here](3.5_to_3.6_upgrade_notes.md).
 
 ### Upgrading from PubNub 3.3.x and Earlier
 PubNub 3.7.3 is NOT compatible with earlier than 3.4 versions of Pubnub Ruby Client.
 
-### Upgrading from PubNub 3.4 and higher versions
-PubNub 3.7.3 is compatible with 3.4 version.
-
 ## Important Notice about Blocking vs Non-Blocking Calls
 
 #### Asynchronous vs Synchronous Requests
-Every operation is by default asynchronous. Asynchronous operations will not block your main thread and will be fired within a new thread.
+Every operation is by default asynchronous (and it will return Celluloid Future). Asynchronous operations will not block your main thread and will be fired within a new thread.
 
 This can cause issues under certain situations, depending on your implementation. To work around this, you can force an operation to run synchronously (block) via the :http_sync option:
 
 ```ruby
-:http_sync => true
+http_sync: true
 ```
 
 Unless otherwise specified, this option is default implied false (all calls by default will be async).
@@ -62,15 +58,15 @@ require 'pubnub'
 my_logger = Logger.new(STDOUT)
 
 pubnub = Pubnub.new(
-    :subscribe_key    => 'demo',
-    :publish_key      => 'demo',
-    :error_callback   => lambda { |msg|
+    subscribe_key: 'demo',
+    publish_key: 'demo',
+    error_callback: lambda do |msg|
       puts "Error callback says: #{msg.inspect}"
-    },
-    :connect_callback => lambda { |msg|
+    end,
+    connect_callback: lambda do |msg|
       puts "CONNECTED: #{msg.inspect}"
-    },
-    :logger => my_logger
+    end,
+    logger: my_logger
 )
 ```
 
@@ -85,23 +81,23 @@ There are a few different ways to make any given PubNub call. How to do it depen
 
 ##### Asynchronous (non-blocking) calling
 
-If you wish to make asyncronous calls (implemented via EventMachine), you have a few different patterns you can follow:
+If you wish to make asyncronous calls, 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)
+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 => false)
+# You can also explicitly request sync with http_sync: true
+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, &cb)
 
-pubnub.publish(:message => msg, :channel => channel) do |envelope|
+pubnub.publish(message: msg, channel: channel) do |envelope|
     puts envelope.message
     puts envelope.channel
     puts envelope.status_code
@@ -110,9 +106,7 @@ 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:
+If you'd prefer to make your calls blocking, set :http_sync => true. Again, there is a bit of flexibility in how this can be done:
 
 ```ruby
 
@@ -120,14 +114,14 @@ If you'd prefer to make your calls blocking (implemented via HTTParty), set :htt
 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)
+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.inspect}"
+my_response = pubnub.publish(http_sync: true, message: msg, channel: channel)
+puts "my response: #{my_response.inspect}"
 
 # Sync (blocking), with a block
-pubnub.publish(:http_sync => true, :message => msg, :channel => channel) do |envelope|
+pubnub.publish(http_sync: true, message: msg, channel: channel) do |envelope|
     puts envelope.message
     puts envelope.channel
     puts envelope.status_code
@@ -137,11 +131,12 @@ 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.
+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:
 
 ```ruby
+# simplifed
 envelopes.each do |envelope|
     callback.call envelope
 end
@@ -151,11 +146,16 @@ end
 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, if publish, holds published message
-* response_message -> as above, except that if publish holds server response (String "Send")
+* response_message -> as above, except for publish - holds server response (String "Send")
 * channel -> Holds channel for current message
+* wildcard_channel -> Holds wildcard channel for current message
+* group -> Holds group for current message
 * timetoken -> Timetoken of server response
+* payload -> Payload from parsed_response
+* service -> Service from parsed_response
 * status (aliased as 'status_code') -> Server response status code
 * response -> Whole and unmodified server response
+* parsed_response -> Parsed server response
 * first -> true if it's first envelope in single response messages array
 * last -> true if it's last envelope in single response messages array
 * And a bit more, specific to some events, you will find it in description of certain events
@@ -166,7 +166,7 @@ Internally, the block or callback iterates over the response array, similar to:
 
 ```ruby
 envelopes.each do |envelope|
-    callback.call envelope
+    callback.call envelope.message
 end
 ```
 
@@ -178,14 +178,13 @@ In a given callback cycle, the **envelope** will be the current element of the r
 
 ```ruby
 pubnub = Pubnub.new(
-    :subscribe_key    => 'demo',
-    :publish_key      => 'demo',
-    :origin           => origin,
-    :uuid			   => "myUserID",
-    :error_callback   => lambda { |msg|
+    subscribe_key: 'demo',
+    publish_key:   'demo',
+    uuid:          'some-uniq-uuid',
+    error_callback: lambda { |msg|
       puts "SOMETHING TERRIBLE HAPPENED HERE: #{msg.inspect}"
     },
-    :connect_callback => lambda { |msg|
+    connect_callback: lambda { |msg|
       puts "CONNECTED: #{msg.inspect}"
     }
 )
@@ -199,9 +198,9 @@ When publishing, send a string, number, array, or hash. PubNub automatically ser
 @my_callback = lambda { |envelope| puts(envelope.msg) }
 
 pubnub.publish(
-    :channel  => "hello_world",
-    :message  => "hi",
-    :callback => @my_callback
+    channel:  'hello_world',
+    message:  'hi',
+    callback: @my_callback
 )
 ```
 
@@ -209,25 +208,25 @@ pubnub.publish(
 
 ```ruby
 pubnub.subscribe(
-    :channel  => :hello_world,
-    :callback => @my_callback
+    channel:  :hello_world,
+    callback: @my_callback
 )
 ```
 
 #### Leave
 Unsubscribes from given channel (`:channel`) or channel group (`:group`) and 
-fires leave event. You need to be subscribed (only async counts) to channel that 
+fires leave event. You need to be subscribed to channel that 
 You want to leave.
 
 ```ruby
 pubnub.subscribe(
-    :channel  => :hello_world,
-    :callback => @my_callback
+    channel:  :hello_world,
+    callback: @my_callback
 )
 
 pubnub.leave(
-    :channel => :hello_world,
-    :callback => @my_callback
+    channel:  :hello_world,
+    callback: @my_callback
 )
 ```
 
@@ -236,17 +235,17 @@ If you want to force leave channel that you're not subscribed to, you can pass :
 ```ruby
 # Wrong
 pubnub.leave(
-    :channel => :not_subbed_channel,
-    :callback => @my_callback
+    channel:  :not_subbed_channel,
+    callback: @my_callback
 )
 # We'll get error:
 Pubnub::ArgumentError: You cannot leave channel that is not subscribed
 
 # Good
 p.leave(
-    :channel => :force_leave,
-    :force => true,
-    :callback => @my_callback
+    channel:  :not_subbed_channel,
+    force:    true,
+    callback: @my_callback
 )
 ```
 
@@ -256,9 +255,9 @@ Optional start, end, and reverse option usage can be found in the tests.
 
 ```ruby
 pubnub.history(
-    :channel  => channel,
-    :count    => 10,
-    :callback => @my_callback
+    channel:  channel,
+    count:    10,
+    callback: @my_callback
 )
 ```
 
@@ -267,15 +266,15 @@ In real-time see people join and leave with occupancy summaries. (requires activ
 
 ```ruby
 pubnub.presence(
-    :channel  => :hello_world,
-    :callback => @my_callback
+    channel:  :hello_world,
+    callback: @my_callback
 )
 ```
 
 ```ruby
 pubnub.presence(
-    :group    => 'foo:',
-    :callback => @my_callback
+    group:   'foo',
+    callback: @my_callback
 )
 ```
 
@@ -285,15 +284,15 @@ very moment.
 
 ```ruby
 pubnub.here_now(
-    :channel  => channel,
-    :callback => @my_callback
+    channel:  channel,
+    callback: @my_callback
 )
 ```
 
 ```ruby
 pubnub.here_now(
-    :group    => channel_group,
-    :callback => @my_callback
+    group:    channel_group,
+    callback: @my_callback
 )
 ```
 
@@ -302,8 +301,8 @@ See where is client with specific uuid
 
 ```ruby
 p.where_now(
-    :uuid => :my_friend,
-    :callback => @my_callback
+    uuid:     :my_friend,
+    callback: @my_callback
 )
 ```
 
@@ -322,7 +321,7 @@ If you wish to manually set a custom UUID, pass in a uuid key in the initializer
 Get the current PubNub time. This is great to use as a "PubNub Ping"
 
 ```ruby
-pubnub.time("callback" => @my_callback)
+pubnub.time(callback: @my_callback)
 ```
 
 ### Channel Groups
@@ -381,26 +380,25 @@ Envelopes returned by PAM events have additional :service and :payload keys.
 When you issue a PAM operation, you can pass the `presence` key, the 'channel' key, or both. 
 
 ```ruby
-# Will grant :r and :w permissions to demo-pnpres channel
-pubnub.grant(:presence => :demo) do |envelope|
+# Will grant :r, :w and :m permissions to demo-pnpres channel
+pubnub.grant(presence: :demo) do |envelope|
   puts envelope.message
 end
 
-# Will grant :r and :w permissions to demo channel
-pubnub.grant(:channel => :demo) do |envelope|
+# Will grant :r, :w and :m permissions to demo channel
+pubnub.grant(channel: :demo) do |envelope|
   puts envelope.message
 end
 
-# Will grant :r and :w permissions to demo and demo-pnpres channels
-pubnub.grant(:presence => :demo, :channel => :demo) do |envelope|
+# Will grant :r, :w and :m permissions to demo and demo-pnpres channels
+pubnub.grant(presence: :demo, channel: :demo) do |envelope|
   puts envelope.message
 end
 
 # For channel groups, all above work.
-# But channel groups additionally have :manage option.
 
-# Will grant :r, :w and :m permissions to foo:foo
-pubnub.grant(:group => 'foo:foo') do |envelope|
+# Will grant :r, :w and :m permissions to foo
+pubnub.grant(:group => 'foo') do |envelope|
   puts envelope.message
 end
 
@@ -410,11 +408,11 @@ end
 Audits auths for given parameters
 
 ```ruby
-pubnub.audit(:channel => :forbidden_for_jim) do |envelope|
+pubnub.audit(channel: :forbidden_for_jim) do |envelope|
   puts envelope.payload
 end
 
-pubnub.audit(:channel => :forbidden_for_jim, :auth_key => :jim) do |envelope|
+pubnub.audit(channel: :forbidden_for_jim, auth_key: :jim) do |envelope|
   puts envelope.payload
 end
 ```
@@ -423,11 +421,11 @@ end
 Grants auths for given parameters, you can pass :read and :write keys as parameters
 
 ```ruby
-pubnub.grant(:channel => :forbidden_to_write, :read => true, :write => false) do |envelope|
+pubnub.grant(channel: :forbidden_to_write, read: true, write: false) do |envelope|
   puts envelope.payload
 end
 
-pubnub.grant(:channel => :forbidden_to_write, :read => true, :write => true, :auth_key => :admin) do |envelope|
+pubnub.grant(channel: :forbidden_to_write, read: true, write: true, :auth_key => :admin) do |envelope|
   puts envelope.payload
 end
 ```
@@ -436,11 +434,11 @@ end
 Revokes right to read and write. Same as granting r:0 w:0.
 
 ```ruby
-pubnub.revoke(:channel => :forbidden) do |envelope|
+pubnub.revoke(channel: :forbidden) do |envelope|
   puts envelope.payload
 end
 
-pubnub.grant(:channel => :forbidden, :auth_key => :godzilla) do |envelope|
+pubnub.grant(channel: :forbidden, auth_key: :godzilla) do |envelope|
   puts envelope.payload
 end
 ```
@@ -452,22 +450,20 @@ end
 # Example below shows passing more options for client
 # Pubnub.new returns Pubnub::Client instance
 pubnub = Pubnub.new(
-  :error_callback             => custom_error_callback,
-  :connect_callback           => custom_connect_callback,
-  :ssl                        => true,
-  :uuid                       => 'newton',
-  :port                       => 80,
-  :origin                     => custom_origin,
-  :subscribe_timeout          => 310,
-  :non_subscribe_timeout      => 5,
-  :max_retries                => 10, # max retries if response got invalid json
-  :ttl                        => custom_default_ttl_for_pam,
-  :secret_key                 => 0
+  error_callback:        custom_error_callback,
+  connect_callback:      custom_connect_callback,
+  ssl:                   true,
+  uuid:                  'newton',
+  subscribe_timeout:     500,
+  non_subscribe_timeout: 15,
+  ttl:                   custom_default_ttl_for_pam,
+  secret_key:            0
 )
 ```
+You can find more default values in Pubnub::Configuration, you can overwrite them passing it while initializing.
 
 ###### Custom logger
-You can pass your custom logger as :logger key while creating new Pubnub instance. Logger invocations has set progname 'Pubnub'.
+You can pass your custom logger as :logger key while creating new Pubnub instance. Logger invocations has set progname 'Pubnub::Class' eg. 'Pubnub::Client', 'Pubnub::Subscribe'.
 
 ##### Publish
 ```ruby
@@ -476,9 +472,9 @@ You can pass your custom logger as :logger key while creating new Pubnub instanc
 
 # This time publish event will block main thread until callback will finish as we set :http_sync to true
 pubnub.publish(
-  :messsage => message,
-  :channel  => :whatever,
-  :http_sync => true )
+  messsage:  message,
+  channel:   :whatever,
+  http_sync: true )
 ```
 
 ##### Subscribe
@@ -496,14 +492,13 @@ pubnub.publish(
 # any messages every ~300s.
 # First sync subscribe will just update your timetoken, you will not get any messages
 # example:
-pubnub.subscribe(:channel => 'alerts', :http_sync => true) # just update timetoken
-pubnub.subscribe(:channel => 'alerts', :http_sync => true) # Will fire request with current timetoken and can possibly get messages
+pubnub.subscribe(channel: 'alerts', http_sync: true) # just update timetoken
+pubnub.subscribe(channel: 'alerts', http_sync: true) # Will fire request with current timetoken and can possibly get messages
 
-# Async subscribe starts infinity loop in seperate thread (EM.periodic_timer precisely)
-# It will update your timetoken and will fire given callback for every message that it gets
+# Async subscribe will update your timetoken and will fire given callback for every message that it gets
 # example:
 pubnub.subscribe(
-  :channel => 'fight_log'
+  channel: 'fight_log'
 ) do |envelope|
   puts envelope.message['attacker']
   puts envelope.message['defender']
@@ -515,7 +510,7 @@ end
 You can subscribe to channel group same way as You're subscribing to channels.
 
 ```ruby
-pubnub.subscribe(group: 'foo:foo', channel: :ping_3, callback: callback)
+pubnub.subscribe(group: 'foo', channel: :ping_3, callback: callback)
 ```
 
 Response envelopes will hold channel and channel_group values. So, if You want
@@ -528,11 +523,11 @@ subscribe to channel group and plain channel at once.
 History returns :count messages from given channel.
 ```ruby
 pubnub.history(
-  :channel  => :actions,
-  :count    => 10,
-  :start    => 13942156708212448,
-  :end      => 13942156908212448,
-  :callback => replay
+  channel:  :actions,
+  count:    10,
+  start:    13942156708212448,
+  end:      13942156908212448,
+  callback: replay
 )
 ```
 
@@ -541,10 +536,10 @@ If both start and end arguments are provided, reverse is ignored and messages ar
 
 ```ruby
 pubnub.history(
-  :channel  => :actions,
-  :count    => 10,
-  :reverse  => true,
-  :callback => replay
+  channel:  :actions,
+  count:    10,
+  reverse:  true,
+  callback: replay
 )
 ```
 History envelope also contains .history_start and .history_end values
@@ -555,10 +550,10 @@ Paginate through your history. You can pass `:channel`, `:page`, `:limit`, `:cal
 
 ```ruby
 pubnub.paged_history(
-  :channel   => :actions,
-  :limit     => 10,
-  :page      => 3,
-  :http_sync => true
+  channel:   :actions,
+  limit:     10,
+  page:      3,
+  http_sync: true
 )
 ```
 
@@ -566,7 +561,7 @@ pubnub.paged_history(
 Presence works exactly the same way as subscribe, it just adds '-pnpres' to channel name.
 ```ruby
 pubnub.presence(
-  :channel => :mars
+  channel: :mars
 ) do |envelope|
   show_in_roster(envelope.uuid)
 end
@@ -576,7 +571,7 @@ end
 HereNow shows us who is currently subscribing channel and how much clients are online on given channel.
 ```ruby
 pubnub.here_now(
-  :channel => :pamam_moon_iv
+  channel: :pamam_moon_iv
 ) do |envelope|
   puts envelope.parsed_response['uuids']
   puts envelope.parsed_response['occupancy']
@@ -597,19 +592,17 @@ Heartbeat (expressed in seconds) is used to signal to the server that the client
 You normally will never need to touch this value, unless your Ruby client resides on a poor or mobile connection.
 
 ```ruby
-pubnub = Pubnub.new(:subscribe_key => 'demo', :heartbeat => 60)
+pubnub = Pubnub.new(subscribe_key: 'demo', heartbeat: 60)
 ```
 
-Update it via heartbeat= and set_heartbeat()
+Update it via heartbeat=
 ```ruby
 pubnub.heartbeat = 120
-pubnub.set_heartbeat 240
 ```
 
-Read it via heartbeat and get_heartbeat()
+Read it via heartbeat
 ```ruby
 pubnub.heartbeat
-pubnub.get_heartbeat
 ```
 
 #### Pam
@@ -621,27 +614,27 @@ PAM actions could take :presence option, that will grant/revoke/audit permission
 
 ##### Audit
 ```ruby
-pubnub.audit(:channel => 'hidden_system'){ |envelope| puts envelope.msg }
+pubnub.audit(channel: 'hidden_system'){ |envelope| puts envelope.msg }
 
 ```
 
 ##### Grant
 ```ruby
 # Channel level
-pubnub.grant(:channel => 'hidden_system', :read => true, :write => false){ |envelope| puts envelope.msg }
+pubnub.grant(channel: 'hidden_system', read: true, write: false){ |envelope| puts envelope.msg }
 
 # Auth key level
-pubnub.grant(:channel => 'hidden_system', :read => true, :write => false, :auth_key => :lemon){ |envelope| puts envelope.msg }
+pubnub.grant(channel: 'hidden_system', read: true, write: false, auth_key: :lemon){ |envelope| puts envelope.msg }
 ```
 
 ##### Revoke
 Revoke is equal to grant with w false, read false
 ```ruby
 # Channel level
-pubnub.revoke(:channel => 'hidden_system'){ |envelope| puts envelope.msg }
+pubnub.revoke(channel: 'hidden_system'){ |envelope| puts envelope.msg }
 
 # Auth key level
-pubnub.revoke(:channel => 'hidden_system', :auth_key => :lemon){ |envelope| puts envelope.msg }
+pubnub.revoke(channel: 'hidden_system', auth_key: :lemon){ |envelope| puts envelope.msg }
 ```
 
 ### State
@@ -651,49 +644,23 @@ State is stored on the server for subscribed uuid, you can pass state in few way
 ```ruby
 # You can set state in a few ways
 # Using subscribe
-pubnub.subscribe(:channel => 'my_channel', :state => {:my_channel => {:key => :value}}){ |e| puts e.msg }
+pubnub.subscribe(channel: 'my_channel', state: {:my_channel => {:key => :value}}){ |e| puts e.msg }
 # Be aware that state have to be hash of hashes where keys are subscribed channel names
 
 # Using event #set_state
-pubnub.set_state(:state => {:key => :value}, :channel => :my_channel, :http_sync => true)
+pubnub.set_state(state: { key: :value }, channel: :my_channel)
 
 # or with channel groups
-pubnub.set_state(:state => {:key => :value}, :group => 'foo:foo', :http_sync => true)
+pubnub.set_state(state: { :key => :value }, group: 'foo')
 
 ```
 
 #### Getting state
 ```ruby
 # All you need to know is just uuid and channel
-pubnub.state(:uuid => 'uuid_client_that_i_am_searching_for', :http_sync => true)
+pubnub.state(uuid: 'uuid_client_that_i_am_searching_for')
 ```
 
-#### State and channel groups
-State works fine with channel groups too! Just pass the `:group` key when
-setting or do it while subscribing.
-
-### Other
-
-Advanced usage examples can be found also 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 10000 times with an explicit 0.05s delay between publishes
-
 ## Proxy support
 Basic proxy is supported using ENV global, before initializing pubnub just set:
 
@@ -705,45 +672,5 @@ ENV['HTTP_PROXY_PASS'] = 'secret'
 
 after that you can initialize pubnub object as always.
 
-## Comment on Passenger users
-Passenger is orphaning threads and it causes issues with EM which is need to run async pubnub events.
-Below is fix that worked with our tests. You should fire that code from your initializers.
-
-Some other environments could cause similar problems with EM, if you think you're affected, feel free to open issue and we will do our best to help.
-
-```ruby
-module Pubnub
-  # Taken from http://www.hiringthing.com/2011/11/04/eventmachine-with-rails.html
-  # Thanks Joshua!
-  def self.start
-    if defined?(PhusionPassenger)
-      PhusionPassenger.on_event(:starting_worker_process) do |forked|
-        # for passenger, we need to avoid orphaned threads
-
-        $my_logger.debug "=> Starting worker process"
-
-        if forked && EM.reactor_running?
-          $my_logger.debug "=> EventMachine stopped fork"
-          EM.stop
-        end
-        Thread.new {
-          EM.run do
-            $my_logger.debug "=> EventMachine started"
-          end
-        }
-        die_gracefully_on_signal
-      end
-    end
-  end
-
-  def self.die_gracefully_on_signal
-    $my_logger.debug "=> EventMachine stopped die"
-    Signal.trap("INT")  { EM.stop }
-    Signal.trap("TERM") { EM.stop }
-  end
-end
 
-Pubnub.start
-```
-
-# Please direct all Support Questions and Concerns to Support@PubNub.com
+# Please direct all Support Questions and Concerns to Support@PubNub.com