fcm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 566f06986ceeeb5c1feb04bd49988c7d1a1698ed
+  data.tar.gz: 60daa74b40a83b9536a54db75b04d8b02b1526f0
+SHA512:
+  metadata.gz: 6c58de63c80e324d3425278ebebe22c617be80d2514a8d0a6944bda90a3c6bd06d2de3bb4afd137e1528fc363f97eb8e8671f3e0f7cf73a71381a0a75f60e107
+  data.tar.gz: aaf37a387be61be0dbb3a094404204dfcb433549c68757dd4863ea97dbf80be236dcbd7706e298ac5148643af217aa76ad73a7e6eef14a06e009adbb650b2aba

data/.gitignore

@@ -0,0 +1,50 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg
+
+# Have editor/IDE/OS specific files you need to ignore? Consider using a global gitignore:
+#
+# * Create a file at ~/.gitignore
+# * Include files you want ignored
+# * Run: git config --global core.excludesfile ~/.gitignore
+#
+# After doing this, these files will be ignored in all your git projects,
+# saving you from having to 'pollute' every project you touch with them
+#
+# Not sure what to needs to be ignored for particular editors/OSes? Here's some ideas to get you started. (Remember, remove the leading # of the line)
+#
+# For MacOS:
+#
+.DS_Store
+#
+# For TextMate
+#*.tmproj
+#tmtags
+#
+# For emacs:
+#*~
+#\#*
+#.\#*
+#
+# For vim:
+#*.swp
+
+bin
+cache
+gems
+specifications
+Gemfile.lock
+.rvmrc
+spec/reports

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1.9
+  - 2.2.5
+  - 2.3.1

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+gemspec
+
+gem 'rake'
+gem 'rspec'
+gem 'webmock'
+gem 'ci_reporter_rspec'

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Kashif Rasul and Shoaib Burq
+
+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,128 @@
+# Firebase Cloud Messaging (FCM) for Android and iOS
+[![Gem Version](https://badge.fury.io/rb/fcm.svg)](http://badge.fury.io/rb/fcm) [![Build Status](https://secure.travis-ci.org/spacialdb/fcm.png?branch=master)](http://travis-ci.org/spacialdb/fcm)
+
+The FCM gem lets your ruby backend send notifications to Android and iOS devices via [
+Firebase Cloud Messaging](https://firebase.google.com/docs/cloud-messaging/).
+
+##Installation
+
+    $ gem install fcm
+
+or in your `Gemfile` just include it:
+
+```ruby
+gem 'fcm'
+```
+
+##Requirements
+
+For Android you will need a device running 2.3 (or newer) that also have the Google Play Store app installed, or an emulator running Android 2.3 with Google APIs. iOS devices are also supported.
+
+One of the following, tested Ruby versions:
+
+* `2.0.0`
+* `2.1.9`
+* `2.2.5`
+* `2.3.1`
+
+##Usage
+
+For your server to send a message to one or more devices, you must first initialise a new `FCM` class with your Firebase server Api key, and then call the `send` method on this and give it 1 or more (up to 1000) registration tokens as an array of strings. You can also optionally send further [HTTP message parameters](https://firebase.google.com/docs/cloud-messaging/http-server-ref) like `data` or `time_to_live` etc. as a hash via the second optional argument to `send`.
+
+Example sending notifications:
+
+```ruby
+require 'fcm'
+
+fcm = FCM.new("my_api_key")
+# you can set option parameters in here
+#  - all options are pass to HTTParty method arguments
+#  - ref: https://github.com/jnunemaker/httparty/blob/master/lib/httparty.rb#L29-L60
+#  fcm = FCM.new("my_api_key", timeout: 3)
+
+registration_ids= ["12", "13"] # an array of one or more client registration tokens
+options = {data: {score: "123"}, collapse_key: "updated_score"}
+response = fcm.send(registration_ids, options)
+```
+
+Currently `response` is just a hash containing the response `body`, `headers` and `status`. Check [here](https://firebase.google.com/docs/cloud-messaging/server#response) to see how to interpret the responses.
+
+## Device Group Messaging
+
+With [device group messaging](https://firebase.google.com/docs/cloud-messaging/notifications), you can send a single message to multiple instance of an app running on devices belonging to a group. Typically, "group" refers a set of different devices that belong to a single user. However, a group could also represent a set of devices where the app instance functions in a highly correlated manner. To use this feature, you will first need an initialised `FCM` class.
+
+### Generate a Notification Key for device group
+Then you will need a notification key which you can create for a particular `key_name` which needs to be uniquely named per app in case you have multiple apps for the same `project_id`.  This ensures that notifications only go to the intended target app. The `create` method will do this and return the token `notification_key`, that represents the device group, in the response:
+
+```ruby
+response = fcm.create(key_name: "appUser-Chris",
+                project_id: "my_project_id",
+                registration_ids:["4", "8", "15", "16", "23", "42"])
+```
+
+### Send to Notification Key
+Now you can send a message to a particular `notification_key` via the `send_with_notification_key` method. This allows the server to send a single data to multiple app instances  (typically on multiple devices) owned by a single user (instead of sending to some registration tokens). Note: the maximum number of members allowed for a `notification_key` is 20.
+
+```ruby
+response = fcm.send_with_notification_key("notification_key", {
+            data: {score: "3x1"},
+            collapse_key: "updated_score"})
+```
+
+### Add/Remove Registration Tokens
+
+You can also add/remove registration Tokens to/from a particular `notification_key` of some `project_id`. For example:
+
+```ruby
+response = fcm.add(key_name: "appUser-Chris",
+                project_id: "my_project_id",
+                notification_key:"appUser-Chris-key",
+                registration_ids:["7", "3"])
+
+response = fcm.remove(key_name: "appUser-Chris",
+                project_id: "my_project_id",
+                notification_key:"appUser-Chris-key",
+                registration_ids:["8", "15"])
+```
+
+## Send Messages to Topics
+
+FCM [topic messaging](https://firebase.google.com/docs/cloud-messaging/topic-messaging) allows your app server to send a message to multiple devices that have opted in to a particular topic. Based on the publish/subscribe model, topic messaging supports unlimited subscriptions per app. Sending to a topic is very similar to sending to an individual device or to a user group, in the sense that you can use the `fcm.send_with_notification_key()` method where the `noticiation_key` matches the regular expression `"/topics/[a-zA-Z0-9-_.~%]+"`:
+
+```ruby
+response = fcm.send_with_notification_key("/topics/yourTopic", {
+            data: {message: "This is a FCM Topic Message!"})
+```
+
+Or you can use the helper:
+
+```ruby
+response = fcm.send_to_topic("yourTopic", {
+            data: {message: "This is a FCM Topic Message!"})
+```
+
+## Mobile Clients
+
+You can find a guide to implement an Android Client app to receive notifications here: [Set up a FCM Client App on Android](https://firebase.google.com/docs/cloud-messaging/android/client).
+
+The guide to set up an iOS app to get notifications is here: [Setting up a FCM Client App on iOS](https://firebase.google.com/docs/cloud-messaging/ios/client).
+
+## ChangeLog
+
+### 0.0.1
+
+* Initial version.
+
+
+##MIT License
+
+* Copyright (c) 2016 Kashif Rasul and Shoaib Burq. See LICENSE.txt for details.
+
+##Many thanks to all the contributors
+
+* [Contributors](https://github.com/spacialdb/fcm/contributors)
+
+## Donations
+We accept tips through [Gratipay](https://gratipay.com/spacialdb/).
+
+[![Gratipay](https://img.shields.io/gratipay/spacialdb.svg)](https://www.gittip.com/spacialdb/)

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+require "rake/tasklib"
+require 'ci/reporter/rake/rspec'
+
+RSpec::Core::RakeTask.new(:spec => ["ci:setup:rspec"]) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--format documentation']
+end
+
+task :default => :spec

data/fcm.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "fcm"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kashif Rasul", "Shoaib Burq"]
+  s.email       = ["kashif@spacialdb.com", "shoaib@spacialdb.com"]
+  s.homepage    = "https://github.com/spacialdb/fcm"
+  s.summary     = %q{Reliably deliver messages and notifications via FCM}
+  s.description = %q{fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform messaging solution that lets you reliably deliver messages and notifications at no cost to Android, iOS or Web browsers.}
+  s.license     = "MIT"
+
+  s.required_ruby_version     = '>= 2.0.0'
+
+  s.rubyforge_project = "fcm"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency('httparty')
+  s.add_dependency('json')
+end

data/lib/fcm.rb

@@ -0,0 +1,179 @@
+require 'httparty'
+require 'cgi'
+require 'json'
+
+class FCM
+  include HTTParty
+  base_uri 'https://fcm.googleapis.com/fcm'
+  default_timeout 30
+  format :json
+
+  attr_accessor :timeout, :api_key
+
+  def initialize(api_key, client_options = {})
+    @api_key = api_key
+    @client_options = client_options
+  end
+
+  # {
+  #   "collapse_key": "score_update",
+  #   "time_to_live": 108,
+  #   "delay_while_idle": true,
+  #   "registration_ids": ["4", "8", "15", "16", "23", "42"],
+  #   "data" : {
+  #     "score": "5x1",
+  #     "time": "15:10"
+  #   }
+  # }
+  # fcm = FCM.new("API_KEY")
+  # fcm.send(registration_ids: ["4sdsx", "8sdsd"], {data: {score: "5x1"}})
+  def send_notification(registration_ids, options = {})
+    post_body = build_post_body(registration_ids, options)
+
+    params = {
+      body: post_body.to_json,
+      headers: {
+        'Authorization' => "key=#{@api_key}",
+        'Content-Type' => 'application/json'
+      }
+    }
+    response = self.class.post('/send', params.merge(@client_options))
+    build_response(response, registration_ids)
+  end
+  alias send send_notification
+
+  def create_notification_key(key_name, project_id, registration_ids = [])
+    post_body = build_post_body(registration_ids,                   operation: 'create',
+                                                                    notification_key_name: key_name)
+
+    params = {
+      body: post_body.to_json,
+      headers: {
+        'Content-Type' => 'application/json',
+        'project_id' => project_id,
+        'Authorization' => "key=#{@api_key}"
+      }
+    }
+
+    response = self.class.post('/notification', params.merge(@client_options))
+    build_response(response)
+  end
+  alias create create_notification_key
+
+  def add_registration_ids(key_name, project_id, notification_key, registration_ids)
+    post_body = build_post_body(registration_ids,                     operation: 'add',
+                                                                      notification_key_name: key_name,
+                                                                      notification_key: notification_key)
+
+    params = {
+      body: post_body.to_json,
+      headers: {
+        'Content-Type' => 'application/json',
+        'project_id' => project_id,
+        'Authorization' => "key=#{@api_key}"
+      }
+    }
+
+    response = self.class.post('/notification', params.merge(@client_options))
+    build_response(response)
+  end
+  alias add add_registration_ids
+
+  def remove_registration_ids(key_name, project_id, notification_key, registration_ids)
+    post_body = build_post_body(registration_ids,                   operation: 'remove',
+                                                                    notification_key_name: key_name,
+                                                                    notification_key: notification_key)
+
+    params = {
+      body: post_body.to_json,
+      headers: {
+        'Content-Type' => 'application/json',
+        'project_id' => project_id,
+        'Authorization' => "key=#{@api_key}"
+      }
+    }
+
+    response = self.class.post('/notification', params.merge(@client_options))
+    build_response(response)
+  end
+  alias remove remove_registration_ids
+
+  def send_with_notification_key(notification_key, options = {})
+    body = { to: notification_key }.merge(options)
+
+    params = {
+      body: body.to_json,
+      headers: {
+        'Authorization' => "key=#{@api_key}",
+        'Content-Type' => 'application/json'
+      }
+    }
+    response = self.class.post('/send', params.merge(@client_options))
+    build_response(response)
+  end
+
+  def send_to_topic(topic, options = {})
+    if topic =~ /[a-zA-Z0-9\-_.~%]+/
+      send_with_notification_key('/topics/' + topic, options)
+    end
+  end
+
+  private
+
+  def build_post_body(registration_ids, options = {})
+    { registration_ids: registration_ids }.merge(options)
+  end
+
+  def build_response(response, registration_ids = [])
+    body = response.body || {}
+    response_hash = { body: body, headers: response.headers, status_code: response.code }
+    case response.code
+    when 200
+      response_hash[:response] = 'success'
+      body = JSON.parse(body) unless body.empty?
+      response_hash[:canonical_ids] = build_canonical_ids(body, registration_ids) unless registration_ids.empty?
+      response_hash[:not_registered_ids] = build_not_registered_ids(body, registration_ids) unless registration_ids.empty?
+    when 400
+      response_hash[:response] = 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.'
+    when 401
+      response_hash[:response] = 'There was an error authenticating the sender account.'
+    when 503
+      response_hash[:response] = 'Server is temporarily unavailable.'
+    when 500..599
+      response_hash[:response] = 'There was an internal error in the FCM server while trying to process the request.'
+    end
+    response_hash
+  end
+
+  def build_canonical_ids(body, registration_ids)
+    canonical_ids = []
+    unless body.empty?
+      if body['canonical_ids'] > 0
+        body['results'].each_with_index do |result, index|
+          canonical_ids << { old: registration_ids[index], new: result['registration_id'] } if has_canonical_id?(result)
+        end
+      end
+    end
+    canonical_ids
+  end
+
+  def build_not_registered_ids(body, registration_id)
+    not_registered_ids = []
+    unless body.empty?
+      if body['failure'] > 0
+        body['results'].each_with_index do |result, index|
+          not_registered_ids << registration_id[index] if is_not_registered?(result)
+        end
+      end
+    end
+    not_registered_ids
+  end
+
+  def has_canonical_id?(result)
+    !result['registration_id'].nil?
+  end
+
+  def is_not_registered?(result)
+    result['error'] == 'NotRegistered'
+  end
+end

data/spec/fcm_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe FCM do
+  let(:send_url) { "#{FCM.base_uri}/send" }
+
+  it 'should raise an error if the api key is not provided' do
+    expect { FCM.new }.to raise_error
+  end
+
+  it 'should raise error if time_to_live is given' do
+    # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#ttl
+  end
+
+  describe 'sending notification' do
+    let(:api_key) { 'AIzaSyB-1uEai2WiUapxCs2Q0GZYzPu7Udno5aA' }
+    let(:registration_ids) { ['42'] }
+    let(:valid_request_body) do
+      { registration_ids: registration_ids }
+    end
+    let(:valid_request_headers) do
+      {
+        'Content-Type' => 'application/json',
+        'Authorization' => "key=#{api_key}"
+      }
+    end
+
+    let(:stub_fcm_send_request) do
+      stub_request(:post, send_url).with(
+        body: valid_request_body.to_json,
+        headers: valid_request_headers
+      ).to_return(
+        # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+        body: '{}',
+        headers: {},
+        status: 200
+      )
+    end
+
+    let(:stub_fcm_send_request_with_basic_auth) do
+      uri = URI.parse(send_url)
+      uri.user = 'a'
+      uri.password = 'b'
+      stub_request(:post, uri.to_s).to_return(body: '{}', headers: {}, status: 200)
+    end
+
+    before(:each) do
+      stub_fcm_send_request
+      stub_fcm_send_request_with_basic_auth
+    end
+
+    it 'should send notification using POST to FCM server' do
+      fcm = FCM.new(api_key)
+      fcm.send(registration_ids).should eq(response: 'success', body: '{}', headers: {}, status_code: 200, canonical_ids: [], not_registered_ids: [])
+      stub_fcm_send_request.should have_been_made.times(1)
+    end
+
+    context 'send notification with data' do
+      let!(:stub_with_data) do
+        stub_request(:post, send_url)
+          .with(body: '{"registration_ids":["42"],"data":{"score":"5x1","time":"15:10"}}',
+                headers: valid_request_headers)
+          .to_return(status: 200, body: '', headers: {})
+      end
+      before do
+      end
+      it 'should send the data in a post request to fcm' do
+        fcm = FCM.new(api_key)
+        fcm.send(registration_ids, data: { score: '5x1', time: '15:10' })
+        stub_with_data.should have_been_requested
+      end
+    end
+
+    context 'when send_notification responds with failure' do
+      let(:mock_request_attributes) do
+        {
+          body: valid_request_body.to_json,
+          headers: valid_request_headers
+        }
+      end
+
+      subject { FCM.new(api_key) }
+
+      context 'on failure code 400' do
+        before do
+          stub_request(:post, send_url).with(
+            mock_request_attributes
+          ).to_return(
+            # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+            body: '{}',
+            headers: {},
+            status: 400
+          )
+        end
+        it 'should not send notification due to 400' do
+          subject.send(registration_ids).should eq(body: '{}',
+                                                   headers: {},
+                                                   response: 'Only applies for JSON requests. Indicates that the request could not be parsed as JSON, or it contained invalid fields.',
+                                                   status_code: 400)
+        end
+      end
+
+      context 'on failure code 401' do
+        before do
+          stub_request(:post, send_url).with(
+            mock_request_attributes
+          ).to_return(
+            # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+            body: '{}',
+            headers: {},
+            status: 401
+          )
+        end
+
+        it 'should not send notification due to 401' do
+          subject.send(registration_ids).should eq(body: '{}',
+                                                   headers: {},
+                                                   response: 'There was an error authenticating the sender account.',
+                                                   status_code: 401)
+        end
+      end
+
+      context 'on failure code 503' do
+        before do
+          stub_request(:post, send_url).with(
+            mock_request_attributes
+          ).to_return(
+            # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+            body: '{}',
+            headers: {},
+            status: 503
+          )
+        end
+
+        it 'should not send notification due to 503' do
+          subject.send(registration_ids).should eq(body: '{}',
+                                                   headers: {},
+                                                   response: 'Server is temporarily unavailable.',
+                                                   status_code: 503)
+        end
+      end
+
+      context 'on failure code 5xx' do
+        before do
+          stub_request(:post, send_url).with(
+            mock_request_attributes
+          ).to_return(
+            # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+            body: '{"body-key" => "Body value"}',
+            headers: { 'header-key' => 'Header value' },
+            status: 599
+          )
+        end
+
+        it 'should not send notification due to 599' do
+          subject.send(registration_ids).should eq(body: '{"body-key" => "Body value"}',
+                                                   headers: { 'header-key' => ['Header value'] },
+                                                   response: 'There was an internal error in the FCM server while trying to process the request.',
+                                                   status_code: 599)
+        end
+      end
+    end
+
+    context 'when send_notification responds canonical_ids' do
+      let(:mock_request_attributes) do
+        {
+          body: valid_request_body.to_json,
+          headers: valid_request_headers
+        }
+      end
+
+      let(:valid_response_body_with_canonical_ids) do
+        {
+          failure: 0, canonical_ids: 1, results: [{ registration_id: '43', message_id: '0:1385025861956342%572c22801bb3' }]
+        }
+      end
+
+      subject { FCM.new(api_key) }
+
+      before do
+        stub_request(:post, send_url).with(
+          mock_request_attributes
+        ).to_return(
+          # ref: https://firebase.google.com/docs/cloud-messaging/http-server-ref#interpret-downstream
+          body: valid_response_body_with_canonical_ids.to_json,
+          headers: {},
+          status: 200
+        )
+      end
+
+      it 'should contain canonical_ids' do
+        response = subject.send(registration_ids)
+
+        response.should eq(headers: {},
+                           canonical_ids: [{ old: '42', new: '43' }],
+                           not_registered_ids: [],
+                           status_code: 200,
+                           response: 'success',
+                           body: '{"failure":0,"canonical_ids":1,"results":[{"registration_id":"43","message_id":"0:1385025861956342%572c22801bb3"}]}')
+      end
+    end
+
+    context 'when send_notification responds with NotRegistered' do
+      subject { FCM.new(api_key) }
+
+      let(:mock_request_attributes) do
+        {
+          body: valid_request_body.to_json,
+          headers: valid_request_headers
+        }
+      end
+
+      let(:valid_response_body_with_not_registered_ids) do
+        {
+          canonical_ids: 0, failure: 1, results: [{ error: 'NotRegistered' }]
+        }
+      end
+
+      before do
+        stub_request(:post, send_url).with(
+          mock_request_attributes
+        ).to_return(
+          body: valid_response_body_with_not_registered_ids.to_json,
+          headers: {},
+          status: 200
+        )
+      end
+
+      it 'should contain not_registered_ids' do
+        response = subject.send(registration_ids)
+        response.should eq(
+          headers: {},
+          canonical_ids: [],
+          not_registered_ids: registration_ids,
+          status_code: 200,
+          response: 'success',
+          body: '{"canonical_ids":0,"failure":1,"results":[{"error":"NotRegistered"}]}'
+        )
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'webmock/rspec'
+
+require 'fcm'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+  # config.filter_run :focus
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: fcm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kashif Rasul
+- Shoaib Burq
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: fcm provides ruby bindings to Firebase Cloud Messaging (FCM) a cross-platform
+  messaging solution that lets you reliably deliver messages and notifications at
+  no cost to Android, iOS or Web browsers.
+email:
+- kashif@spacialdb.com
+- shoaib@spacialdb.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- fcm.gemspec
+- lib/fcm.rb
+- spec/fcm_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/spacialdb/fcm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: fcm
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Reliably deliver messages and notifications via FCM
+test_files:
+- spec/fcm_spec.rb
+- spec/spec_helper.rb