gravel 0.1.0.alpha1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e0af416f5d3e8c7a7048a6b56a57ab951b3d701f
+  data.tar.gz: 19462716bc99702d0fdc51365ae7df20caac0657
+SHA512:
+  metadata.gz: b61e235460ef57ed8651ba8848609f0b4604adfe23d31067b25393a8ad2b5be8fd1ca099241152995932950178e485d0c07bf3eb25235b9619bac522e592c2b4
+  data.tar.gz: fae035c45f431282047db1a5286c8e9e68de1884faaddd130559051704615ccfadcfb86993d975863c957fa17b5a8ddc97d8c0592aabdd153dadc1a8b1f66e5f

data/.gitignore

@@ -0,0 +1,45 @@
+# Packages #
+############
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+
+# Logs #
+########
+*.log
+
+# Databases #
+#############
+*.sql
+*.sqlite
+
+# OS Files #
+############
+.DS_Store
+.Trashes
+ehthumbs.db
+Icon?
+Thumbs.db
+
+# Vagrant #
+###########
+.vagrant
+
+# Ruby Files #
+##############
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/bundle/
+*.gem

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+--require spec_helper

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,116 @@
+# Gravel
+
+Unified Push Notifications
+
+## Installation
+
+You can install **Gravel** using the following command:
+
+    $ gem install gravel
+
+## Usage
+
+Currently, Gravel only supports APNS (but FCM support is on the list).
+
+### APNS
+
+Gravel uses the new APNS token based authentication so if you don't have an
+APNS token, you'll need to generate one using the Apple Developer portal.
+
+You'll also need the ID for that key, your team's ID and the bundle identifier
+of your application (which should be passed as the 'topic' value - see below).
+
+The APNS class provides the connection to APNS, you can create an instance
+like this:
+
+```ruby
+apns = Gravel::APNS.new(
+  key: Gravel::APNS.key_from_file('/path/to/APNsAuthKey_XXXXXXXXXX.p8'),
+  key_id: 'XXXXXXXXXX',
+  team_id: 'XXXXXXXXXX',
+  topic: 'com.example.app'
+)
+```
+
+There are also a few other parameters you can specify, you can check the
+documentation for the full list but a couple that you might need are:
+
+##### :environment
+
+This can be set to either ```:production``` or ```:development```.
+
+The default value is ```:development```.
+
+##### :concurrency
+
+This tells Gravel how many connections it should open to APNS.
+
+One notification can be sent at a time through a connection, so opening multiple connections will improve the speed at which you can crunch through a notification task.
+
+The default value is ```1```.
+
+---
+
+Next, you'll want to send a notification. You can create a notification like this:
+
+```ruby
+notification = Gravel::APNS::Notification.new
+notification.title = 'Hello, World!'
+notification.body = 'How are you today?'
+notification.sound = :default
+notification.device_token = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
+```
+
+Finally, you can send the notification:
+
+```ruby
+apns.send(notification) do |success, response|
+  puts "Success: #{success}, Response: #{response}"
+end
+```
+
+The requests are all asynchronous, so if you need to wait for them to finish
+you can call the ```wait``` method:
+
+```ruby
+apns.wait
+```
+
+This will block the thread until all requests have completed.
+
+---
+
+If you're sending notifications to lots of devices, there's a helper method
+that allows you to quickly generate the same notification for each device token:
+
+```ruby
+tokens = [
+  'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+  'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
+]
+
+notifications = notification.for_device_tokens(*tokens)
+```
+
+Then you can just loop over each notification and deliver it:
+
+```ruby
+notifications.each do |notification|
+  apns.send(notification) do |success, result|
+    puts "Success: #{success}, Response: #{response}"
+  end
+end
+```
+
+---
+
+You should keep the APNS instance in memory for as long a possible, this
+keeps the connection(s) to APNS open.
+
+See [Communicating with APNs - Best Practices for Managing Connections](https://developer.apple.com/library/content/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/CommunicatingwithAPNs.html#//apple_ref/doc/uid/TP40008194-CH11-SW8) for more info on this.
+
+## Development
+
+After checking out the repo, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'gravel'
+require 'irb'
+
+IRB.start

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/gravel.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gravel/constants'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'gravel'
+  spec.version       = Gravel::VERSION
+  spec.authors       = ['Nialto Services']
+  spec.email         = ['support@nialtoservices.co.uk']
+
+  spec.summary       = %q{Unified Push Notifications}
+  spec.homepage      = 'https://github.com/nialtoservices/gravel'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.metadata['yard.run'] = 'yri'
+
+  spec.add_dependency 'jwt',       '~> 1.5'
+  spec.add_dependency 'net-http2', '~> 0.14.1'
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake',    '~> 10.0'
+  spec.add_development_dependency 'rspec',   '~> 3.0'
+  spec.add_development_dependency 'yard',    '~> 0.9.8'
+end

data/lib/gravel.rb

@@ -0,0 +1,16 @@
+require 'json'
+require 'jwt'
+require 'net-http2'
+require 'openssl'
+require 'securerandom'
+require 'uri'
+
+require 'gravel/apns'
+require 'gravel/apns/auto_token'
+require 'gravel/apns/notification'
+require 'gravel/apns/notification/localization'
+
+# Gravel Unified Push Notifications.
+#
+module Gravel
+end

data/lib/gravel/apns.rb

@@ -0,0 +1,224 @@
+module Gravel
+  # Manages the connection to APNS.
+  # You should keep this instance somewhere instead of recreating it every
+  # time you need to send notifications.
+  #
+  class APNS
+    # The production APNS server URL.
+    #
+    PRODUCTION_URL = 'api.push.apple.com'
+
+    # The development APNS server URL.
+    #
+    DEVELOPMENT_URL = 'api.development.push.apple.com'
+
+    # The default APNS port.
+    #
+    DEFAULT_PORT = 443
+
+    # The alternative APNS port.
+    #
+    ALTERNATIVE_PORT = 2197
+
+    class << self
+      # Attempt to load a key from the specified path.
+      #
+      # @param path [String] The path to the key file.
+      # @return [OpenSSL::PKey::EC] The key.
+      #
+      def key_from_file(path)
+        unless File.file?(path)
+          raise "A key could not be loaded from: #{path}"
+        end
+
+        OpenSSL::PKey::EC.new(File.read(path))
+      end
+    end
+
+    # The topic to pass to APNS.
+    # This is usually the bundle identifier of the application you're sending
+    # push notifications to.
+    #
+    # @return [String] The APNS topic.
+    #
+    attr_reader :topic
+
+    # Create a new APNS instance.
+    #
+    # @param alternative_port [Boolean] (optional) Should we use the default (443) or the alternative (2197) port?
+    # @param concurrency [Integer] (optional) How many connections to APNS should we open?
+    # @param environment [Symbol] (optional) :production or :development
+    # @param key [OpenSSL::PKey::EC] An elliptic curve key (APNS authentication).
+    # @param key_id [String] The key's identifier.
+    # @param team_id [String] The team's identifier.
+    # @param topic [String] The topic to pass to APNS.
+    # @return [Gravel::APNS] An APNS instance.
+    #
+    def initialize(options = {})
+      options = {
+        alternative_port: false,
+        concurrency: 1,
+        environment: :development
+      }.merge(options)
+
+      unless options[:topic].is_a?(String)
+        raise 'The APNS topic is required.'
+      end
+
+      unless [true, false].include?(options[:alternative_port])
+        raise 'The alternative port should be a boolean value.'
+      end
+
+      unless options[:concurrency].is_a?(Integer) && options[:concurrency] > 0
+        raise 'Concurrency should be specified as an Integer greater than zero.'
+      end
+
+      unless [:development, :production].include?(options[:environment])
+        raise 'The environment should be either :production or :development.'
+      end
+
+      host = case options[:environment]
+      when :development
+        DEVELOPMENT_URL
+      when :production
+        PRODUCTION_URL
+      end
+
+      port = options[:alternative_port] ? ALTERNATIVE_PORT : DEFAULT_PORT
+
+      @auto_token = Gravel::APNS::AutoToken.new(options[:team_id], options[:key_id], options[:key])
+      @queue = Queue.new
+      @topic = options[:topic]
+      @url = "https://#{host}:#{port}"
+
+      @workers = options[:concurrency].times.map do
+        client = NetHttp2::Client.new(@url)
+
+        thread = Thread.new(client) do |client|
+          Thread.current.abort_on_exception = true
+
+          loop do
+            Thread.current[:processing] = false
+
+            notification, block = @queue.pop
+
+            Thread.current[:processing] = true
+
+            process_notification(notification, client, &block)
+          end
+        end
+
+        { client: client, thread: thread }
+      end
+    end
+
+    # The identifier for the developer's team.
+    #
+    # @return [String] The team's identifier.
+    #
+    def team_id
+      @auto_token.team_id
+    end
+
+    # The identifier for the APNS key.
+    #
+    # @return [String] The key's identifier.
+    #
+    def key_id
+      @auto_token.key_id
+    end
+
+    # Push a notification onto the send queue.
+    #
+    # @param notification [Gravel::APNS::Notification] The notification to send.
+    # @param block [Proc] The block to call when the request has completed.
+    # @return [Boolean] Whether or not the notification was sent.
+    #
+    def send(notification, &block)
+      if @workers.nil? || @workers.empty?
+        raise "There aren't any workers to process this notification!"
+      end
+
+      @queue.push([notification, block])
+
+      nil
+    end
+
+    # Wait for all threads to finish processing.
+    #
+    def wait
+      threads = @workers.map { |w| w[:thread] }
+
+      until @queue.empty? && threads.all? { |t| t[:processing] == false }
+        # Waiting for the threads to finish ...
+      end
+    end
+
+    # Close all clients and terminate all workers.
+    #
+    def close
+      @queue.clear
+
+      if @workers.is_a?(Array)
+        @workers.each do |payload|
+          payload[:thread].kill
+          payload[:client].close
+        end
+
+        @workers = nil
+      end
+
+      nil
+    end
+
+    private
+    # Process a notification (in a worker).
+    #
+    # @param notification [Gravel::APNS::Notification] The notification to process.
+    # @param client [NetHttp2::Client] The client to use.
+    # @param block [Proc] The block to call on completion.
+    #
+    def process_notification(notification, client, &block)
+      unless notification.is_a?(Gravel::APNS::Notification)
+        raise 'The notification must be an instance of Gravel::APNS::Notification.'
+      end
+
+      unless client.is_a?(NetHttp2::Client)
+        raise 'The client must be an instance of NetHttp2::Client.'
+      end
+
+      unless notification.device_token
+        block.call(false) if block_given?
+        return
+      end
+
+      path = "/3/device/#{notification.device_token}"
+
+      headers = Hash.new
+      headers['authorization'] = @auto_token.bearer_token
+      headers['apns-topic'] = @topic
+
+      if notification.uuid
+        headers['apns-id'] = notification.uuid
+      end
+
+      if notification.collapse_id
+        headers['apns-collapse-id'] = notification.collapse_id
+      end
+
+      if notification.priority
+        headers['apns-priority'] = notification.priority.to_s
+      end
+
+      if notification.expiration && notification.expiration.is_a?(Time)
+        headers['apns-expiration'] = notification.expiration.utc.to_i.to_s
+      end
+
+      body = notification.payload.to_json
+
+      response = client.call(:post, path, headers: headers, body: body)
+
+      block.call(response.ok?, response) if block_given?
+    end
+  end
+end

data/lib/gravel/apns/auto_token.rb

@@ -0,0 +1,107 @@
+module Gravel
+  class APNS
+    # Used internally to generate JWT tokens for APNS.
+    #
+    class AutoToken
+      # The identifier for the developer's team.
+      #
+      # @return [String] The team identifier.
+      #
+      attr_reader :team_id
+
+      # The identifier for the APNS key.
+      #
+      # @return [String] The key identifier.
+      #
+      attr_reader :key_id
+
+      # Create a new AutoToken instance.
+      #
+      # @param team_id [String] The team identifier.
+      # @param key_id [String] The key identifier.
+      # @param key [OpenSSL::PKey::EC] The private key.
+      # @return [Gravel::APNS::AutoToken] An AutoToken instance.
+      #
+      def initialize(team_id, key_id, key)
+        unless team_id.is_a?(String)
+          raise 'The team identifier must be a string.'
+        end
+
+        unless key_id.is_a?(String)
+          raise 'The key identifier must be a string.'
+        end
+
+        unless key_id.length == 10
+          raise 'The key identifier does not appear to be valid.'
+        end
+
+        unless key.is_a?(OpenSSL::PKey::EC)
+          raise 'The key must be an elliptic curve key.'
+        end
+
+        unless key.private?
+          raise 'The key must contain a private key.'
+        end
+
+        @key = key
+        @key_id = key_id
+        @team_id = team_id
+        @token_generation_mutex = Mutex.new
+      end
+
+      # Get the next token to use.
+      #
+      # @return [String] The next token.
+      #
+      def token
+        if require_token_generation?
+          @token_generation_mutex.synchronize do
+            # Double check if we need to regenerate the token.
+            # This could happen if two threads try to concurrently access
+            # the token after it has expired (or before initial generation).
+            if require_token_generation?
+              @last_generated = time
+              @token = generate_token
+            end
+          end
+        end
+
+        @token
+      end
+
+      # Generate a bearer token.
+      #
+      # @return [String] A bearer token.
+      #
+      def bearer_token
+        'Bearer ' + token
+      end
+
+      private
+      # Check if we need to generate a new token.
+      #
+      def require_token_generation?
+        @token == nil || @last_generated == nil || @last_generated < (time - 3540)
+      end
+
+      # Generate a new token.
+      #
+      # @return [String] The token.
+      #
+      def generate_token
+        headers = { 'kid' => @key_id }
+        claims  = { 'iat' => Time.now.utc.to_i, 'iss' => @team_id }
+
+        JWT.encode(claims, @key, 'ES256', headers)
+      end
+
+      # Get the current time in seconds (Epoch).
+      #
+      # @return [Integer] The current time in seconds.
+      #
+      def time
+        Time.now.utc.to_i
+      end
+    end
+  end
+end

data/lib/gravel/apns/notification.rb

@@ -0,0 +1,203 @@
+module Gravel
+  class APNS
+    # A notification for an Apple device (using APNS).
+    #
+    class Notification
+      PRIORITY_IMMEDIATE = 10
+      PRIORITY_ECO = 5
+
+      # The title of the notification.
+      # You can provide a localization on this value.
+      #
+      # @return [String|Gravel::APNS::Notification::Localization] The title.
+      #
+      attr_accessor :title
+
+      # The subtitle of the notification.
+      # You can provide a localization on this value.
+      #
+      # @return [String|Gravel::APNS::Notification::Localization] The subtitle.
+      #
+      attr_accessor :subtitle
+
+      # The body of the notification.
+      # You can provide a localization on this value.
+      #
+      # @return [String|Gravel::APNS::Notification::Localization] The body.
+      #
+      attr_accessor :body
+
+      # The name of the sound file to play when notifying the user.
+      #
+      # @return [String] The sound file name.
+      #
+      attr_accessor :sound
+
+      # The badge number to show on the application icon.
+      #
+      # @return [Integer] The badge number.
+      #
+      attr_accessor :badge
+
+      # A localization key to use when populating the content of the 'View' button.
+      #
+      # @param [String] The action button's localization key.
+      #
+      attr_accessor :action_key
+
+      # A category to identify the notification's type.
+      # This should match one of the identifier values as defined in your
+      # application.
+      #
+      # @param [String] The notification's category.
+      #
+      attr_accessor :category
+
+      # The filename of an image to use when launching the app.
+      #
+      # @param [String] The launch image filename.
+      #
+      attr_accessor :launch_image
+
+      # Set to true to trigger a silent notification in your application.
+      # This is useful to trigger a background app refresh.
+      #
+      # @return [Boolean] Whether or not new content is available.
+      #
+      attr_accessor :content_available
+
+      # The mutable content of the notification.
+      #
+      # @return [Hash] The mutable content.
+      #
+      attr_accessor :mutable_content
+
+      # A unique identifier for this notification.
+      #
+      # @return [String] The unique identifier.
+      #
+      attr_accessor :uuid
+
+      # A group identifier for the notification.
+      # This allows APNS to identify similar messages and collapse them
+      # into a single notification.
+      #
+      # @return [String] The collapse identifier.
+      #
+      attr_accessor :collapse_id
+
+      # The priority of the notification.
+      #
+      # @return [Integer] The priority.
+      #
+      attr_accessor :priority
+
+      # A time when the notification is no longer valid and APNS should stop
+      # attempting to deliver the notification.
+      #
+      # @return [Time] The expiration time.
+      #
+      attr_accessor :expiration
+
+      # A token representing the device you want to send the notification to.
+      #
+      # @return [String] The device token.
+      #
+      attr_accessor :device_token
+
+      # Create a new APNS notification.
+      #
+      # @return [Gravel::APNS::Notification] The notification object.
+      #
+      def initialize
+        self.content_available = false
+        self.uuid = SecureRandom.uuid
+      end
+
+      # Quickly create the same notification for multiple device tokens.
+      #
+      # @param tokens [Splat] An array of device tokens.
+      # @return [Array] An array of notifications.
+      #
+      def for_device_tokens(*tokens)
+        tokens.map do |token|
+          notification = self.dup
+          notification.uuid = SecureRandom.uuid
+          notification.device_token = token
+          notification
+        end
+      end
+
+      # Generate the APNS payload.
+      #
+      # @return [Hash] The APNS payload.
+      #
+      def payload
+        aps = Hash.new
+
+        if self.title.is_a?(String)
+          aps['alert'] ||= Hash.new
+          aps['alert']['title'] = self.title
+        elsif self.title.is_a?(Gravel::APNS::Notification::Localization)
+          aps['alert'] ||= Hash.new
+          aps['alert'].merge!(self.title.payload(:title))
+        end
+
+        if self.subtitle.is_a?(String)
+          aps['alert'] ||= Hash.new
+          aps['alert']['subtitle'] = self.subtitle
+        elsif self.subtitle.is_a?(Gravel::APNS::Notification::Localization)
+          aps['alert'] ||= Hash.new
+          aps['alert'].merge!(self.subtitle.payload(:subtitle))
+        end
+
+        if self.body.is_a?(String)
+          aps['alert'] ||= Hash.new
+          aps['alert']['body'] = self.body
+        elsif self.body.is_a?(Gravel::APNS::Notification::Localization)
+          aps['alert'] ||= Hash.new
+          aps['alert'].merge!(self.body.payload(:body))
+        end
+
+        if self.sound == :default
+          aps['sound'] = 'default'
+        elsif self.sound.is_a?(String)
+          aps['sound'] = self.sound.to_s
+        end
+
+        if self.badge.is_a?(Integer)
+          aps['badge'] = self.badge
+        end
+
+        if self.action_key.is_a?(String)
+          aps['alert']['action-loc-key'] = self.action_key
+        end
+
+        if self.category.is_a?(String)
+          aps['category'] = self.category
+        end
+
+        if self.launch_image.is_a?(String)
+          aps['alert']['launch-image'] = self.launch_image
+        end
+
+        if self.content_available
+          aps['content-available'] = '1'
+        end
+
+        payload = Hash.new
+
+        if self.mutable_content.is_a?(Hash)
+          aps['mutable-content'] = '1'
+          payload.merge!(self.mutable_content)
+        end
+
+        unless aps.empty?
+          payload['aps'] = aps
+        end
+
+        payload
+      end
+    end
+  end
+end

data/lib/gravel/apns/notification/localization.rb

@@ -0,0 +1,88 @@
+module Gravel
+  class APNS
+    class Notification
+      # This class can be used to localize part of a notification.
+      # You can set a notification's title, subtitle or body attribute
+      # to an instance of this class to localize it.
+      #
+      class Localization
+        # The localization key as defined in your app's localization file.
+        #
+        # @return [String] The localization key.
+        #
+        attr_reader :key
+
+        # Additional arguments to pass into the localizable string.
+        #
+        # @return [Array] Additional arguments.
+        #
+        attr_accessor :arguments
+
+        # Create a new localization.
+        #
+        # @param key [String] The localization key.
+        # @param args [Splat] Arguments to pass into the localizable string.
+        # @return [Gravel::APNS::Notification::Localization] The localization object.
+        #
+        def initialize(key, *args)
+          unless key.is_a?(String)
+            raise 'The localization key must be a string.'
+          end
+
+          @key = key.to_s
+          self.arguments = args
+        end
+
+        # Set additional arguments to pass into the localizable string.
+        #
+        # @param arguments [Array] Additional arguments.
+        # @return [Array] The input value.
+        #
+        def arguments=(arguments)
+          unless arguments.nil?
+            unless arguments.is_a?(Array)
+              raise 'The localization arguments must be an array.'
+            end
+
+            unless arguments.all? { |a| a.is_a?(Float) || a.is_a?(Integer) || a.is_a?(String) }
+              raise 'The localization arguments must all be primitives.'
+            end
+          end
+
+          @arguments = arguments
+        end
+
+        # Check if there are any additional arguments.
+        #
+        # @return [Boolean] Whether or not there are any additional arguments.
+        #
+        def arguments?
+          self.arguments && self.arguments.any?
+        end
+
+        # Convert the localization into APNS payload components.
+        #
+        # @param type [Symbol] The localization type (title/subtitle/body).
+        # @return [Hash] The APNS payload components.
+        #
+        def payload(type)
+          components = Hash.new
+
+          case type
+          when :title
+            components['title-loc-key'] = @key
+            components['title-loc-args'] = self.arguments if arguments?
+          when :subtitle
+            components['subtitle-loc-key'] = @key
+            components['subtitle-loc-args'] = self.arguments if arguments?
+          when :body
+            components['loc-key'] = @key
+            components['loc-args'] = self.arguments if arguments?
+          end
+
+          components
+        end
+      end
+    end
+  end
+end

data/lib/gravel/constants.rb

@@ -0,0 +1,3 @@
+module Gravel
+  VERSION = '0.1.0.alpha1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'gravel'

data/spec/unit/gravel/constants_spec.rb

@@ -0,0 +1,5 @@
+describe Gravel do
+  it 'should have a version' do
+    expect { Gravel::VERSION }.not_to raise_exception
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: gravel
+version: !ruby/object:Gem::Version
+  version: 0.1.0.alpha1
+platform: ruby
+authors:
+- Nialto Services
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: net-http2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.8
+description: 
+email:
+- support@nialtoservices.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- gravel.gemspec
+- lib/gravel.rb
+- lib/gravel/apns.rb
+- lib/gravel/apns/auto_token.rb
+- lib/gravel/apns/notification.rb
+- lib/gravel/apns/notification/localization.rb
+- lib/gravel/constants.rb
+- spec/spec_helper.rb
+- spec/unit/gravel/constants_spec.rb
+homepage: https://github.com/nialtoservices/gravel
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Unified Push Notifications
+test_files:
+- spec/spec_helper.rb
+- spec/unit/gravel/constants_spec.rb