maia 2.0.0 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0200a5ab7f43a82c921bc7a3dbadbece312e129b
-  data.tar.gz: 5dd079e1820935f9de05e4ce9ab7e8907058e280
+  metadata.gz: 1f16e5e9cba3546a3653e1fd2e3f87d19fa46784
+  data.tar.gz: aa5f6350dd17689e8dd01c999c3f509680b73e80
 SHA512:
-  metadata.gz: 5ac7fbcdb52b2db18d12021a946c4343bd645576587cdc5095a81c9dc7bc869e99245ad18ea7c6e3ce5c4ebeda6e49f116d8b688205054a2c07834649f1d364c
-  data.tar.gz: f4f06d7362e26f54fbf548ad342424daa98594c992b8aa8e4516ecc1bec642200ee4262627bec2f1417d9d416781e700ef006855b33b505d04116dede020538a
+  metadata.gz: 51ae47908f1ae0e3a1e0b04eb3812023a20db60276b07fa2156583b325191ea7c3231057d0f461c36832dcfd9db6d37c831b10f1a58f5e2cd304431197f4ad71
+  data.tar.gz: 1bbdf160cdeaefebd160966ad92c39ec18d795af55a2e0e4ec291b91e8af91dd199e0d1374cda1bea091f29f150a8f523584221c505274d12cd1ad72f9c82a9c

data/README.md

