twinpush 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4e5f75a1774fcdbbf792c1e4d982e07cf13d324e0ef3ee113efea24c0c9ae417
+  data.tar.gz: 0776ed72759003f8108506bcd4d9e1645ef12e27a6575d681fc5030a30f4e7f0
+SHA512:
+  metadata.gz: 8246fe87adbae38faed5bc5d7d8de5bf1b022ec284ef73363bd88de647a2ec4e292074e9742283740928c52c27fa010266c6a83b1dc2b340a5c77a14e8263c65
+  data.tar.gz: b1d5e69a2c9137a795cb107fba7e8e59143bd0a73689c43b7e3f5fc9d699face3514682ffb4a6f46c4c42e468a5af054a40a1c7d6c5c0ce0723a20cedd7d0afe

data/lib/twinpush.rb

@@ -0,0 +1,159 @@
+require 'faraday'
+require 'cgi'
+require 'json'
+
+class TWINPUSH
+  DEFAULT_TIMEOUT = 30
+  FORMAT = :json
+  BASE_URI = 'https://subdomain.twinpush.com'
+  API_URL = '/api/v2/apps'
+
+  attr_accessor :uri, :app_id, :api_token, :api_token_creator
+
+  # @param [Hash] authentication_keys
+  # @param [Hash] client_options
+  # @param [Integer] timeout
+  def initialize(authentication_keys, client_options = {}, timeout = nil)
+    validate_keys(authentication_keys)
+    authentication_keys.each_pair do |key, value|
+      instance_variable_set("@#{key}", value)
+      self.class.instance_eval { attr_accessor key.to_sym }
+    end
+    @uri = BASE_URI.sub! 'subdomain', @subdomain
+    @client_options = client_options
+    @timeout = timeout | DEFAULT_TIMEOUT
+  end
+
+  #obtains details from a previously created notification
+  def show_notification(notification_id, device_id = nil)
+    path = "#{API_URL}/#{app_id}#{"/devices/#{device_id}" if device_id }/notifications/#{notification_id}"
+    for_uri(uri) do |connection|
+      response = connection.get(path)
+      build_response(response)
+    end
+  end
+
+  alias show show_notification
+
+  #creates a new notification to be delivered from the platform
+  def create_notification(notification_params)
+    path = "#{API_URL}/#{app_id}/notifications"
+    for_uri(uri) do |connection|
+      response = connection.post(path, notification_params.to_json)
+      build_response(response)
+    end
+  end
+
+  alias create create_notification
+
+  # obtains delivery statistics for a given notification
+  def report_notification(notification_id)
+    path = "#{API_URL}/#{app_id}/notifications/#{notification_id}/report"
+    for_uri(uri) do |connection|
+      response = connection.get(path)
+      build_response(response)
+    end
+  end
+
+  alias report report_notification
+
+  #Obtains paginated list of all the deliveries for a given notification.
+  #This is useful to obtain exactly who has been the recipient of the notification and also who has opened it
+  def deliveries_notification(notification_id)
+    path = "#{API_URL}/#{app_id}/notifications/#{notification_id}/deliveries"
+    for_uri(uri) do |connection|
+      response = connection.get(path)
+      build_response(response)
+    end
+  end
+
+  alias deliveries deliveries_notification
+
+  # Makes a paginated search of the notifications sent to an user through the device alias. It allows filtering by notification tags
+  def inbox(device_id)
+    path = "#{API_URL}/#{app_id}/devices/#{device_id}/inbox"
+    for_uri(uri) do |connection|
+      response = connection.get(path)
+      build_response(response)
+    end
+  end
+
+  #Obtains a fast summary of the notification inbox associated to the current device alias
+  #It offers the total notification count and the unopened notification count
+  def inbox_summary(device_id)
+    path = "#{API_URL}/#{app_id}/devices/#{device_id}/inbox_summary"
+    for_uri(uri) do |connection|
+      response = connection.get(path)
+      build_response(response)
+    end
+  end
+
+  #Removes the selected notification from the inbox of the user (or alias) associated to the device
+  def delete_inbox(device_id, notification_id)
+    path = "#{API_URL}/#{app_id}/devices/#{device_id}/notifications/#{notification_id}"
+    for_uri(uri) do |connection|
+      response = connection.delete(path)
+      build_response(response)
+    end
+  end
+
+  # assigns value for a device custom property
+  def set_custom_property(device_id, properties)
+    path = "#{API_URL}/#{app_id}/devices/#{device_id}/set_custom_property"
+    for_uri(uri) do |connection|
+      response = connection.post(path, properties.to_json)
+      build_response(response)
+    end
+  end
+
+  #Makes a paginated search of the notifications received by a device. It allows filtering by notification tags
+  def search_device_notifications(device_id, params)
+    path = "#{API_URL}/#{app_id}/devices/#{device_id}/search_notifications"
+    for_uri(uri) do |connection|
+      response = connection.post(path, params.to_json)
+      build_response(response)
+    end
+  end
+
+  private
+
+  def validate_keys(authentication_keys)
+    required_params = [:app_id, :subdomain, :api_token, :api_token_creator]
+    (required_params - authentication_keys.keys).each do |params|
+      raise ArgumentError, "Required authentication_key #{params} missing"
+    end
+  end
+
+  def for_uri(uri, extra_headers = {})
+    connection = ::Faraday.new(:url => uri) do |faraday|
+      faraday.adapter  Faraday.default_adapter
+      faraday.headers["Content-Type"] = "application/json"
+      faraday.headers["X-TwinPush-REST-API-Key-Creator"] = api_token_creator
+      faraday.headers["X-TwinPush-REST-API-Token"] = api_token
+      extra_headers.each do |key, value|
+        faraday.headers[key] = value
+      end
+    end
+    yield connection
+  end
+
+  def build_response(response)
+    body = response.body || {}
+    response_hash = { body: body, headers: response.headers, status_code: response.status }
+    case response.status
+    when 200
+      response_hash[:response] = 'success'
+    when 403
+      response_hash[:response] = 'API Key Token or Creator API Key Token are not valid or does not match with App ID'
+    when 404
+      response_hash[:response] = 'Application not found for given application_id, device not found for given device_id or delivery not found for given notification and device'
+    when 422
+      response_hash[:response] = 'Some of the parameters given is not valid when trying to create a notification, create a device property or register or update a device'
+    when 500..599
+      response_hash[:response] = 'There was an internal error in the Twinpush server while trying to process the request.'
+    end
+    response_hash
+  end
+
+
+end

