expo-push 1.0.2

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.0
+  - 2.5.0
+  - 2.4.0
+  - 2.3.0
+before_install:
+  - gem update --system
+  - gem install bundler

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in exponent-server-sdk.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Jesse Ruder
+
+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
+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.

data/README.md

@@ -0,0 +1,72 @@
+# Exponent Server SDK Ruby
+
+[![Build Status](https://travis-ci.org/expo/expo-server-sdk-ruby.svg?branch=master)](https://travis-ci.org/expo/expo-server-sdk-ruby)
+[![Gem Version](https://badge.fury.io/rb/exponent-server-sdk.svg)](https://badge.fury.io/rb/exponent-server-sdk)
+
+Use to send push notifications to Exponent Experiences from a Ruby server.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'expo-push'
+```
+
+And then execute:
+
+```shell
+$ bundle
+```
+
+Or install it yourself as:
+
+```shell
+$ gem install expo-push
+```
+
+## Usage
+
+### Client
+
+The push client is the preferred way. This hits the latest version of the api.
+
+Optional arguments: `gzip: true`
+
+```ruby
+client = Exponent::Push::Client.new
+# client = Exponent::Push::Client.new(gzip: true)  # for compressed, faster requests
+
+messages = [{
+  to: "ExponentPushToken[xxxxxxxxxxxxxxxxxxxxxx]",
+  sound: "default",
+  body: "Hello world!"
+}, {
+  to: "ExponentPushToken[yyyyyyyyyyyyyyyyyyyyyy]",
+  badge: 1,
+  body: "You've got mail"
+}]
+
+# @Deprecated
+# client.publish(messages)
+
+# MAX 100 messages at a time
+handler = client.send_messages(messages)
+
+# Array of all errors returned from the API
+# puts handler.errors
+
+# you probably want to delay calling this because the service might take a few moments to send
+# I would recommend reading the expo documentation regarding delivery delays
+client.verify_deliveries(handler.receipt_ids)
+
+```
+
+See the getting started example. If you clone this repo, you can also use it to test locally by entering your ExponentPushToken. Otherwise it serves as a good copy pasta example to get you going.
+
+The complete format of the messages can be found [here.](https://docs.expo.io/push-notifications/sending-notifications/#message-request-format)
+
+## Contributing
+
+If you have problems with the code in this repository, please file issues & bug reports. We encourage you
+to submit a pull request with a solution or a failing test to reproduce your issue. Thanks!

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+def load_libs(rake_task)
+  rake_task.libs << 'test'
+  rake_task.libs << 'lib'
+end
+
+Rake::TestTask.new(:test) do |rake_task|
+  load_libs rake_task
+  rake_task.test_files = FileList['test/**/*-test.rb']
+end
+
+Rake::TestTask.new(:getting_started) do |rake_task|
+  load_libs rake_task
+  rake_task.test_files = FileList['examples/getting_started.rb']
+end
+
+task default: :test

data/examples/getting_started.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'expo-push'
+
+class Test
+  def initialize
+    # @client = Exponent::Push::Client.new
+
+    # OR use GZIP to be AWESOME
+    @client = Exponent::Push::Client.new(gzip: true)
+  end
+
+  def too_many_messages
+    (0..101).map { create_message }
+  end
+
+  def create_message
+    {
+      # REPLACE WITH YOUR EXPONENT PUSH TOKEN LIKE:
+      # to: 'ExponentPushToken[g5sIEbOm2yFdzn5VdSSy9n]',
+      to: "ExponentPushToken[#{(0...22).map { ('a'..'z').to_a[rand(26)] }.join}]",
+      sound: 'default',
+      title: 'Hello World',
+      subtitle: 'This is a Push Notification',
+      body: 'Here\'s a little message for you...',
+      data: {
+        user_id: 1,
+        points: 23_434
+      },
+      ttl: 10,
+      expiration: 1_886_207_332,
+      priority: 'default',
+      badge: 0,
+      channelId: 'game'
+    }
+  end
+
+  def test
+    # messages = too_many_messages
+    messages = [create_message]
+
+    response_handler = @client.send_messages(messages)
+    puts response_handler.response.response_body
+  end
+end
+
+Test.new.test

data/expo-push.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'expo-push/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'expo-push'
+  spec.version       = Exponent::VERSION
+  spec.authors       = ['Jesse Ruder', 'Pablo Gomez', 'Mike Taylor']
+  spec.email         = ['jesse@sixfivezero.net', 'pablonahuelgomez@gmail.com', 'mike.taylor@growmaple.com']
+  spec.summary       = %q{Expo Push}
+  spec.description   = %q{A ruby gem to communicate with the Expo Push service.}
+  spec.homepage      = 'https://github.com/growmaple/expo-push'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'typhoeus', '~> 1.4'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+end

data/lib/expo-push/too_many_messages_error.rb

@@ -0,0 +1,2 @@
+class TooManyMessagesError < StandardError
+end

data/lib/expo-push/version.rb

@@ -0,0 +1,3 @@
+module Exponent
+  VERSION = '1.0.2'.freeze
+end

data/lib/expo-push.rb

@@ -0,0 +1,269 @@
+require 'expo-push/version'
+require 'expo-push/too_many_messages_error'
+require 'typhoeus'
+require 'json'
+
+# Basic Usage:
+#
+# Create new client
+# client = Exponent::Push::Client.new(**args)
+#
+# Send UPTO ~~100~~ messages per call,
+# https://docs.expo.io/versions/latest/guides/push-notifications/#message-format
+# response_handler = client.send_messages([list of formatted messages])
+#
+# Check the response to see if any errors were re
+# response_handler.errors?
+#
+# To process each error, iterate over the errors array
+# which contains each Error class instance
+# response_handler.errors
+#
+# There is an array of invalid ExponentPushTokens that were found in the initial /send call
+# response_handler.invalid_push_tokens['ExponentPushToken[1212121212121212]']
+#
+# You can use the handler to get receipt_ids
+# response_handler.receipt_ids
+#
+# You can pass an array of receipt_ids to verify_deliveries method and
+# it will populate a new ResponseHandler with any errors
+# receipt_response = client.verify_deliveries(receipt_ids)
+
+module Exponent
+  def self.is_exponent_push_token?(token)
+    token.start_with?('ExponentPushToken')
+  end
+
+  module Push
+    class Client
+      def initialize(**args)
+        @http_client = args[:http_client] || Typhoeus
+        @error_builder = ErrorBuilder.new
+        # future versions will deprecate this
+        @response_handler = args[:response_handler] || ResponseHandler.new
+        @gzip             = args[:gzip] == true
+      end
+
+      # returns response handler that provides access to errors? and other response inspection methods
+      def send_messages(messages, **args)
+        # https://docs.expo.io/versions/latest/guides/push-notifications/#message-format
+        raise TooManyMessagesError, 'Only 100 message objects at a time allowed.' if messages.length > 100
+
+        response = push_notifications(messages)
+
+        # each call to send_messages will return a new instance of ResponseHandler
+        handler = args[:response_handler] || ResponseHandler.new
+        handler.process_response(response)
+        handler
+      end
+
+      def verify_deliveries(receipt_ids, **args)
+        response = get_receipts(receipt_ids)
+        handler  = args[:response_handler] || ResponseHandler.new
+        handler.process_response(response)
+        handler
+      end
+
+      private
+
+      def push_notifications(messages)
+        @http_client.post(
+          push_url,
+          body: messages.to_json,
+          headers: headers,
+          accept_encoding: @gzip
+        )
+      end
+
+      def push_url
+        'https://exp.host/--/api/v2/push/send'
+      end
+
+      def get_receipts(receipt_ids)
+        @http_client.post(
+          receipts_url,
+          body: { ids: receipt_ids }.to_json,
+          headers: headers,
+          accept_encoding: @gzip
+        )
+      end
+
+      def receipts_url
+        'https://exp.host/--/api/v2/push/getReceipts'
+      end
+
+      def headers
+        headers = {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json'
+        }
+        headers
+      end
+    end
+
+    class ResponseHandler
+      attr_reader :response, :invalid_push_tokens, :receipt_ids, :errors, :raw_errors
+
+      def initialize(error_builder = ErrorBuilder.new)
+        @error_builder             = error_builder
+        @response                  = nil
+        @receipt_ids               = []
+        @invalid_push_tokens       = []
+        @errors                    = []
+        @raw_errors                = []
+      end
+
+      def process_response(response)
+        @response = response
+
+        case response.code.to_s
+        when '504'
+          # NOTE: Raise specific error so app knows to retry the request.
+          raise Exponent::Push::GatewayTimeoutError.new(
+            "Request timed out: #{response.code} #{response.response_body}"
+          )
+        when '502'
+          # NOTE: Raise specific error so app knows to retry the request.
+          raise Exponent::Push::BadGatewayError.new(
+            "Request timed out: #{response.code} #{response.response_body}"
+          )
+        when '400'
+          # NOTE: The app will want to handle expo server error response differently.
+          # Responding with an object that exposes what the expo server errored with.
+          @raw_errors = body.fetch('errors', [])
+        when /(^4|^5)/
+          # NOTE: Catch-all in case we do not get a 400 or 504 error. This will raise unknown
+          # error with information on what the issue was.
+          raise @error_builder.parse_response(response)
+        else
+          sort_results
+        end
+      end
+
+      def errors?
+        @errors.any?
+      end
+
+      private
+
+      def sort_results
+        data = body&.fetch('data', nil) || nil
+
+        # something is definitely wrong
+        return if data.nil?
+
+        # Array indicates a response from the /send endpoint
+        # Hash indicates a response from the /getReceipts endpoint
+        if data.is_a? Array
+          data.each do |push_ticket|
+            receipt_id = push_ticket.fetch('id', nil)
+            if push_ticket.fetch('status', nil) == 'ok'
+              @receipt_ids.push(receipt_id) unless receipt_id.nil?
+            else
+              process_error(push_ticket)
+            end
+          end
+        else
+          process_receipts(data)
+        end
+      end
+
+      def process_receipts(receipts)
+        receipts.each do |receipt_id, receipt|
+          @receipt_ids.push(receipt_id) unless receipt_id.nil?
+          process_error(receipt) unless receipt.fetch('status') == 'ok'
+        end
+      end
+
+      def process_error(push_ticket)
+        message      = push_ticket.fetch('message')
+        invalid      = message.match(/ExponentPushToken\[(...*)\]/)
+        unregistered = message.match(/\"(...*)\"/)
+        error_class = @error_builder.parse_push_ticket(push_ticket)
+
+        @invalid_push_tokens.push(invalid[0]) unless invalid.nil?
+        @invalid_push_tokens.push(unregistered[1]) unless unregistered.nil?
+
+        @errors.push(error_class) unless @errors.include?(error_class)
+      end
+
+      def body
+        # memoization FTW!
+        @body ||= JSON.parse(@response.body)
+      rescue SyntaxError
+        # Sometimes the server returns an empty string.
+        # It must be escaped before we can process it.
+        @body = JSON.parse(@response.body.to_json)
+      rescue StandardError
+        # Prevent nil errors in old version of ruby when using fetch
+        @body = {}
+      end
+    end
+
+    class ErrorBuilder
+      def parse_response(response)
+        with_error_handling(response) do
+          error      = response.fetch('errors')
+          error_name = error.fetch('code')
+          message    = error.fetch('message')
+
+          get_error_class(error_name).new(message)
+        end
+      end
+
+      def parse_push_ticket(push_ticket)
+        with_error_handling(push_ticket) do
+          message = push_ticket.fetch('message')
+          get_error_class(push_ticket.fetch('details').fetch('error')).new(message)
+        end
+      end
+
+      %i[erroneous successful].each do |selector|
+        define_method(:"build_from_#{selector}") do |response|
+          with_error_handling(response) do
+            send "from_#{selector}_response", response
+          end
+        end
+      end
+
+      private
+
+      def with_error_handling(response)
+        yield(response)
+      rescue KeyError, NoMethodError => e
+        unknown_error_format(response, e)
+      end
+
+      def validate_error_name(condition)
+        condition ? yield : Exponent::Push::UnknownError
+      end
+
+      def get_error_class(error_name)
+        validate_error_name(Exponent::Push.error_names.include?(error_name)) do
+          Exponent::Push.const_get("#{error_name}Error")
+        end
+      end
+
+      def unknown_error_format(response, e)
+        error_message = e.message
+        error_response_code = response.response_code
+        error_response_body = response.response_body
+        Exponent::Push::UnknownError.new(
+          "Unknown error format: #{e.message} #{error_response_code} #{error_response_body}"
+        )
+      end
+    end
+
+    Error = Class.new(StandardError)
+
+    def self.error_names
+      %w[DeviceNotRegistered MessageTooBig
+         MessageRateExceeded InvalidCredentials GatewayTimeout
+         BadGateway Unknown]
+    end
+
+    error_names.each do |error_name|
+      const_set "#{error_name}Error", Class.new(Error)
+    end
+  end
+end