@@ -0,0 +1,188 @@
+# Maia
+
+This project maintains a `Maia::Device` model and facilitates the delivery of push notifications for iOS and Android through FCM (Firebase Cloud Messaging).
+
+## Installation
+
+```
+gem 'maia'
+bundle
+bin/rake railties:install:migrations
+bin/rake db:migrate
+```
+
+This will copy the `maia_devices` table into your project.
+
+## Setup
+
+Maia relies on [ActiveJob](https://github.com/rails/rails/tree/master/activejob) to enqueue messages. Ensure your application is properly setup with ActiveJob!
+
+Set your FCM key in an initializer, such as `config/initializers/maia.rb`:
+
+```ruby
+Maia::FCM.key = Rails.application.secrets[:fcm][:key]
+```
+
+Alternatively, you can set `ENV['FCM_KEY']`, which Maia will check first.
+
+Include `Maia::Model` into your User model. This will attach the `has_many` relationship you need with `Maia::Device`:
+
+```ruby
+class User
+  include Maia::Model
+  # ...
+end
+```
+
+Create a Devices controller where you need it, which is most likely an API. The controller itself will be generated within your application so that Maia does not make any assumptions about your method of authentication, `respond_with` mimetypes, etc. The only requirement is that `current_user` exists and returns whatever model included `Maia::Model`.
+
+Here's an example of getting setup with an API Devices controller that mobile apps can register with:
+
+`bin/rails g controller api/devices`
+
+After the controller is generated, include `Maia::Controller`:
+
+```ruby
+class API::DevicesController
+  include Maia::Controller
+  # ...
+```
+
+Maia provides the `create` method for you, so devices can now register themselves by POSTing to that controller. If you'd like to add any other actions, feel free.
+
+## Device Registration
+
+Devices can register with your application by submitting a POST to your devices controller with these params:
+
+```
+{ "device": { "token": "<TOKEN>" } }
+```
+
+Where `<TOKEN>` is the token from FCM registration.
+
+## Device Management
+
+When FCM responds with an invalid or unregistered device token, the device record will be destroyed from the database.
+
+When FCM responds with a canonical ID, the device record will be updated so that it's `token` field will be equal to the canonical ID given by FCM.
+
+## Device Expiration
+
+Devices will expire after 14 days. This is to ensure user's who sell or otherwise give away their device will not be tied to that device forever. Each time a POST to Devices is received, the token expiration will be refreshed.
+
+## Defining Messages
+
+Maia provides a `Maia::Message` class that provides an interface for defining push messages and sending them. To define a message, inherit from `Maia::Message` and override whatever you need to:
+
+```ruby
+class ExampleMessage < Maia::Message
+  # Required
+  def title
+    'Something happened!'
+  end
+
+  # Required, the body of the message on Android, alert on iOS
+  def body
+    'Something very important has happened, check it out!'
+  end
+
+  # Determines the icon to load on Android phones
+  def icon
+    'icn_maia'
+  end
+
+  # Will use 'default' by default. Overriding to nil will prevent sound
+  def sound
+    'default'
+  end
+
+  # Badge to use on iOS
+  def badge
+    1
+  end
+
+  # #RRGGBB formatted color to use for the Android notification icon
+  def color
+    '#ffffff'
+  end
+
+  # click_action on Android, category on iOS
+  def on_click
+    'SOMETHING_HAPPENED'
+  end
+
+  # Any additional data to send with the payload
+  def data
+    { foo: :bar }
+  end
+
+  # :normal or :high (:normal by default)
+  def priority
+    :normal
+  end
+
+  # Override to true in order to send the iOS content-available flag
+  def content_available?
+    false
+  end
+
+  # Override to true in order to send a dry run push. This can help debug any device errors without actually sending a push message
+  def dry_run?
+    false
+  end
+end
+```
+
+This message will generate the following FCM payload:
+
+```json
+{
+  "priority": "normal",
+  "dry_run": false,
+  "content_available": false,
+  "data": {
+    "foo": "bar"
+  },
+  "notification": {
+    "title": "Something happened!",
+    "body": "'Something very important has happened, check it out!'",
+    "icon": "icn_maia",
+    "sound": "default",
+    "badge": 1,
+    "color": "#ffffff",
+    "click_action": "SOMETHING_HAPPENED",
+  },
+  "registration_ids": ["<TOKEN1>", "<TOKEN2>"]
+}
+```
+
+`Maia::Message` does not define a constructor so you can construct your message however you want.
+
+## Sending messages
+
+`Maia::Message` provides a `send_to` that pushes the message out to a user (or collection of users). The argument to `send_to` should be a single record or relation of records.
+
+For example:
+
+```ruby
+ExampleMessage.new(...).send_to User.first
+ExampleMessage.new(...).send_to User.where(beta: true)
+```
+
+`send_to` will batch users in groups of 999 tokens (FCM limitation) and send them via ActiveJob.
+
+## Specifying job options (`wait`, `queue`, etc)
+
+The `send_to` method passes it's last argument into [ActiveJob's `set` method](http://apidock.com/rails/ActiveJob/Core/ClassMethods/set), for example:
+
+```ruby
+ExampleMessage.new(...).send_to User.first, wait: 10.seconds, queue: :maia
+```
+
+## Sending a test push
+
+Maia comes with a built-in message to use to test your configuration out:
+
+```ruby
+Maia::Poke.new.send_to user
+```

data/lib/maia.rb

@@ -1,4 +1,6 @@
 require 'rails'
+require 'active_support/core_ext/enumerable'
+
 require 'maia/engine'
 require 'maia/message'
 require 'maia/messenger'
@@ -6,5 +8,15 @@ require 'maia/poke'
 require 'maia/dry_run'
 require 'maia/error'
 
+require 'maia/fcm'
+require 'maia/fcm/connection'
+require 'maia/fcm/notification'
+require 'maia/fcm/response_collection'
+require 'maia/fcm/response'
+require 'maia/fcm/result_collection'
+require 'maia/fcm/result'
+require 'maia/fcm/service'
+
 module Maia
+  BATCH_SIZE = 999
 end

data/lib/maia/engine.rb

@@ -2,7 +2,6 @@ module Maia
   class Engine < ::Rails::Engine
     isolate_namespace Maia
 
-    require 'mercurius'
     require 'responders'
   end
 end

data/lib/maia/fcm.rb

@@ -0,0 +1,7 @@
+module Maia
+  module FCM
+    class << self
+      attr_accessor :key
+    end
+  end
+end

data/lib/maia/fcm/connection.rb

@@ -0,0 +1,34 @@
+module Maia
+  module FCM
+    class Connection
+      URL = 'https://fcm.googleapis.com/fcm/send'.freeze
+
+      def initialize(key)
+        @key = key
+      end
+
+      def write(payload = {})
+        request = Net::HTTP::Post.new uri, headers
+        request.body = payload.to_json
+        http.request request
+      end
+
+      def uri
+        URI(URL)
+      end
+
+      def headers
+        {
+          'Content-Type' => 'application/json',
+          'Authorization' => "key=#{@key}"
+        }
+      end
+
+      def http
+        @_http ||= Net::HTTP.new(uri.host, uri.port).tap do |h|
+          h.use_ssl = true
+        end
+      end
+    end
+  end
+end

data/lib/maia/fcm/notification.rb

@@ -0,0 +1,27 @@
+module Maia
+  module FCM
+    class Notification
+      attr_accessor :attributes
+
+      def initialize(attributes = {})
+        @attributes = attributes
+      end
+
+      def to_h
+        @attributes
+      end
+
+      def ==(other)
+        attributes == other.attributes
+      end
+
+      def method_missing(method_name, *args, &block)
+        @attributes.fetch(method_name) { super }
+      end
+
+      def respond_to_missing?(method_name)
+        @attributes.include? method_name
+      end
+    end
+  end
+end

data/lib/maia/fcm/response.rb

@@ -0,0 +1,55 @@
+module Maia
+  module FCM
+    class Response
+      attr_reader :http_response, :tokens
+
+      def initialize(http_response, tokens = [])
+        @http_response = http_response
+        @tokens = tokens
+      end
+
+      def status
+        http_response.code
+      end
+
+      def success?
+        (200..399).cover? status
+      end
+
+      def fail?
+        !success?
+      end
+
+      def results
+        @_results ||= begin
+          results = to_h.fetch 'results', []
+          results.map!.with_index do |attributes, i|
+            Result.new attributes, tokens[i]
+          end
+          ResultCollection.new(results)
+        end
+      end
+
+      def error
+        case status
+        when 400
+          'Invalid JSON was sent to FCM.'
+        when 401
+          'Authentication error with FCM. Check the server whitelist and the validity of your project key.'
+        when 500..599
+          'FCM Internal server error.'
+        end
+      end
+
+      def retry_after
+        http_response.headers['Retry-After']
+      end
+
+      def to_h
+        JSON.parse http_response.body
+      rescue JSON::ParserError
+        {}
+      end
+    end
+  end
+end

data/lib/maia/fcm/response_collection.rb

@@ -0,0 +1,34 @@
+module Maia
+  module FCM
+    class ResponseCollection
+      include Enumerable
+
+      def initialize(notification, responses = [])
+        @notification = notification
+        @responses = responses
+      end
+
+      def results
+        collection = ResultCollection.new
+        @responses.each do |response|
+          response.results.each do |result|
+            collection << result
+          end
+        end
+        collection
+      end
+
+      def [](index)
+        @responses[index]
+      end
+
+      def <<(response)
+        @responses.concat Array(response).flatten
+      end
+
+      def each(&block)
+        @responses.each(&block)
+      end
+    end
+  end
+end

data/lib/maia/fcm/result.rb

@@ -0,0 +1,31 @@
+module Maia
+  module FCM
+    class Result
+      include ActiveModel::Model
+
+      attr_accessor :message_id, :registration_id, :error
+      attr_reader :token
+
+      def initialize(attributes, token)
+        super attributes
+        @token = token
+      end
+
+      def success?
+        message_id.present?
+      end
+
+      def fail?
+        !success?
+      end
+
+      def canonical_id
+        registration_id
+      end
+
+      def has_canonical_id?
+        canonical_id.present?
+      end
+    end
+  end
+end

data/lib/maia/fcm/result_collection.rb

@@ -0,0 +1,35 @@
+module Maia
+  module FCM
+    class ResultCollection
+      include Enumerable
+
+      def initialize(results = [])
+        @results = results
+      end
+
+      def succeeded
+        @results.select(&:success?)
+      end
+
+      def failed
+        @results.select(&:fail?)
+      end
+
+      def with_canonical_ids
+        @results.select(&:has_canonical_id?)
+      end
+
+      def [](index)
+        @results[index]
+      end
+
+      def <<(result)
+        @results << result
+      end
+
+      def each(&block)
+        @results.each(&block)
+      end
+    end
+  end
+end

data/lib/maia/fcm/service.rb

@@ -0,0 +1,48 @@
+module Maia
+  module FCM
+    class Service
+      def initialize
+        @connection ||= FCM::Connection.new key
+      end
+
+      def key
+        ENV.fetch 'FCM_KEY', Maia::FCM.key
+      end
+
+      def deliver(notification, *tokens, topic: nil)
+        responses = ResponseCollection.new notification
+        responses << deliver_all(notification, tokens)
+        responses << deliver_all(notification, topic) if topic
+        responses
+      end
+
+      private
+        def deliver_all(notification, recipients)
+          batch(recipients).map do |batch|
+            if batch.many?
+              multicast notification, batch
+            elsif batch.one?
+              unicast notification, batch.first
+            end
+          end
+        end
+
+        def unicast(notification, recipient)
+          deliver! notification, recipient, to: recipient
+        end
+
+        def multicast(notification, recipients)
+          deliver! notification, recipients, registration_ids: recipients
+        end
+
+        def deliver!(notification, recipients, params = {})
+          payload = notification.to_h.merge params
+          Response.new @connection.write(payload), Array(recipients)
+        end
+
+        def batch(recipients, batch_size: Maia::BATCH_SIZE)
+          Array(recipients).flatten.compact.each_slice batch_size
+        end
+    end
+  end
+end

data/lib/maia/message.rb

@@ -1,19 +1,17 @@
 module Maia
   class Message
-    MAX_TOKENS_AT_ONCE = 999
-
     def send_to(pushable, job_options = {})
       devices = Device.owned_by pushable
-      worker = Maia::Messenger.set job_options
+      worker  = Messenger.set job_options
 
-      enqueue worker, devices.android, to_h(notify: notify?(:android))
-      enqueue worker, devices.ios, to_h(notify: notify?(:ios))
-      enqueue worker, devices.unknown, to_h(notify: notify?(:unknown))
+      enqueue worker, devices.android
+      enqueue worker, devices.ios
+      enqueue worker, devices.unknown
     end
 
-    def enqueue(worker, devices, payload)
-      devices.pluck(:token).each_slice MAX_TOKENS_AT_ONCE do |tokens|
-        worker.perform_later tokens, payload.deep_stringify_keys
+    def enqueue(worker, devices)
+      devices.in_batches(of: Maia::BATCH_SIZE) do |devices|
+        worker.perform_later devices.pluck(:token), to_h.deep_stringify_keys
       end
     end
 
@@ -23,11 +21,14 @@ module Maia
     def body
     end
 
+    def on_click
+    end
+
     def icon
     end
 
     def sound
-      'default'
+      :default
     end
 
     def badge
@@ -36,17 +37,6 @@ module Maia
     def color
     end
 
-    def action
-    end
-
-    def title_i18n
-      []
-    end
-
-    def body_i18n
-      []
-    end
-
     def data
     end
 
@@ -58,12 +48,12 @@ module Maia
       false
     end
 
-    def dry_run?
+    def content_mutable?
       false
     end
 
-    def notify?(_platform = :unknown)
-      true
+    def dry_run?
+      false
     end
 
     def notification
@@ -71,51 +61,22 @@ module Maia
         title: title,
         body: body,
         icon: icon,
-        sound: sound,
+        sound: sound.to_s,
         badge: badge,
         color: color,
-        click_action: action
-      }.merge(i18n).compact
+        click_action: on_click
+      }.compact
     end
 
