apn_sender 2.0.2 → 2.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a84e566b3256a5f25795f6264af593041e7c800
+  data.tar.gz: cbe6ffd3cc326f919f702c883c1c608d9ed58535
+SHA512:
+  metadata.gz: 8dc1ed6e420f195f9154c145b3a5c3ca53d0de4b76c4b55b64b8c77dcfdeee2dded1d2279d9c4cc643650681cba1225744550a3314cd8cb28ce6197b47eaab1b
+  data.tar.gz: 0782593c57733813f5ad1a9b6b6a50f50d4550550e0583ce2a4168b505a0d1bdd47fbfde2cd217b0dbcf16f66f8b7b8e8cf84d02c2fb2f3e6251db08e28e521e

data/lib/apn.rb

@@ -1,14 +1,14 @@
 require "openssl"
 require "socket"
+require "active_support"
 require "active_support/core_ext"
 require "active_support/json"
 require 'connection_pool'
 
 require "apn/version"
-require 'apn/connection'
+require "apn/connection"
 
 module APN
-
   class << self
     include APN::Connection
 
@@ -83,6 +83,7 @@ module APN
   end
 end
 
+require 'apn/multiple_apps' if ENV['APN_MULTIPLE_APPS'] == 'true'
 require 'apn/notification'
 require 'apn/client'
 require 'apn/feedback'

data/lib/apn/application.rb

@@ -0,0 +1,37 @@
+require "apn/connection"
+
+module APN
+  class Application
+    include Connection
+
+    APPS = {}
+    OPTION_KEYS = [:pool_size, :pool_timeout, :host, :port, :root, :full_certificate_path, :password, :certificate_name].freeze
+    DELEGATE_METHODS = [:with_connection, :connection_pool].concat(OPTION_KEYS)
+
+    attr_reader :name
+
+    def initialize(name, options = {})
+      @name = name.to_s
+
+      OPTION_KEYS.each do |key|
+        self.send("#{key}=", options.fetch(key) { APN.send("original_#{key}") } )
+      end
+    end
+
+    def to_h
+      Hash[OPTION_KEYS.zip(OPTION_KEYS.map(&method(:send)))]
+    end
+
+    def == other
+      if other.is_a?(APN::Application)
+        to_h == other.to_h
+      else
+        super(other)
+      end
+    end
+
+    def self.register(*args)
+      new(*args).tap { |app| APPS[app.name] = app if app.certificate }
+    end
+  end
+end

data/lib/apn/jobs/sidekiq_notification_job.rb

@@ -1,11 +1,11 @@
 module APN::Jobs
   # This is the class that's actually enqueued via Sidekiq when user calls +APN.notify+.
-  # It gets added to the +apple_server_notifications+ Sidekiq queue, which should only be operated on by
+  # It gets added to the +apple_push_notifications+ Sidekiq queue, which should only be operated on by
   # workers of the +APN::Sender+ class.
   class SidekiqNotificationJob
     include Sidekiq::Worker
     # Behind the scenes, this is the name of our Sidekiq queue
-    @queue = QUEUE_NAME
+    sidekiq_options :queue => QUEUE_NAME
 
     # Build a notification from arguments and send to Apple
     def perform(token, opts)

data/lib/apn/multiple_apps.rb

@@ -0,0 +1,53 @@
+require "apn/application"
+
+module APN
+  module MultipleApps
+    def self.extended(mod)
+      class << mod
+        alias_method_chain :notify_sync, :app
+
+        delegate(*Application::DELEGATE_METHODS, to: :current_app, prefix: true, allow_nil: true)
+
+        Application::DELEGATE_METHODS.each do |method_name|
+          alias_method :"original_#{method_name}", method_name
+          alias_method method_name, :"current_app_#{method_name}"
+        end
+      end
+    end
+
+    def notify_sync_with_app(token, notification)
+      if notification.is_a?(Hash)
+        notification.symbolize_keys!
+        app_name = notification.delete(:app)
+      end
+
+      with_app(app_name) do
+        notify_sync_without_app(token, notification)
+      end
+    end
+
+    attr_writer :default_app_name
+
+    def default_app_name
+      @default_app_name || 'default'.freeze
+    end
+
+    def current_app_name
+      @_app_name || default_app_name
+    end
+
+    def current_app
+      Application::APPS[current_app_name] or \
+        raise NameError, "Unregistered APN::Application `#{current_app_name}'"
+    end
+
+    def with_app(app_name)
+      @_app_name, app_was = app_name.presence, @_app_name
+      yield if block_given?
+    ensure
+      @_app_name = app_was
+    end
+  end
+end
+
+APN.extend APN::MultipleApps

