zeppelin 0.1.0

data/.autotest

@@ -0,0 +1,15 @@
+Autotest.add_hook :initialize do |at|
+  # Requires bundler before minitest since the minitest bundled with Ruby does
+  # not support runners.
+  at.testlib = 'bundler/setup minitest/unit'
+  
+  # Mappings from http://opensoul.org/blog/archives/2008/08/22/autotest-mapping-for-rails-test-conventions/.
+  at.clear_mappings
+  
+  at.add_mapping %r%/^lib/(.*)\.rb$% do |_, m|
+    possible = File.basename(m[1])
+    files_matching %r%^test/.*(#{possible}_test|test_#{possible})\.rb$%
+  end
+  
+  at.add_mapping(%r%^test/.*\.rb$%) { |filename, _| filename }
+end

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# Gem-specific
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+script: 'rake test'
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ree
+  - jruby

data/.yardopts

@@ -0,0 +1,6 @@
+--readme          README.md
+--markup          markdown
+--markup-provider maruku
+--default-return  ""
+--title           "Zeppelin Documentation"
+--hide-void-return

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Alexander Kern
+
+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,47 @@
+# zeppelin - Urban Airship library for Ruby [![StillMaintained Status](http://stillmaintained.com/CapnKernul/zeppelin.png)](http://stillmaintained.com/CapnKernul/zeppelin) [![Build Status](http://travis-ci.org/CapnKernul/zeppelin.png)](http://travis-ci.org/CapnKernul/zeppelin) #
+
+Ruby client for the [Urban Airship](http://urbanairship.com) Push Notification
+API.
+
+## Installation ##
+
+Without bundler:
+
+    gem install zeppelin
+
+With bundler:
+
+    gem 'zeppelin'
+
+## Usage ##
+
+    # First, create a client.
+    client = Zeppelin.new('your app key', 'your app master secret')
+    
+    # You can then use the client to push messages to Urban Airship. The options
+    # for push are converted to JSON and sent as the payload.
+    client.push(:device_tokens => ['devtoken'], :aps => { :badge => 10 })
+
+Check out the docs for more ways of querying the API.
+
+## TODO ##
+
+* Add support for the statistics API.
+* Add support for the device token list API.
+
+## Note on Patches/Pull Requests ##
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, but do not mess with the `Rakefile`. If you want to have your own version, that is fine but bump the version in a commit by itself in another branch so I can ignore it when I pull.
+* Send me a pull request. Bonus points for git flow feature branches.
+
+## Resources ##
+
+* [GitHub Repository](https://github.com/CapnKernul/zeppelin)
+* [Documentation](http://rubydoc.info/github/CapnKernul/zeppelin)
+
+## License ##
+
+Zeppelin is licensed under the MIT License. See `LICENSE` for details.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => 'test'
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.ruby_opts += ['-rubygems']
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end

data/lib/zeppelin/version.rb

@@ -0,0 +1,3 @@
+class Zeppelin
+  VERSION = '0.1.0'
+end

data/lib/zeppelin.rb

@@ -0,0 +1,123 @@
+require 'faraday'
+require 'yajl'
+require 'time'
+
+# A very tiny Urban Airship Push Notification API client.
+# 
+# Provides thin wrappers around API calls to the most common API tasks. For more
+# information on how the requests and responses are formatted, visit the [Urban
+# Airship Push Notification API docs](http://urbanairship.com/docs/push.html).
+class Zeppelin
+  BASE_URI = 'https://go.urbanairship.com'
+  PUSH_URI = '/api/push/'
+  BATCH_PUSH_URI = '/api/push/batch/'
+  BROADCAST_URI = '/api/push/broadcast/'
+  SUCCESSFUL_STATUS_CODES = (200..299)
+  JSON_HEADERS = { 'Content-Type' => 'application/json' }
+  
+  # The connection to `https://go.urbanairship.com`.
+  attr_reader :connection
+  
+  # Creates a new client.
+  # 
+  # @param [String] application_key your Urban Airship Application Key
+  # @param [String] application_master_secret your Urban Airship Application
+  #   Master Secret
+  def initialize(application_key, application_master_secret)
+    @connection = Faraday::Connection.new(BASE_URI) do |builder|
+      builder.request :json
+      builder.adapter :net_http
+    end
+    
+    @connection.basic_auth(application_key, application_master_secret)
+  end
+  
+  # Registers a device token.
+  # 
+  # @param [String] device_token
+  # @param [Hash] payload the payload to send during registration
+  # @return [Boolean] whether or not the registration was successful
+  def register_device_token(device_token, payload = {})
+    uri = device_token_uri(device_token)
+    
+    if payload.empty?
+      response = @connection.put(uri)
+    else
+      response = @connection.put(uri, payload, JSON_HEADERS)
+    end
+    
+    successful?(response)
+  end
+  
+  # Retrieves information on a device token.
+  # 
+  # @param [String] device_token
+  # @return [Hash, nil]
+  def device_token(device_token)
+    response = @connection.get(device_token_uri(device_token))
+    successful?(response) ? Yajl::Parser.parse(response.body) : nil
+  end
+  
+  # Deletes a device token.
+  # 
+  # @param [String] device_token
+  # @return [Boolean] whether or not the deletion was successful
+  def delete_device_token(device_token)
+    response = @connection.delete(device_token_uri(device_token))
+    successful?(response)
+  end
+  
+  # Pushes a message.
+  # 
+  # @param [Hash] payload the payload of the message
+  # @return [Boolean] whether or not pushing the message was successful
+  def push(payload)
+    response = @connection.post(PUSH_URI, payload, JSON_HEADERS)
+    successful?(response)
+  end
+  
+  # Batch pushes multiple messages.
+  # 
+  # @param [<Hash>] payload the payloads of each message
+  # @return [Boolean] whether or not pushing the messages was successful
+  def batch_push(*payload)
+    response = @connection.post(BATCH_PUSH_URI, payload, JSON_HEADERS)
+    successful?(response)
+  end
+  
+  # Broadcasts a message.
+  # 
+  # @param [Hash] payload the payload of the message
+  # @return [Boolean] whether or not broadcasting the message was successful
+  def broadcast(payload)
+    response = @connection.post(BROADCAST_URI, payload, JSON_HEADERS)
+    successful?(response)
+  end
+  
+  # Retrieves feedback on device tokens.
+  # 
+  # This is useful for removing inactive device tokens for the database.
+  # 
+  # @param [Time] since the time to retrieve inactive tokens from
+  # @return [Hash, nil]
+  def feedback(since)
+    response = @connection.get(feedback_uri(since))
+    successful?(response) ? Yajl::Parser.parse(response.body) : nil
+  end
+  
+  private
+  
+  def device_token_uri(device_token)
+    "/api/device_tokens/#{device_token}"
+  end
+  
+  def feedback_uri(since)
+    "/api/device_tokens/feedback/?since=#{since.utc.iso8601}"
+  end
+  
+  def successful?(response)
+    SUCCESSFUL_STATUS_CODES.include?(response.status)
+  end
+end
+
+require 'zeppelin/version'

data/test/support/spec_reporter.rb

@@ -0,0 +1,222 @@
+require 'minitest/unit'
+require 'ansi'
+
+# Code for this runner has been borrowed and modified from MiniTest, written by
+# Ryan Davis of Seattle.rb. MiniTest is licensed under the MIT License, and can
+# be found on GitHub at https://github.com/seattlerb/minitest.
+# 
+# This code is also heavily based upon these gists as well, which don't appear
+# to have a license:
+# * https://gist.github.com/356945
+# * https://gist.github.com/960669
+# 
+# @abstract
+# @todo Add documentation to everything.
+module MiniTest
+  class Reporter
+    attr_accessor :runner
+    
+    def print(*args)
+      runner.output.print(*args)
+    end
+    
+    def puts(*args)
+      runner.output.puts(*args)
+    end
+    
+    def before_suites(suites); end
+    def after_suites(suites); end
+    def before_suite(suite); end
+    def after_suite(suite); end
+    def before_test(suite, test); end
+    def pass(suite, test); end
+    def skip(suite, test, e); end
+    def failure(suite, test, e); end
+    def error(suite, test, e); end
+  end
+end
+
+module MiniTest
+  class SpecReporter < Reporter
+    include ANSI::Code
+    
+    TEST_PADDING = 2
+    INFO_PADDING = 8
+    MARK_SIZE    = 5
+    
+    def before_suites(suites)
+      @suites_start_time = Time.now
+      puts 'Started'
+      puts
+    end
+    
+    def after_suites(suites)
+      total_time = Time.now - @suites_start_time
+      
+      puts('Finished in %.5fs' % total_time)
+      print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
+      print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
+      print(yellow { '%d skips' } % runner.skips)
+      puts
+    end
+    
+    def before_suite(suite)
+      puts suite
+    end
+    
+    def after_suite(suite)
+      puts
+    end
+    
+    def before_test(suite, test)
+      @test_start_time = Time.now
+    end
+    
+    def pass(suite, test)
+      print(green { pad_mark('PASS') })
+      print_test_with_time(test)
+      puts
+    end
+    
+    def skip(suite, test, e)
+      print(yellow { pad_mark('SKIP') })
+      print_test_with_time(test)
+      puts
+    end
+    
+    def failure(suite, test, e)
+      print(red { pad_mark('FAIL') })
+      print_test_with_time(test)
+      puts
+      print_info(e)
+      puts
+    end
+    
+    def error(suite, test, e)
+      print(red { pad_mark('ERROR') })
+      print_test_with_time(test)
+      puts
+      print_info(e)
+      puts
+    end
+    
+    private
+    
+    def print_test_with_time(test)
+      total_time = Time.now - @test_start_time
+      print(" #{test} (%.2fs)" % total_time)
+    end
+    
+    def print_info(e)
+      e.message.each_line { |line| puts pad(line, INFO_PADDING) }
+      
+      trace = MiniTest.filter_backtrace(e.backtrace)
+      trace.each { |line| puts pad(line, INFO_PADDING) }
+    end
+    
+    def pad(str, size)
+      ' ' * size + str
+    end
+    
+    def pad_mark(str)
+      pad("%#{MARK_SIZE}s" % str, TEST_PADDING)
+    end
+  end
+end
+
+module MiniTest
+  class RunnerWithReporter < Unit
+    def initialize(new_reporter)
+      super()
+      @reporter = new_reporter
+      @reporter.runner = self
+    end
+    
+    def puke(suite, method, e)
+      case e
+      when MiniTest::Skip then
+        @skips += 1
+        [:skip, e]
+      when MiniTest::Assertion then
+        @failures += 1
+        [:failure, e]
+      else
+        @errors += 1
+        [:error, e]
+      end
+    end
+    
+    def _run_anything(type)
+      @test_count = @assertion_count = 0
+      suites = TestCase.send("#{type}_suites")
+      return if suites.empty?
+      
+      @reporter.before_suites(suites)
+      
+      sync = output.respond_to?(:'sync=') # stupid emacs
+      old_sync, output.sync = output.sync, true if sync
+      _run_suites(suites, type)
+      output.sync = old_sync if sync
+      
+      @reporter.after_suites(suites)
+    end
+    
+    def _run_suites(suites, type)
+      suites.map { |suite| _run_suite(suite, type) }
+    end
+    
+    def _run_suite(suite, type)
+      run_suite_header(suite, type)
+      
+      filter = options[:filter] || '/./'
+      filter = Regexp.new($1) if filter =~ /\/(.*)\//
+      
+      tests = suite.send("#{type}_methods").grep(filter)
+      
+      unless tests.empty?
+        @reporter.before_suite(suite)
+        run_suite_tests(suite, tests)
+        @reporter.after_suite(suite)
+      end
+    end
+    
+    private
+    
+    def run_suite_header(suite, type)
+      header_method = "#{type}_suite_header"
+      send(header_method, suite) if respond_to?(header_method)
+    end
+    
+    def run_suite_tests(suite, tests)
+      suite.startup if suite.respond_to?(:startup)
+      
+      tests.each do |test|
+        @reporter.before_test(suite, test)
+        response, e = run_suite_test(suite, test)
+        
+        case response
+        when :pass then @reporter.pass(suite, test)
+        when :skip then @reporter.skip(suite, test, e)
+        when :failure then @reporter.failure(suite, test, e)
+        else @reporter.error(suite, test, e)
+        end
+      end
+    ensure
+      suite.shutdown if suite.respond_to?(:shutdown)
+    end
+    
+    def run_suite_test(suite, test)
+      suite_instance = suite.new(test)
+      suite_instance._assertions = 0
+      
+      result = suite_instance.run(self)
+      
+      @test_count += 1
+      @assertion_count += suite_instance._assertions
+      
+      result == '.' ? :pass : result
+    end
+  end
+end
+
+MiniTest::Unit.runner = MiniTest::RunnerWithReporter.new(MiniTest::SpecReporter.new)

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'mocha'
+require 'test_declarative'
+require 'zeppelin'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+class Zeppelin::TestCase < MiniTest::Unit::TestCase; end

data/test/zeppelin_test.rb

@@ -0,0 +1,232 @@
+require 'test_helper'
+
+class ZeppelinTest < Zeppelin::TestCase
+  def setup
+    @client = Zeppelin.new('app key', 'app master secret')
+    @device_token = '1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF'
+  end
+  
+  test '#connection' do
+    assert_instance_of Faraday::Connection, @client.connection
+    assert_equal 'https', @client.connection.scheme
+    assert_equal 'go.urbanairship.com', @client.connection.host
+    assert_includes @client.connection.builder.handlers, Faraday::Adapter::NetHttp
+    assert_includes @client.connection.builder.handlers, Faraday::Request::JSON
+    assert_equal 'Basic YXBwIGtleTphcHAgbWFzdGVyIHNlY3JldA==', @client.connection.headers['Authorization']
+  end
+  
+  test '#register_device_token without a payload' do
+    stub_requests @client.connection do |stub|
+      stub.put("/api/device_tokens/#{@device_token}") do [201, {}, '']
+      end
+    end
+    
+    response = @client.register_device_token(@device_token)
+    assert response
+  end
+  
+  test '#register_device_token an already registered device token' do
+    stub_requests @client.connection do |stub|
+      stub.put("/api/device_tokens/#{@device_token}") do
+        [200, {}, '']
+      end
+    end
+    
+    response = @client.register_device_token(@device_token)
+    assert response
+  end
+  
+  test '#register_device_token with payload' do
+    payload = { :alias => 'CapnKernul' }
+    
+    stub_requests @client.connection do |stub|
+      stub.put("/api/device_tokens/#{@device_token}", Yajl::Encoder.encode(payload)) do
+        [200, {}, '']
+      end
+    end
+    
+    response = @client.register_device_token(@device_token, payload)
+    assert response
+  end
+  
+  test '#register_device_token with an error' do
+    stub_requests @client.connection do |stub|
+      stub.put("/api/device_tokens/#{@device_token}", nil) do
+        [500, {}, '']
+      end
+    end
+    
+    response = @client.register_device_token(@device_token)
+    refute response
+  end
+  
+  test '#device_token with valid device token' do
+    response_body = { 'foo' => 'bar' }
+    stub_requests @client.connection do |stub|
+      stub.get("/api/device_tokens/#{@device_token}") do
+        [200, {}, Yajl::Encoder.encode(response_body)]
+      end
+    end
+    
+    response = @client.device_token(@device_token)
+    assert_equal response_body, response
+  end
+  
+  test '#device_token with an unknown device token' do
+    stub_requests @client.connection do |stub|
+      stub.get("/api/device_tokens/#{@device_token}") do
+        [404, {}, '']
+      end
+    end
+    
+    response = @client.device_token(@device_token)
+    assert_nil response
+  end
+  
+  test '#delete_device_token with a valid device token' do
+    stub_requests @client.connection do |stub|
+      stub.delete("/api/device_tokens/#{@device_token}") do
+        [204, {}, '']
+      end
+    end
+    
+    response = @client.delete_device_token(@device_token)
+    assert response
+  end
+  
+  test '#delete_device_token with an unknown device token' do
+    stub_requests @client.connection do |stub|
+      stub.delete("/api/device_tokens/#{@device_token}") do
+        [404, {}, '']
+      end
+    end
+    
+    response = @client.delete_device_token(@device_token)
+    refute response
+  end
+  
+  test '#push with a valid payload' do
+    payload = {
+      :device_tokens => [@device_token],
+      :aps => { :alert => 'Hello from Urban Airship!' }
+    }
+    
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/', Yajl::Encoder.encode(payload)) do
+        [200, {}, '']
+      end
+    end
+    
+    response = @client.push(payload)
+    assert response
+  end
+  
+  # Although the Urban Airship documentation states that a 400 Status Code
+  # will be sent when there's an invalid payload, it doesn't state what
+  # constitutes an invalid payload. Hence, I'm just mocking out the request so
+  # that it returns a 400.
+  test '#push with an invalid payload' do
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/', '{}') do
+        [400, {}, '']
+      end
+    end
+    
+    response = @client.push({})
+    refute response
+  end
+  
+  test '#batch_push with a valid payload' do
+    message1 = {
+      :device_tokens => [@device_token],
+      :aps => { :alert => 'Hello from Urban Airship!' }
+    }
+    
+    message2 = {
+      :device_tokens => [],
+      :aps => { :alert => 'Yet another hello from Urban Airship!' }
+    }
+    
+    payload = [message1, message2]
+    
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/batch/', Yajl::Encoder.encode(payload)) do
+        [200, {}, '']
+      end
+    end
+    
+    response = @client.batch_push(message1, message2)
+    assert response
+  end
+  
+  # See the note above for why this test exists.
+  test '#batch_push with an invalid payload' do
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/batch/', '[{},{}]') do
+        [400, {}, '']
+      end
+    end
+    
+    response = @client.batch_push({}, {})
+    refute response
+  end
+  
+  test '#broadcast with a valid payload' do
+    payload = {
+      :aps => { :alert => 'Hello from Urban Airship!' }
+    }
+    
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/broadcast/', Yajl::Encoder.encode(payload)) do
+        [200, {}, '']
+      end
+    end
+    
+    response = @client.broadcast(payload)
+    assert response
+  end
+  
+  # See the note above for why this test exists.
+  test '#broadcast with an invalid payload' do
+    stub_requests @client.connection do |stub|
+      stub.post('/api/push/broadcast/', '{}') do
+        [400, {}, '']
+      end
+    end
+    
+    response = @client.broadcast({})
+    refute response
+  end
+  
+  test '#feedback with a valid since' do
+    response_body = { 'foo' => 'bar' }
+    since = Time.at(0)
+    
+    stub_requests @client.connection do |stub|
+      stub.get('/api/device_tokens/feedback/?since=1970-01-01T00%3A00%3A00Z') do
+        [200, {}, Yajl::Encoder.encode(response_body)]
+      end
+    end
+    
+    response = @client.feedback(since)
+    assert_equal response_body, response
+  end
+  
+  test '#feedback with an error' do
+    since = Time.at(0)
+    
+    stub_requests @client.connection do |stub|
+      stub.get('/api/device_tokens/feedback/?since=1970-01-01T00%3A00%3A00Z') do
+        [400, {}, '']
+      end
+    end
+    
+    response = @client.feedback(since)
+    assert_nil response
+  end
+  
+  def stub_requests(connection, &block)
+    connection.builder.handlers.delete(Faraday::Adapter::NetHttp)
+    connection.adapter(:test, &block)
+  end
+end

data/zeppelin.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'zeppelin/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'zeppelin'
+  s.version     = Zeppelin::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Alexander Kern']
+  s.email       = ['alex@kernul.com']
+  s.homepage    = 'https://github.com/CapnKernul/zeppelin'
+  s.summary     = %q{Urban Airship library for Ruby}
+  s.description = %q{Ruby client for the Urban Airship Push Notification API}
+  
+  s.rubyforge_project = 'zeppelin'
+  
+  s.add_dependency 'faraday'
+  s.add_dependency 'yajl-ruby'
+  
+  s.add_development_dependency 'ansi'
+  s.add_development_dependency 'minitest', '~> 2.0'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'test_declarative'
+  
+  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']
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: zeppelin
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Alexander Kern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: ansi
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: test_declarative
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+description: Ruby client for the Urban Airship Push Notification API
+email: 
+- alex@kernul.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- .travis.yml
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/zeppelin.rb
+- lib/zeppelin/version.rb
+- test/support/spec_reporter.rb
+- test/test_helper.rb
+- test/zeppelin_test.rb
+- zeppelin.gemspec
+has_rdoc: true
+homepage: https://github.com/CapnKernul/zeppelin
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: zeppelin
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Urban Airship library for Ruby
+test_files: 
+- test/support/spec_reporter.rb
+- test/test_helper.rb
+- test/zeppelin_test.rb