-    def to_h(notify: true)
-      payload = {
+    def to_h
+      {
         priority: priority.to_s,
         dry_run: dry_run?,
         content_available: content_available?,
-        data: data
-      }
-
-      payload[:notification] = notification if notify
-      payload.compact
+        mutable_content: content_mutable?,
+        data: data,
+        notification: notification
+      }.compact
     end
-
-    private
-      def i18n
-        {}.tap do |hash|
-          hash[:body_loc_key] = body_i18n.first
-          hash[:body_loc_args] = body_i18n_args
-          hash[:title_loc_key] = title_i18n_key
-          hash[:title_loc_args] = title_i18n_args
-        end.compact
-      end
-
-      def body_i18n_key
-        body_i18n.first
-      end
-
-      def body_i18n_args
-        args = body_i18n.drop 1
-        args if args.any?
-      end
-
-      def title_i18n_key
-        title_i18n.first
-      end
-
-      def title_i18n_args
-        args = title_i18n.drop 1
-        args if args.any?
-      end
   end
 end

data/lib/maia/messenger.rb

@@ -4,46 +4,48 @@ module Maia
       logger.info "Pushing to #{tokens.size} token(s)..."
       logger.info "Payload: #{payload}"
 
-      notification = GCM::Notification.new(payload)
-      responses = gcm.deliver(notification, tokens)
+      notification = FCM::Notification.new payload
+      responses    = fcm.deliver notification, tokens
 
       responses.each do |response|