data/lib/apn/notification.rb

@@ -1,3 +1,5 @@
+require 'apn/payload'
+
 module APN
   # Encapsulates the logic necessary to convert an iPhone token and an array of options into a string of the format required
   # by Apple's servers to send the notification.  Much of the processing code here copied with many thanks from
@@ -19,9 +21,9 @@ module APN
   #
   class Notification
     # Available to help clients determine before they create the notification if their message will be too large.
-    # Each iPhone Notification payload must be 256 or fewer characters (not including the token or other push data), see Apple specs at:
-    # https://developer.apple.com/library/mac/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/CommunicatingWIthAPS.html#//apple_ref/doc/uid/TP40008194-CH101-SW4
-    DATA_MAX_BYTES = 256
+    # Each iPhone Notification payload must be 2047 or fewer characters (not including the token or other push data), see Apple specs at:
+    # https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/ApplePushService.html#//apple_ref/doc/uid/TP40008194-CH100-SW1
+    DATA_MAX_BYTES = 2047
 
     attr_accessor :options, :token
     def initialize(token, opts)
@@ -47,9 +49,23 @@ module APN
 
     # Completed encoded notification, ready to send down the wire to Apple
     def packaged_notification
-      pt = packaged_token
-      pm = packaged_message
-      [0, 0, 32, pt, 0, payload_size, pm].pack("ccca*cca*")
+      [2, frame_length, packaged_frame].pack("cl>a*")
+    end
+
+    def frame_length
+      packaged_frame.bytesize
+    end
+
+    def packaged_frame
+      [token_frame, payload_frame].pack('a*a*')
+    end
+
+    def token_frame
+      [1, 32, packaged_token].pack('cs>a*')
+    end
+
+    def payload_frame
+      [2, payload_size, packaged_message].pack('cs>a*')
     end
 
     # Device token, compressed and hex-ified
@@ -58,7 +74,7 @@ module APN
     end
 
     # Converts the supplied options into the JSON needed for Apple's push notification servers.
-    # Extracts :alert, :badge, and :sound keys into the 'aps' hash, merges any other hash data
+    # Extracts :alert, :badge, :sound and :category keys into the 'aps' hash, merges any other hash data
     # into the root of the hash to encode and send to apple.
     def packaged_message
       @packaged_message ||=
@@ -70,6 +86,7 @@ module APN
             hsh['aps']['alert'] = alert
           end
           hsh['aps']['badge'] = opts.delete(:badge).to_i if opts[:badge]
+          hsh['aps']['category'] = opts.delete(:category).to_s if opts[:category]
           if sound = opts.delete(:sound)
             hsh['aps']['sound'] = sound.is_a?(TrueClass) ? 'default' : sound.to_s
           end
@@ -77,45 +94,8 @@ module APN
             hsh['aps']['content-available'] = 1 if [1,true].include? content_available
           end
           hsh.merge!(opts)
-          payload(hsh)
+          Payload.new(hsh, DATA_MAX_BYTES).package
         end
     end
-
-    private
-
-      def payload(hash)
-        str = ActiveSupport::JSON::encode(hash)
-
-        if APN.truncate_alert && str.bytesize > DATA_MAX_BYTES
-          if hash['aps']['alert'].is_a?(Hash)
-            alert = hash['aps']['alert']['loc-args'][0]
-          else
-            alert = hash['aps']['alert']
-          end
-          max_bytesize = DATA_MAX_BYTES - (str.bytesize - alert.bytesize)
-
-          raise "Even truncating the alert wont be enought to have a #{DATA_MAX_BYTES} message" if max_bytesize <= 0
-          alert = truncate_alert(alert, max_bytesize)
-
-          if hash['aps']['alert'].is_a?(Hash)
-            hash['aps']['alert']['loc-args'][0] = alert
-          else
-            hash['aps']['alert'] = alert
-          end
-          str = ActiveSupport::JSON::encode(hash)
-        end
-        str
-      end
-
-      def truncate_alert(alert, max_size)
-        alert.each_char.each_with_object('') do |char, result|
-          if result.bytesize + char.bytesize > max_size
-            break result
-          else
-            result << char
-          end
-        end
-      end
-
   end
 end