data/spec/spec_helper.rb

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

data/spec/twinpush_spec.rb

@@ -0,0 +1,475 @@
+require 'spec_helper'
+
+describe TWINPUSH do
+  let(:app_id) { '1a2b3c4d5f' }
+  let(:subdomain) { 'test' }
+  let(:api_token) { '1c5cabc4055e03c64f123d9dbfb4d0e9' }
+  let(:api_token_creator) { '232ddfd56b6a3af1ba89b93c5ffd836d' }
+  let(:authentication_keys) {{app_id: app_id, subdomain: subdomain, api_token: api_token, api_token_creator: api_token_creator}}
+
+  it 'should replace subdomian in uri' do
+    twinpush = TWINPUSH.new(authentication_keys)
+    expect(twinpush.uri).to eq "https://test.googleapis.com/api/v2"
+  end
+
+  it 'should raise an error if authentication_keys is not provided' do
+    expect { TWINPUSH.new }.to raise_error(ArgumentError)
+    expect { TWINPUSH.new(app_id: app_id )}.to raise_error(ArgumentError, 'Required authentication_key subdomain missing')
+    expect { TWINPUSH.new(app_id: app_id, subdomain: subdomain )}.to raise_error(ArgumentError, 'Required authentication_key api_token missing')
+    expect { TWINPUSH.new(app_id: app_id, subdomain: subdomain, api_token: api_token)}.to raise_error(ArgumentError, 'Required authentication_key api_token_creator missing')
+    expect { TWINPUSH.new(authentication_keys)}.not_to raise_error(ArgumentError)
+  end
+
+  # describe 'sending notification' do
+  #   let(:valid_request_body) do
+  #     { registration_ids: registration_ids }
+  #   end
+  #   let(:valid_request_body_with_string) do
+  #     { registration_ids: registration_id }
+  #   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_string) do
+  #     stub_request(:post, send_url).with(
+  #         body: valid_request_body_with_string.to_json,
+  #         headers: valid_request_headers
+  #     ).to_return(
+  #         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_string
+  #     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
+  #
+  #   it 'should send notification using POST to FCM if id provided as string' do
+  #     fcm = FCM.new(api_key)
+  #     fcm.send(registration_id).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 "sending notification to a topic" do
+  #     let!(:stub_with_valid_topic) do
+  #       stub_request(:post, send_url)
+  #           .with(body: '{"to":"/topics/TopicA","data":{"score":"5x1","time":"15:10"}}',
+  #                 headers: valid_request_headers)
+  #           .to_return(status: 200, body: '', headers: {})
+  #     end
+  #     let!(:stub_with_invalid_topic) do
+  #       stub_request(:post, send_url)
+  #           .with(body: '{"condition":"/topics/TopicA$","data":{"score":"5x1","time":"15:10"}}',
+  #                 headers: valid_request_headers)
+  #           .to_return(status: 200, body: '', headers: {})
+  #     end
+  #
+  #     describe "#send_to_topic" do
+  #       it 'should send the data in a post request to fcm' do
+  #         fcm = FCM.new(api_key)
+  #         fcm.send_to_topic(valid_topic, data: { score: '5x1', time: '15:10' })
+  #         stub_with_valid_topic.should have_been_requested
+  #       end
+  #
+  #       it 'should not send to invalid topics' do
+  #         fcm = FCM.new(api_key)
+  #         fcm.send_to_topic(invalid_topic, data: { score: '5x1', time: '15:10' })
+  #         stub_with_invalid_topic.should_not have_been_requested
+  #       end
+  #     end
+  #   end
+  #
+  #   context "sending notification to a topic condition" do
+  #     let!(:stub_with_valid_condition) do
+  #       stub_request(:post, send_url)
+  #           .with(body: '{"condition":"\'TopicA\' in topics && (\'TopicB\' in topics || \'TopicC\' in topics)","data":{"score":"5x1","time":"15:10"}}',
+  #                 headers: valid_request_headers)
+  #           .to_return(status: 200, body: '', headers: {})
+  #     end
+  #     let!(:stub_with_invalid_condition) do
+  #       stub_request(:post, send_url)
+  #           .with(body: '{"condition":"\'TopicA\' in topics and some other text (\'TopicB\' in topics || \'TopicC\' in topics)","data":{"score":"5x1","time":"15:10"}}',
+  #                 headers: valid_request_headers)
+  #           .to_return(status: 200, body: '', headers: {})
+  #     end
+  #     let!(:stub_with_invalid_condition_topic) do
+  #       stub_request(:post, send_url)
+  #           .with(body: '{"condition":"\'TopicA$\' in topics","data":{"score":"5x1","time":"15:10"}}',
+  #                 headers: valid_request_headers)
+  #           .to_return(status: 200, body: '', headers: {})
+  #     end
+  #
+  #     describe "#send_to_topic_condition" do
+  #       it 'should send the data in a post request to fcm' do
+  #         fcm = FCM.new(api_key)
+  #         fcm.send_to_topic_condition(valid_condition, data: { score: '5x1', time: '15:10' })
+  #         stub_with_valid_condition.should have_been_requested
+  #       end
+  #
+  #       it 'should not send to invalid conditions' do
+  #         fcm = FCM.new(api_key)
+  #         fcm.send_to_topic_condition(invalid_condition, data: { score: '5x1', time: '15:10' })
+  #         stub_with_invalid_condition.should_not have_been_requested
+  #       end
+  #
+  #       it 'should not send to invalid topics in a condition' do
+  #         fcm = FCM.new(api_key)
+  #         fcm.send_to_topic_condition(invalid_condition_topic, data: { score: '5x1', time: '15:10' })
+  #         stub_with_invalid_condition_topic.should_not have_been_requested
+  #       end
+  #     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
+  #
+  # describe 'sending group notifications' do
+  #   # TODO: refactor to should_behave_like
+  #   let(:valid_request_headers) do
+  #     {
+  #         "Authorization" => "key=#{api_key}",
+  #         "Content-Type" => 'application/json',
+  #         "Project-Id" => project_id
+  #     }
+  #   end
+  #   let(:valid_response_body) do
+  #     { notification_key: "APA91bGHXQBB...9QgnYOEURwm0I3lmyqzk2TXQ" }
+  #   end
+  #
+  #   let(:default_valid_request_body) do
+  #     {
+  #         registration_ids: registration_ids,
+  #         operation: "create",
+  #         notification_key_name: key_name
+  #     }
+  #   end
+  #
+  #   subject { FCM.new(api_key) }
+  #
+  #   # ref: https://firebase.google.com/docs/cloud-messaging/notifications#managing-device-groups-on-the-app-server
+  #   context 'create' do
+  #     let(:valid_request_body) do
+  #       default_valid_request_body.merge({
+  #                                            operation: "create"
+  #                                        })
+  #     end
+  #
+  #     let(:mock_request_attributes) do
+  #       {
+  #           body: valid_request_body.to_json,
+  #           headers: valid_request_headers
+  #       }
+  #     end
+  #
+  #     before do
+  #       stub_request(:post, group_notification_base_uri).with(
+  #           mock_request_attributes
+  #       ).to_return(
+  #           body: valid_response_body.to_json,
+  #           headers: {},
+  #           status: 200
+  #       )
+  #     end
+  #
+  #     it 'should send a post request' do
+  #       response = subject.create(key_name, project_id, registration_ids)
+  #       response.should eq(
+  #                           headers: {},
+  #                           status_code: 200,
+  #                           response: 'success',
+  #                           body: valid_response_body.to_json
+  #                       )
+  #     end
+  #   end # create context
+  #
+  #   context 'add' do
+  #     let(:valid_request_body) do
+  #       default_valid_request_body.merge({
+  #                                            operation: "add",
+  #                                            notification_key: notification_key
+  #                                        })
+  #     end
+  #
+  #     let(:mock_request_attributes) do
+  #       {
+  #           body: valid_request_body.to_json,
+  #           headers: valid_request_headers
+  #       }
+  #     end
+  #
+  #     before do
+  #       stub_request(:post, group_notification_base_uri).with(
+  #           mock_request_attributes
+  #       ).to_return(
+  #           body: valid_response_body.to_json,
+  #           headers: {},
+  #           status: 200
+  #       )
+  #     end
+  #
+  #     it 'should send a post request' do
+  #       response = subject.add(key_name, project_id, notification_key, registration_ids)
+  #       response.should eq(
+  #                           headers: {},
+  #                           status_code: 200,
+  #                           response: 'success',
+  #                           body: valid_response_body.to_json
+  #                       )
+  #     end
+  #   end # add context
+  #
+  #   context 'remove' do
+  #     let(:valid_request_body) do
+  #       default_valid_request_body.merge({
+  #                                            operation: "remove",
+  #                                            notification_key: notification_key
+  #                                        })
+  #     end
+  #
+  #     let(:mock_request_attributes) do
+  #       {
+  #           body: valid_request_body.to_json,
+  #           headers: valid_request_headers
+  #       }
+  #     end
+  #
+  #     before do
+  #       stub_request(:post, group_notification_base_uri).with(
+  #           mock_request_attributes
+  #       ).to_return(
+  #           body: valid_response_body.to_json,
+  #           headers: {},
+  #           status: 200
+  #       )
+  #     end
+  #
+  #     it 'should send a post request' do
+  #       response = subject.remove(key_name, project_id, notification_key, registration_ids)
+  #       response.should eq(
+  #                           headers: {},
+  #                           status_code: 200,
+  #                           response: 'success',
+  #                           body: valid_response_body.to_json
+  #                       )
+  #     end
+  #   end # remove context
+  # end
+  #
+  # describe 'subscribing to a topic' do
+  #   # TODO
+  # end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: twinpush
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Amaury González
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.15.4
+description: TwinPush gem provides ruby bindings to TwinPush a messaging solution
+  that lets you reliably deliver messages and notifications at no cost to Android,
+  iOS or Web browsers.
+email:
+- amaury.muro@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/twinpush.rb
+- spec/spec_helper.rb
+- spec/twinpush_spec.rb
+homepage: https://github.com/amaurygonzalez/twinpush
+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: twinpush
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Reliably deliver push notifications through TwinPush API
+test_files:
+- spec/spec_helper.rb
+- spec/twinpush_spec.rb