Push0r 0.4.4 → 0.5.0

data/lib/push0r/FlushResult.rb

@@ -1,48 +1,48 @@
 module Push0r
-	# FlushResult models the result of a single {Queue} flushing process.
-	class FlushResult
-		attr_reader :failed_messages
-		attr_reader :new_token_messages
-		
-		def initialize(failed_message, new_token_messages)
-			@failed_messages = failed_message
-			@new_token_messages = new_token_messages
-		end
-		
-		def to_s
-			"FlushResult - Failed: #{@failed_messages.count} NewToken: #{@new_token_messages.count}"
-		end
-	end
-	
-	class FailedMessage
-		attr_reader :error_code
-		attr_reader :receivers
-		attr_reader :message
-		
-		def initialize(error_code, receivers, message)
-			@error_code = error_code
-			@receivers = receivers
-			@message = message
-		end
-		
-		def to_s
-			"FailedMessage: errorCode: #{@error_code} receivers: #{@receivers.inspect}"
-		end
-	end
-	
-	class NewTokenMessage
-		attr_reader :message
-		attr_reader :token
-		attr_reader :new_token
-		
-		def initialize(token, new_token, message)
-			@token = token
-			@new_token = new_token
-			@message = message
-		end
-		
-		def to_s
-			"NewTokenMessage: oldToken: #{@token} newToken: #{@new_token}"
-		end
-	end
+  # FlushResult models the result of a single {Queue} flushing process.
+  class FlushResult
+    attr_reader :failed_messages
+    attr_reader :new_token_messages
+
+    def initialize(failed_message, new_token_messages)
+      @failed_messages = failed_message
+      @new_token_messages = new_token_messages
+    end
+
+    def to_s
+      "FlushResult - Failed: #{@failed_messages.count} NewToken: #{@new_token_messages.count}"
+    end
+  end
+
+  class FailedMessage
+    attr_reader :error_code
+    attr_reader :receivers
+    attr_reader :message
+
+    def initialize(error_code, receivers, message)
+      @error_code = error_code
+      @receivers = receivers
+      @message = message
+    end
+
+    def to_s
+      "FailedMessage: errorCode: #{@error_code} receivers: #{@receivers.inspect}"
+    end
+  end
+
+  class NewTokenMessage
+    attr_reader :message
+    attr_reader :token
+    attr_reader :new_token
+
+    def initialize(token, new_token, message)
+      @token = token
+      @new_token = new_token
+      @message = message
+    end
+
+    def to_s
+      "NewTokenMessage: oldToken: #{@token} newToken: #{@new_token}"
+    end
+  end
 end

data/lib/push0r/GCM/GcmPushMessage.rb

@@ -1,27 +1,27 @@
 module Push0r
-	# GcmPushMessage is a {PushMessage} implementation that encapsulates a single push notification to be sent to a single or multiple users.
-	class GcmPushMessage < PushMessage
-		
-		# Returns a new GcmPushMessage instance that encapsulates a single push notification to be sent to a single or multiple users.
-		# @param receiver_token [Array<String>] the apns push tokens (aka registration ids) to push the notification to
-		# @param identifier [Fixnum] a unique identifier to identify this push message during error handling. If nil, a random identifier is automatically generated.
-		# @param time_to_live [Fixnum] The time to live in seconds for this push messages. If nil, the time to live is set to four weeks.
-		def initialize(receiver_token, identifier = nil, time_to_live = nil)
-			if identifier.nil? ## make sure the message has an identifier
-				identifier = Random.rand(2**32)
-			end
-			
-			# for GCM the receiver_token is an array, so make sure we convert a single string to an array containing that string :-)
-			if receiver_token.is_a?(String)
-				receiver_token = [receiver_token]
-			end
-			
-			super(receiver_token, identifier, time_to_live)
-			
-			if time_to_live && time_to_live.to_i >= 0
-				self.attach({"time_to_live" => time_to_live.to_i})
-			end
-		end
-	end
+  # GcmPushMessage is a {PushMessage} implementation that encapsulates a single push notification to be sent to a single or multiple users.
+  class GcmPushMessage < PushMessage
+
+    # Returns a new GcmPushMessage instance that encapsulates a single push notification to be sent to a single or multiple users.
+    # @param receiver_token [Array<String>] the apns push tokens (aka registration ids) to push the notification to
+    # @param identifier [Fixnum] a unique identifier to identify this push message during error handling. If nil, a random identifier is automatically generated.
+    # @param time_to_live [Fixnum] The time to live in seconds for this push messages. If nil, the time to live is set to four weeks.
+    def initialize(receiver_token, identifier = nil, time_to_live = nil)
+      if identifier.nil? ## make sure the message has an identifier
+        identifier = Random.rand(2**32)
+      end
+
+      # for GCM the receiver_token is an array, so make sure we convert a single string to an array containing that string :-)
+      if receiver_token.is_a?(String)
+        receiver_token = [receiver_token]
+      end
+
+      super(receiver_token, identifier, time_to_live)
+
+      if time_to_live && time_to_live.to_i >= 0
+        self.attach({'time_to_live' => time_to_live.to_i})
+      end
+    end
+  end
 end
 