data/lib/apn/payload.rb

@@ -0,0 +1,70 @@
+class Payload
+
+  def initialize(notification_hash, max_bytes)
+    @notification_hash = notification_hash
+    @max_bytes = max_bytes
+  end
+
+  def package
+    str = encode(@notification_hash)
+
+    if APN.truncate_alert && str.bytesize > @max_bytes
+      max_bytesize = @max_bytes - (str.bytesize - alert.bytesize)
+
+      if max_bytesize <= 0
+        escaped_max_bytesize = @max_bytes - (str.bytesize - encode(alert).bytesize)
+        raise "Even truncating the alert won't be enough to have a #{@max_bytes} message" if escaped_max_bytesize <= 0
+        truncate_escaped!(escaped_max_bytesize)
+      else
+        truncate_alert!(max_bytesize)
+      end
+      str = encode(@notification_hash)
+    end
+    str
+  end
+
+  private
+
+    def alert
+      @alert ||=
+      if hash_alert?
+        @notification_hash['aps']['alert']['loc-args'][0]
+      else
+        @notification_hash['aps']['alert']
+      end
+    end
+
+    def alert=(value)
+      if hash_alert?
+        @notification_hash['aps']['alert']['loc-args'][0] = value
+      else
+        @notification_hash['aps']['alert'] = value
+      end
+    end
+
+    def hash_alert?
+      @hash_alert ||= @notification_hash['aps']['alert'].is_a?(Hash)
+    end
+
+    def truncate_alert!(max_size)
+      self.alert = alert.mb_chars.limit(max_size).to_s
+    end
+
+    def truncate_escaped!(max_size)
+      self.alert = alert.each_char.each_with_object('') do |char, result|
+        if encoded_size(result) + encoded_size(char) > max_size
+          break result
+        else
+          result << char
+        end
+      end
+    end
+
+    def encode(obj)
+      ActiveSupport::JSON.encode(obj)
+    end
+
+    def encoded_size(str)
+      encode(str).bytesize - 2
+    end
+end

data/lib/apn/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module APN
-  VERSION = "2.0.2"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apn_sender
 version: !ruby/object:Gem::Version
-  version: 2.0.2
-  prerelease: 
+  version: 2.1.0
 platform: ruby
 authors:
 - Kali Donovan
@@ -14,40 +13,52 @@ date: 2011-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
-  requirement: &1 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *1
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
     - - "<"
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: '5'
   type: :runtime
   prerelease: false
-  version_requirements: *2
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: daemons
-  requirement: &3 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *3
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Background worker to send Apple Push Notifications over a persistent
   TCP socket. Includes Resque tweaks to allow persistent sockets between jobs, helper
   methods for enqueueing APN notifications, and a background daemon to send them.
@@ -56,49 +67,47 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/apn.rb
+- lib/apn/application.rb
+- lib/apn/backend.rb
 - lib/apn/backend/resque.rb
 - lib/apn/backend/sidekiq.rb
-- lib/apn/backend.rb
 - lib/apn/client.rb
 - lib/apn/connection.rb
 - lib/apn/feedback.rb
 - lib/apn/jobs/resque_notification_job.rb
 - lib/apn/jobs/sidekiq_notification_job.rb
+- lib/apn/multiple_apps.rb
 - lib/apn/notification.rb
+- lib/apn/payload.rb
 - lib/apn/railtie.rb
 - lib/apn/sender_daemon.rb
 - lib/apn/tasks.rb
 - lib/apn/version.rb
-- lib/apn.rb
 - lib/apn_sender.rb
-- CHANGELOG.md
-- LICENSE
-- README.md
-- Rakefile
 homepage: http://github.com/arthurnn/apn_sender
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '1.9'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.5.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Background worker to send Apple Push Notifications over a persistent TCP
   socket.
 test_files: []

data/CHANGELOG.md