-        if error = response.error
-          raise Maia::Error, error
-        else
-          handle_failed_tokens response.results.failed
-          update_devices_to_use_canonical_ids response.results.with_canonical_ids
-        end
+        raise Maia::Error, response.error if response.error
+        handle_errors response.results.failed
+        update_devices_to_use_canonical_ids response.results.with_canonical_ids
       end
     end
 
     private
-      def gcm
-        @_service ||= GCM::Service.new connection: connection
-      end
-
-      def connection
-        nil # use the default
+      def fcm
+        @_service ||= FCM::Service.new
       end
 
-      def handle_failed_tokens(results)
+      def handle_errors(results)
         results.each do |result|
-          device = Maia::Device.find_by(token: result.token)
-          if device
-            if device_unrecoverable?(result.error)
-              log_error "Destroying device #{device.id}", result, device
-              device.destroy
-            else
-              log_error "Push to device #{device.id} failed", result, device
-            end
+          device = Maia::Device.find_by token: result.token
+          next unless device.present?
+
+          if device_unrecoverable? result.error
+            log_error "Destroying device #{device.id}", result, device
+            device.destroy
+          else
+            log_error "Push to device #{device.id} failed", result, device
           end
         end
       end
 
+      def device_unrecoverable?(error)
+        error =~ /InvalidRegistration|NotRegistered|MismatchSenderId/
+      end
+
+      def log_error(message, result, device)
+        logger.info "#{message} (error: #{result.error}, token: #{device.token})"
+      end
+
       def update_devices_to_use_canonical_ids(results)
         results.each do |result|
           device = Maia::Device.find_by token: result.token
           next if device.nil?