data/lib/push0r/GCM/GcmService.rb

@@ -2,128 +2,130 @@ require 'net/http'
 
 module Push0r
 
-	# A module that contains constants for Google Cloud Messaging error codes
-	module GcmErrorCodes
-		UNKNOWN_ERROR			= 1
-		INVALID_REGISTRATION	= 2
-		UNAVAILABLE				= 3
-		NOT_REGISTERED			= 4
-		MISMATCH_SENDER_ID		= 5
-		MISSING_REGISTRATION	= 6
-		MESSAGE_TOO_BIG			= 7
-		INVALID_DATA_KEY		= 8
-		INVALID_TTL				= 9
-		INVALID_PACKAGE_NAME	= 10
-		CONNECTION_ERROR		= 11
-		UNABLE_TO_PARSE_JSON	= 400
-		NOT_AUTHENTICATED		= 401
-		INTERNAL_ERROR			= 500
-	end
-
-	# GcmService is a {Service} implementation to push notifications to Android users using the Google Cloud Messaging Service.
-	# @example
-	#   queue = Push0r::Queue.new
-	#
-	#   gcm_service = Push0r::GcmService.new("__gcm_api_token__")
-	#   queue.register_service(gcm_service)
-	class GcmService < Service
-
-		# Returns a new ApnsService instance
-		# @param api_key [String] the GCM API key obtained from the Google Developers Console
-		def initialize(api_key)
-			@api_key = api_key
-			@messages = []
-		end
-
-		# @see Service#can_send?
-		def can_send?(message)
-			return message.is_a?(GcmPushMessage)
-		end
-
-		# @see Service#send
-		def send(message)
-			@messages << message
-		end
-
-		# @see Service#init_push
-		def init_push
-			## not used for gcm
-		end
-
-		# @see Service#end_push
-		def end_push
-			failed_messages = []
-			new_registration_messages = []
-
-			uri = URI.parse("https://android.googleapis.com/gcm/send")
-			http = Net::HTTP.new(uri.host, uri.port)
-			http.use_ssl = true
-
-			@messages.each do |message|
-				begin
-					request = Net::HTTP::Post.new(uri.path, {"Content-Type" => "application/json", "Authorization" => "key=#{@api_key}"})
-					request.body = message.attach({"registration_ids" => message.receiver_token}).payload.to_json
-					response = http.request(request)
-				rescue SocketError
-					## connection error
-					failed_messages << FailedMessage.new(Push0r::GcmErrorCodes::CONNECTION_ERROR, message.receiver_token, message)
-					next
-				end
-
-				if response.code.to_i == 200
-					json = JSON.parse(response.body)
-
-					if json["failure"].to_i > 0 || json["canonical_ids"].to_i > 0
-						error_receivers = {}
-
-						json["results"].each_with_index do |result,i|
-							receiver_token = message.receiver_token[i]
-							error = result["error"]
-							message_id = result["message_id"]
-							registration_id = result["registration_id"]
-
-							if message_id && registration_id
-								new_registration_messages << NewTokenMessage.new(receiver_token, registration_id, message)
-							elsif error
-								error_code = Push0r::GcmErrorCodes::UNKNOWN_ERROR
-								if error == "InvalidRegistration"
-									error_code = Push0r::GcmErrorCodes::INVALID_REGISTRATION
-								elsif error == "Unavailable"
-									error_code = Push0r::GcmErrorCodes::UNAVAILABLE
-								elsif error == "NotRegistered"
-									error_code = Push0r::GcmErrorCodes::NOT_REGISTERED
-								elsif error == "MismatchSenderId"
-									error_code = Push0r::GcmErrorCodes::MISMATCH_SENDER_ID
-								elsif error == "MissingRegistration"
-									error_code = Push0r::GcmErrorCodes::MISSING_REGISTRATION
-								elsif error == "MessageTooBig"
-									error_code = Push0r::GcmErrorCodes::MESSAGE_TOO_BIG
-								elsif error == "InvalidDataKey"
-									error_code = Push0r::GcmErrorCodes::INVALID_DATA_KEY
-								elsif error == "InvalidTtl"
-									error_code = Push0r::GcmErrorCodes::INVALID_TTL
-								elsif error == "InvalidPackageName"
-									error_code = Push0r::GcmErrorCodes::INVALID_PACKAGE_NAME
-								end
-								if error_receivers[error_code].nil? then error_receivers[error_code] = [] end
-								error_receivers[error_code] << receiver_token
-							end
-						end
-
-						## if there are any receivers with errors: add a hash for every distinct error code and the related receivers to the failed_messages array
-						error_receivers.each do |error_code, receivers|
-							failed_messages << FailedMessage.new(error_code, receivers, message)
-						end
-					end
-				elsif response.code.to_i >= 500 && response.code.to_i <= 599
-					failed_messages << FailedMessage.new(Push0r::GcmErrorCodes::INTERNAL_ERROR, message.receiver_token, message)
-				else
-					failed_messages << FailedMessage.new(response.code.to_i, message.receiver_token, message)
-				end
-			end
-
-			@messages = [] ## reset
-			return [failed_messages, new_registration_messages]
-		end
-	end
+  # A module that contains constants for Google Cloud Messaging error codes
+  module GcmErrorCodes
+    UNKNOWN_ERROR = 1
+    INVALID_REGISTRATION = 2
+    UNAVAILABLE = 3
+    NOT_REGISTERED = 4
+    MISMATCH_SENDER_ID = 5
+    MISSING_REGISTRATION = 6
+    MESSAGE_TOO_BIG = 7
+    INVALID_DATA_KEY = 8
+    INVALID_TTL = 9
+    INVALID_PACKAGE_NAME = 10
+    CONNECTION_ERROR = 11
+    UNABLE_TO_PARSE_JSON = 400
+    NOT_AUTHENTICATED = 401
+    INTERNAL_ERROR = 500
+  end
+
+  # GcmService is a {Service} implementation to push notifications to Android users using the Google Cloud Messaging Service.
+  # @example
+  #   queue = Push0r::Queue.new
+  #
+  #   gcm_service = Push0r::GcmService.new("__gcm_api_token__")
+  #   queue.register_service(gcm_service)
+  class GcmService < Service
+
+    # Returns a new ApnsService instance
+    # @param api_key [String] the GCM API key obtained from the Google Developers Console
+    def initialize(api_key)
+      @api_key = api_key
+      @messages = []
+    end
+
+    # @see Service#can_send?
+    def can_send?(message)
+      return message.is_a?(GcmPushMessage)
+    end
+
+    # @see Service#send
+    def send(message)
+      @messages << message
+    end
+
+    # @see Service#init_push
+    def init_push
+      ## not used for gcm
+    end
+
+    # @see Service#end_push
+    def end_push
+      failed_messages = []
+      new_registration_messages = []
+
+      uri = URI.parse('https://android.googleapis.com/gcm/send')
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      @messages.each do |message|
+        begin
+          request = Net::HTTP::Post.new(uri.path, {'Content-Type' => 'application/json', 'Authorization' => "key=#{@api_key}"})
+          request.body = message.attach({'registration_ids' => message.receiver_token}).payload.to_json
+          response = http.request(request)
+        rescue SocketError
+          ## connection error
+          failed_messages << FailedMessage.new(Push0r::GcmErrorCodes::CONNECTION_ERROR, message.receiver_token, message)
+          next
+        end
+
+        if response.code.to_i == 200
+          json = JSON.parse(response.body)
+
+          if json['failure'].to_i > 0 || json['canonical_ids'].to_i > 0
+            error_receivers = {}
+
+            json['results'].each_with_index do |result, i|
+              receiver_token = message.receiver_token[i]
+              error = result['error']
+              message_id = result['message_id']
+              registration_id = result['registration_id']
+
+              if message_id && registration_id
+                new_registration_messages << NewTokenMessage.new(receiver_token, registration_id, message)
+              elsif error
+                error_code = Push0r::GcmErrorCodes::UNKNOWN_ERROR
+                if error == 'InvalidRegistration'
+                  error_code = Push0r::GcmErrorCodes::INVALID_REGISTRATION
+                elsif error == 'Unavailable'
+                  error_code = Push0r::GcmErrorCodes::UNAVAILABLE
+                elsif error == 'NotRegistered'
+                  error_code = Push0r::GcmErrorCodes::NOT_REGISTERED
+                elsif error == 'MismatchSenderId'
+                  error_code = Push0r::GcmErrorCodes::MISMATCH_SENDER_ID
+                elsif error == 'MissingRegistration'
+                  error_code = Push0r::GcmErrorCodes::MISSING_REGISTRATION
+                elsif error == 'MessageTooBig'
+                  error_code = Push0r::GcmErrorCodes::MESSAGE_TOO_BIG
+                elsif error == 'InvalidDataKey'
+                  error_code = Push0r::GcmErrorCodes::INVALID_DATA_KEY
+                elsif error == 'InvalidTtl'
+                  error_code = Push0r::GcmErrorCodes::INVALID_TTL
+                elsif error == 'InvalidPackageName'
+                  error_code = Push0r::GcmErrorCodes::INVALID_PACKAGE_NAME
+                end
+                if error_receivers[error_code].nil? then
+                  error_receivers[error_code] = []
+                end
+                error_receivers[error_code] << receiver_token
+              end
+            end
+
+            ## if there are any receivers with errors: add a hash for every distinct error code and the related receivers to the failed_messages array
+            error_receivers.each do |error_code, receivers|
+              failed_messages << FailedMessage.new(error_code, receivers, message)
+            end
+          end
+        elsif response.code.to_i >= 500 && response.code.to_i <= 599
+          failed_messages << FailedMessage.new(Push0r::GcmErrorCodes::INTERNAL_ERROR, message.receiver_token, message)
+        else
+          failed_messages << FailedMessage.new(response.code.to_i, message.receiver_token, message)
+        end
+      end
+
+      @messages = [] ## reset
+      return [failed_messages, new_registration_messages]
+    end
+  end
 end