@@ -1,28 +0,0 @@
-# Version 2.0
-## 2.0.2
-- Add default file so we dont need to require 'apn' anymore
-- Change backend switch:
-  Use simple backend per default, also allow changes.
-  Now you can change the backend using:
-        APN.backend = :sidekiq
-
-## 2.0.1
-- Use bytesize to truncate alert when necessary
-- Better calculation on payload size. (botvinik)
-- Fix generating payload should use bytesize. (piotr-sokolowski)
-- Rescuing and repairing broken connections (Arseniy Ivanov)
-
-## 2.0.0
-- adding connection_pool for handle apple sockets
-- removing resque hard dependency
-- adding support for sending sync messages
-- adding Thread support
-- adding support to sidekiq (Caue Guerra)
-- truncation messages when payload is greater than 256 option (Caue Guerra)
-
-# Version 1.0
-## 1.0.6
-- Added support for password-protected .pem files
-- Read feedback data in 38-byte chunks
-- Support passing dictionary as :alert key
-- Logging to STDOUT if no other loggers present

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2013 Arthur Nogueira Neves
-
-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

@@ -1,151 +0,0 @@
-[![Code Climate](http://img.shields.io/codeclimate/github/arthurnn/apn_sender.svg)](https://codeclimate.com/github/arthurnn/apn_sender)
-[![Build Status](https://travis-ci.org/arthurnn/apn_sender.svg?branch=master)](https://travis-ci.org/arthurnn/apn_sender)
-
-## Synopsis
-
-Need to send background notifications to an iPhone application over a <em>persistent</em> connection in Ruby? Keep reading...
-
-## The Story
-
-So you're building the server component of an iPhone application in Ruby and you want to send background notifications through the Apple Push Notification servers. This doesn't seem too bad at first, but then you read in the [Apple Documentation](https://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Introduction.html) that Apple's servers may treat non-persistent connections as a Denial of Service attack. Since Rails has no easy way to maintain a persistent connection internally, things start to look complicated.
-
-This gem includes a background daemon which processes background messages from your application and sends them along to Apple <em>over a single, persistent socket</em>.  It also includes the ability to query the Feedback service, helper methods for enqueueing your jobs, and a sample monit config to make sure the background worker is around when you need it.
-
-## Yet another ApplePushNotification interface?
-
-Yup.  There's some great code out there already, but we didn't like the idea of getting banned from the APN gateway for establishing a new connection each time we needed to send a batch of messages, and none of the libraries I found handled maintaining a persistent connection.
-
-## Current Status
-
-This gem has been used in production, on [500px](http://500px.com), sending hundreds of millions, if not, billions of notifications.
-
-## Usage
-
-APN sender can use [Resque](http://github.com/defunkt/resque) or [Sidekiq](https://github.com/mperham/sidekiq) to send asynchronous messages, if none of them are installed it creates a new thread to send messages.
-
-### 1. Use a background processor or not.
-
-You can either use Resque or Sidekiq, I strongly advice using Sidekiq, as apn_sender uses a connection pool for the apple socks. To use apn_sender with one of them you dont have to do anything, just include the background processor gem into your gemfile and it will all work. 
-
-### 2. Queueing Messages From Your Application
-
-To queue a message for sending through Apple's Push Notification service from your Rails application:
-
-```
-APN.notify_async(token, opts_hash)
-```
-
-Where ```token``` is the unique identifier of the iPhone to receive the notification and ```opts_hash``` can have any of the following keys:
-
-* :alert  ## The alert to send
-* :badge  ## The badge number to send
-* :sound  ## The sound file to play on receipt, or true to play the default sound installed with your app
-
-If any other keys are present they'll be be passed along as custom data to your application.
-
-### 3. Sending Queued Messages
-
-Put your ```apn_development.pem``` and ```apn_production.pem``` certificates from Apple in your ```RAILS_ROOT/config/certs``` directory.
-
-You also can configure some extra settings:
-
-```
-APN.root = 'RAILS_ROOT/config/certs' # root to certificates folder
-APN.certificate_name = 'apn_production.pem' # certificate filename
-APN.host = 'apple host (on development sandbox url is used by default)'
-APN.password = 'certificate_password'
-APN.pool_size = 1 # number of connections on the pool
-APN.pool_timeout = 5 # timeout in seconds for connection pool
-APN.logger = Logger.new(File.join(Rails.root, 'log', 'apn_sender.log'))
-```
-
-Check ```logs/apn_sender.log``` for debugging output.  In addition to logging any major errors there, apn_sender hooks into the Resque::Worker logging to display any verbose or very_verbose worker output in apn_sender.log file as well.
-On latest versions apn_sender will use Rails.logger as the default logger.
-
-
-### 4. Checking Apple's Feedback Service
-
-Since push notifications are a fire-and-forget sorta deal, where you get no indication if your message was received (or if the specified recipient even exists), Apple needed to come up with some other way to ensure their network isn't clogged with thousands of bogus messages (e.g. from developers sending messages to phones where their application <em>used</em> to be installed, but where the user has since removed it).  Hence, the Feedback Service.
-
-It's actually really simple - you connect to them periodically and they give you a big dump of tokens you shouldn't send to anymore.  The gem wraps this up nicely -- just call:
-
-```
- # APN::Feedback accepts the same optional :environment
- # and :cert_path / :full_cert_path options as APN::Sender
- feedback = APN::Feedback.new()
-
- tokens = feedback.tokens # Array of device tokens
- tokens.each do |token|
-   # ... custom logic here to stop you app from
-   # sending further notifications to this token
- end
-```
-
-If you're interested in knowing exactly <em>when</em> Apple determined each token was expired (which can be useful in determining if the application re-registered with your service since it first appeared in the expired queue):
-
-```
- items = feedback.data # Array of APN::FeedbackItem elements
- items.each do |item|
-   item.token
-   item.timestamp
-   # ... custom logic here
- end
-```
-
-The Feedback Service works as a big queue.  When you connect it pops off all its data and sends it over the wire at once, which means connecting a second time will return an empty array, so for ease of use a call to either +tokens+ or +data+ will connect once and cache the data.  If you call either one again it'll continue to use its cached version (rather than connecting to Apple a second time to retrieve an empty array, which is probably not what you want).
-
-Forcing a reconnect is as easy as calling either method with the single parameter +true+, but be sure you've already used the existing data because you'll never get it back.
-
-
-#### Warning: No really, check Apple's Feedback Service occasionally
-
-If you're sending notifications, you should definitely call one of the ```receive``` methods periodically, as Apple's policies require it and they apparently monitor providers for compliance.  I'd definitely recommend throwing together a quick rake task to take care of this for you (the [whenever library](http://github.com/javan/whenever) provides a nice wrapper around scheduling tasks to run at certain times (for systems with cron enabled)).
-
-Just for the record, this is essentially what you want to have whenever run periodically for you:
-```
-def self.clear_uninstalled_applications
-  feedback_data = APN::Feedback.new(:environment #> :production).data
-
-  feedback_data.each do |item|
-    user = User.find_by_iphone_token( item.token )
-
-    if user.iphone_token_updated_at && user.iphone_token_updated_at > item.timestamp
-      return true # App has been reregistered since Apple determined it'd been uninstalled
-    else
-      user.update_attributes(iphone_token: nil, iphone_token_updated_at: Time.now)
-    end
-  end
-end
-```
-
-
-### Keeping Your Workers Working
-
-There's also an included sample ```apn_sender.monitrc``` file in the ```contrib/``` folder to help monit handle server restarts and unexpected disasters.
-
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'apn_sender', require: 'apn'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install apn_sender
-
-To add a few useful rake tasks for running workers, add the following line to your Rakefile:
-
-```
-  require 'apn/tasks'
-```
-
-## License
-
-APN Sender is released under the [MIT License](http://www.opensource.org/licenses/MIT).
-
-

data/Rakefile

@@ -1,35 +0,0 @@
-require "bundler"
-Bundler.setup
-
-require "rake"
-require "rspec/core/rake_task"
-
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "apn/version"
-
-task :gem => :build
-task :build do
-  system "gem build apn_sender.gemspec"
-end
-
-task :install => :build do
-  system "gem install apn_sender-#{APN::VERSION}.gem"
-end
-
-task :release => :build do
-  system "git tag -a v#{APN::VERSION} -m 'Tagging #{APN::VERSION}'"
-  system "git push --tags"
-  system "gem push apn_sender-#{APN::VERSION}.gem"
-  system "rm apn_sender-#{APN::VERSION}.gem"
-end
-
-RSpec::Core::RakeTask.new("spec") do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
-end
-
-RSpec::Core::RakeTask.new('spec:progress') do |spec|
-  spec.rspec_opts = %w(--format progress)
-  spec.pattern = "spec/**/*_spec.rb"
-end
-
-task :default => :spec