+
           if user_already_has_token_registered?(device.pushable, result.canonical_id)
             device.destroy
           else
@@ -52,16 +54,8 @@ module Maia
         end
       end
 
-      def device_unrecoverable?(error)
-        error =~ /InvalidRegistration|NotRegistered|MismatchSenderId/
-      end
-
       def user_already_has_token_registered?(user, token)
         user.devices.exists? token: token
       end
-
-      def log_error(message, result, device)
-        logger.info "#{message} (error: #{result.error}, token: #{device.token})"
-      end
   end
 end

data/lib/maia/poke.rb

@@ -1,11 +1,11 @@
 module Maia
   class Poke < Message
     def title
-      'Poke'
+      'Poke!'
     end
 
     def body
-      'Poke'
+      'This is a test push, please ignore me.'
     end
   end
 end

data/lib/maia/version.rb

@@ -1,3 +1,3 @@
 module Maia
-  VERSION = '2.0.0'.freeze
+  VERSION = '4.0.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: maia
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Logan Serman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-08 00:00:00.000000000 Z
+date: 2017-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,58 +16,70 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.0.2
+        version: '5'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
 - !ruby/object:Gem::Dependency
   name: responders
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: mercurius
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.2.1
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +93,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-rails
+  name: capybara
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +107,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: capybara
+  name: capybara-webkit
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +121,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: capybara-webkit
+  name: launchy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -123,7 +135,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: launchy
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -137,7 +149,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: webmock-rspec-helper
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -150,7 +162,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: Manage device tokens and push messaging with Rails and Mercurius.
+description: Manage device tokens and push messaging with Rails and FCM.
 email:
 - loganserman@gmail.com
 executables: []
@@ -158,6 +170,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
+- README.md
 - Rakefile
 - app/controllers/concerns/maia/controller.rb
 - app/models/concerns/maia/model.rb
@@ -171,6 +184,14 @@ files:
 - lib/maia/dry_run.rb
 - lib/maia/engine.rb
 - lib/maia/error.rb
+- lib/maia/fcm.rb
+- lib/maia/fcm/connection.rb
+- lib/maia/fcm/notification.rb
+- lib/maia/fcm/response.rb
+- lib/maia/fcm/response_collection.rb
+- lib/maia/fcm/result.rb
+- lib/maia/fcm/result_collection.rb
+- lib/maia/fcm/service.rb
 - lib/maia/message.rb
 - lib/maia/messenger.rb
 - lib/maia/poke.rb
@@ -195,8 +216,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: Manage device tokens and push messaging with Rails and Mercurius.
+summary: Manage device tokens and push messaging with Rails and FCM.
 test_files: []