data/lib/push0r/PushMessage.rb

@@ -1,33 +1,33 @@
 module Push0r
-	# PushMessage is the base class for all implemented push message types. A PushMessage encapsulates values like the notification's payload, its receiver, etc.
-	# @abstract
-	# @attr_reader [Hash] payload the payload for this push message
-	# @attr_reader [Fixnum] identifier the unique identifier for this push message
-	# @attr_reader [String, Array] receiver_token the receiver's push token
-	# @attr_reader [Fixnum] time_to_live the time to live in seconds for this push message
-	class PushMessage
-		attr_reader :payload, :identifier, :receiver_token, :time_to_live
+  # PushMessage is the base class for all implemented push message types. A PushMessage encapsulates values like the notification's payload, its receiver, etc.
+  # @abstract
+  # @attr_reader [Hash] payload the payload for this push message
+  # @attr_reader [Fixnum] identifier the unique identifier for this push message
+  # @attr_reader [String, Array] receiver_token the receiver's push token
+  # @attr_reader [Fixnum] time_to_live the time to live in seconds for this push message
+  class PushMessage
+    attr_reader :payload, :identifier, :receiver_token, :time_to_live
 
-		# Creates a new PushMessage instance
-		# @param receiver_token [String, Array] the receiver's push token. Some subclasses might also accept an Array of tokens.
-		# @param identifier [Fixnum] a unique identifier to identify this push message during error handling. If nil, a random identifier is automatically generated.
-		# @param time_to_live [Fixnum] The time to live in seconds for this push messages. If nil, the time to live depends on the service used to transmit the message.
-		def initialize(receiver_token, identifier = nil, time_to_live = nil)
-			@receiver_token = receiver_token
-			@identifier = identifier
-			@time_to_live = time_to_live
-			@payload = {}
-		end
+    # Creates a new PushMessage instance
+    # @param receiver_token [String, Array] the receiver's push token. Some subclasses might also accept an Array of tokens.
+    # @param identifier [Fixnum] a unique identifier to identify this push message during error handling. If nil, a random identifier is automatically generated.
+    # @param time_to_live [Fixnum] The time to live in seconds for this push messages. If nil, the time to live depends on the service used to transmit the message.
+    def initialize(receiver_token, identifier = nil, time_to_live = nil)
+      @receiver_token = receiver_token
+      @identifier = identifier
+      @time_to_live = time_to_live
+      @payload = {}
+    end
 
-		# Attaches the given payload to the push message.
-		# @note attaching is done using the merge! method of the Hash class, i.e. be careful not to overwrite previously set Hash keys.
-		# @param payload [Hash] the payload to attach to the message.
-		# @return [self] self
-		def attach(payload = {})
-			@payload.merge!(payload)
-			return self
-		end
-	end
+    # Attaches the given payload to the push message.
+    # @note attaching is done using the merge! method of the Hash class, i.e. be careful not to overwrite previously set Hash keys.
+    # @param payload [Hash] the payload to attach to the message.
+    # @return [self] self
+    def attach(payload = {})
+      @payload.merge!(payload)
+      return self
+    end
+  end
 end
 
 require_relative 'APNS/ApnsPushMessage'