urbanairship 2.1.2 → 2.2.0

data/README.markdown

@@ -161,3 +161,27 @@ response.success? # => false
 response.code # => '503'
 response.inspect # => "{\"error\"=>\"Request timeout\"}"
 ```
+
+Instantiating an Urbanairship::Client
+-------------------------------------
+
+Anything you can do directly with the Urbanairship module, you can also do with a Client.
+
+```ruby
+client = Urbanairship::Client.new
+client.application_key = 'application-key'
+client.application_secret = 'application-secret'
+client.register_device('DEVICE-TOKEN')
+notification = {
+  :schedule_for => [1.hour.from_now],
+  :device_tokens => ['DEVICE-TOKEN'],
+  :aps => {:alert => 'You have a new message!', :badge => 1}
+}
+
+client.push(notification) # =>
+# {
+#   "scheduled_notifications" => ["https://go.urbanairship.com/api/push/scheduled/123456"]
+# }
+```
+
+This can be used to use clients for different Urbanairship applications in a thread-safe manner.

data/lib/urbanairship.rb

@@ -13,7 +13,7 @@ module Urbanairship
     Timer = Timeout
   end
 
-  class << self
+  module ClassMethods
     attr_accessor :application_key, :application_secret, :master_secret, :logger, :request_timeout, :provider
 
     def register_device(device_token, options = {})
@@ -128,4 +128,12 @@ module Urbanairship
       @request_timeout || 5.0
     end
   end
+
+  class << self
+    include ClassMethods
+  end
+
+  class Client
+    include ClassMethods
+  end
 end

data/spec/urbanairship_spec.rb

@@ -1,4 +1,4 @@
-describe Urbanairship do
+shared_examples_for "an Urbanairship client" do
   before(:all) do
     FakeWeb.allow_net_connect = false
 
@@ -39,139 +39,139 @@ describe Urbanairship do
 
   describe "configuration" do
     it "enables you to configure the application key" do
-      Urbanairship.application_key.should be_nil
-      Urbanairship.application_key = "asdf1234"
-      Urbanairship.application_key.should == "asdf1234"
+      subject.application_key.should be_nil
+      subject.application_key = "asdf1234"
+      subject.application_key.should == "asdf1234"
     end
 
     it "enables you to configure the application secret" do
-      Urbanairship.application_secret.should be_nil
-      Urbanairship.application_secret = "asdf1234"
-      Urbanairship.application_secret.should == "asdf1234"
+      subject.application_secret.should be_nil
+      subject.application_secret = "asdf1234"
+      subject.application_secret.should == "asdf1234"
     end
 
     it "enables you to configure the master secret" do
-      Urbanairship.master_secret.should be_nil
-      Urbanairship.master_secret = "asdf1234"
-      Urbanairship.master_secret.should == "asdf1234"
+      subject.master_secret.should be_nil
+      subject.master_secret = "asdf1234"
+      subject.master_secret.should == "asdf1234"
     end
   end
 
   describe "::register_device" do
     before(:each) do
       @valid_params = {:alias => 'one'}
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.application_secret = "my_app_secret"
+      subject.application_key = "my_app_key"
+      subject.application_secret = "my_app_secret"
     end
 
     it "raises an error if call is made without an app key and secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.application_secret = nil
+      subject.application_key = nil
+      subject.application_secret = nil
 
       lambda {
-        Urbanairship.register_device("asdf1234")
+        subject.register_device("asdf1234")
       }.should raise_error(RuntimeError, "Must configure application_key, application_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.register_device("new_device_token")
+      subject.register_device("new_device_token")
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_app_secret').chomp}"
     end
 
     it "takes and sends a device token" do
-      Urbanairship.register_device("new_device_token")
+      subject.register_device("new_device_token")
       FakeWeb.last_request.path.should == "/api/device_tokens/new_device_token"
     end
 
     it "returns true when the device is registered for the first time" do
-      Urbanairship.register_device("new_device_token").success?.should == true
+      subject.register_device("new_device_token").success?.should == true
     end
 
     it "returns true when the device is registered again" do
-      Urbanairship.register_device("existing_device_token").success?.should == true
+      subject.register_device("existing_device_token").success?.should == true
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.register_device("new_device_token").success?.should == false
+      subject.application_key = "bad_key"
+      subject.register_device("new_device_token").success?.should == false
     end
 
     it "accepts an alias" do
-      Urbanairship.register_device("device_token_one", @valid_params).success?.should == true
+      subject.register_device("device_token_one", @valid_params).success?.should == true
     end
 
     it "adds alias to the JSON payload" do
-      Urbanairship.register_device("device_token_one", @valid_params)
+      subject.register_device("device_token_one", @valid_params)
       request_json['alias'].should == "one"
     end
 
     it "converts alias param to string" do
-      Urbanairship.register_device("device_token_one", :alias => 11)
+      subject.register_device("device_token_one", :alias => 11)
       request_json['alias'].should be_a_kind_of String
     end
 
     it "uses the iOS interface by default" do
-      Urbanairship.register_device("new_device_token")
+      subject.register_device("new_device_token")
       FakeWeb.last_request.path.should == "/api/device_tokens/new_device_token"
     end
 
     it "uses the android interface if 'provider' configuration option is set to :android" do
-      Urbanairship.provider = :android
-      Urbanairship.register_device("new_device_token")
+      subject.provider = :android
+      subject.register_device("new_device_token")
       FakeWeb.last_request.path.should == "/api/apids/new_device_token"
-      Urbanairship.provider = nil
+      subject.provider = nil
     end
 
     it "uses the android interface if 'provider' option is passed as :android" do
-      Urbanairship.register_device("new_device_token", :provider => :android)
+      subject.register_device("new_device_token", :provider => :android)
       FakeWeb.last_request.path.should == "/api/apids/new_device_token"
     end
   end
 
   describe "::unregister_device" do
     before(:each) do
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.application_secret = "my_app_secret"
+      subject.application_key = "my_app_key"
+      subject.application_secret = "my_app_secret"
     end
 
     it "raises an error if call is made without an app key and secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.application_secret = nil
+      subject.application_key = nil
+      subject.application_secret = nil
 
       lambda {
-        Urbanairship.unregister_device("asdf1234")
+        subject.unregister_device("asdf1234")
       }.should raise_error(RuntimeError, "Must configure application_key, application_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.unregister_device("key_to_delete")
+      subject.unregister_device("key_to_delete")
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_app_secret').chomp}"
     end
 
     it "sends the key that needs to be deleted" do
-      Urbanairship.unregister_device("key_to_delete")
+      subject.unregister_device("key_to_delete")
       FakeWeb.last_request.path.should == "/api/device_tokens/key_to_delete"
     end
 
     it "returns true when the device is successfully unregistered" do
-      Urbanairship.unregister_device("key_to_delete").success?.should == true
+      subject.unregister_device("key_to_delete").success?.should == true
       FakeWeb.last_request.body.should be_nil
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.unregister_device("key_to_delete").success?.should == false
+      subject.application_key = "bad_key"
+      subject.unregister_device("key_to_delete").success?.should == false
     end
 
     it "uses the android interface if 'provider' configuration option is set to :android" do
-      Urbanairship.provider = :android
-      Urbanairship.unregister_device("new_device_token")
+      subject.provider = :android
+      subject.unregister_device("new_device_token")
       FakeWeb.last_request.path.should == "/api/apids/new_device_token"
-      Urbanairship.provider = nil
+      subject.provider = nil
     end
 
     it "uses the android interface if 'provider' option is passed as :android" do
-      Urbanairship.unregister_device("new_device_token", :provider => :android)
+      subject.unregister_device("new_device_token", :provider => :android)
       FakeWeb.last_request.path.should == "/api/apids/new_device_token"
     end
 
@@ -179,95 +179,95 @@ describe Urbanairship do
 
   describe "::delete_scheduled_push" do
     before(:each) do
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.master_secret = "my_master_secret"
+      subject.application_key = "my_app_key"
+      subject.master_secret = "my_master_secret"
     end
 
     it "raises an error if call is made without an app key and master secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.master_secret = nil
+      subject.application_key = nil
+      subject.master_secret = nil
 
       lambda {
-        Urbanairship.delete_scheduled_push("123456789")
+        subject.delete_scheduled_push("123456789")
       }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.delete_scheduled_push("123456789")
+      subject.delete_scheduled_push("123456789")
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
     end
 
     it "sends the key that needs to be deleted" do
-      Urbanairship.delete_scheduled_push("123456789")
+      subject.delete_scheduled_push("123456789")
       FakeWeb.last_request.path.should == "/api/push/scheduled/123456789"
     end
 
     it "sends the key that needs to be deleted" do
-      Urbanairship.delete_scheduled_push(123456789)
+      subject.delete_scheduled_push(123456789)
       FakeWeb.last_request.path.should == "/api/push/scheduled/123456789"
     end
 
     it "sends the alias that needs to be deleted" do
-      Urbanairship.delete_scheduled_push(:alias => "alias_to_delete")
+      subject.delete_scheduled_push(:alias => "alias_to_delete")
       FakeWeb.last_request.path.should == "/api/push/scheduled/alias/alias_to_delete"
     end
 
     it "returns true when the push notification is successfully deleted" do
-      Urbanairship.delete_scheduled_push("123456789").success?.should == true
+      subject.delete_scheduled_push("123456789").success?.should == true
       FakeWeb.last_request.body.should be_nil
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.delete_scheduled_push("123456789").success?.should == false
+      subject.application_key = "bad_key"
+      subject.delete_scheduled_push("123456789").success?.should == false
     end
   end
 
   describe "::push" do
     before(:each) do
       @valid_params = {:device_tokens => ['device_token_one', 'device_token_two'], :aps => {:alert => 'foo'}}
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.master_secret = "my_master_secret"
+      subject.application_key = "my_app_key"
+      subject.master_secret = "my_master_secret"
     end
 
     it "raises an error if call is made without an app key and master secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.master_secret = nil
+      subject.application_key = nil
+      subject.master_secret = nil
 
       lambda {
-        Urbanairship.push(@valid_params)
+        subject.push(@valid_params)
       }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.push(@valid_params)
+      subject.push(@valid_params)
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
     end
 
     it "returns true when it successfully pushes a notification" do
-      Urbanairship.push(@valid_params).success?.should == true
+      subject.push(@valid_params).success?.should == true
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.push(@valid_params).success?.should == false
+      subject.application_key = "bad_key"
+      subject.push(@valid_params).success?.should == false
     end
 
     it "adds schedule_for to the JSON payload" do
       time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
-      Urbanairship.push(@valid_params.merge(:schedule_for => [time]))
+      subject.push(@valid_params.merge(:schedule_for => [time]))
       request_json['schedule_for'].should == ['2010-10-17T20:00:00Z']
     end
 
     it "only attempts to format schedule_for if it is a time object" do
-      Urbanairship.push(@valid_params.merge(:schedule_for => ["2010-10-10 09:09:09 UTC"]))
+      subject.push(@valid_params.merge(:schedule_for => ["2010-10-10 09:09:09 UTC"]))
       request_json['schedule_for'].should == ['2010-10-10T09:09:09Z']
     end
 
     it "returns false if urbanairship responds with a non-200 response" do
-      Urbanairship.application_key = "my_app_key2"
-      Urbanairship.master_secret = "my_master_secret2"
-      Urbanairship.push.success?.should == false
+      subject.application_key = "my_app_key2"
+      subject.master_secret = "my_master_secret2"
+      subject.push.success?.should == false
     end
   end
 
@@ -277,146 +277,146 @@ describe Urbanairship do
         {:device_tokens => ['device_token_one', 'device_token_two'], :aps => {:alert => 'foo'}},
         {:device_tokens => ['device_token_three', 'device_token_four'], :aps => {:alert => 'bar'}}
       ]
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.master_secret = "my_master_secret"
+      subject.application_key = "my_app_key"
+      subject.master_secret = "my_master_secret"
     end
 
     it "raises an error if call is made without an app key and master secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.master_secret = nil
+      subject.application_key = nil
+      subject.master_secret = nil
 
       lambda {
-        Urbanairship.batch_push(@valid_params)
+        subject.batch_push(@valid_params)
       }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.batch_push(@valid_params)
+      subject.batch_push(@valid_params)
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
     end
 
     it "returns true when it successfully pushes a notification" do
-      Urbanairship.batch_push(@valid_params).success?.should == true
+      subject.batch_push(@valid_params).success?.should == true
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.batch_push(@valid_params).success?.should == false
+      subject.application_key = "bad_key"
+      subject.batch_push(@valid_params).success?.should == false
     end
 
     it "adds schedule_for to the JSON payload" do
       time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
       @valid_params[0].merge!(:schedule_for => [time])
-      Urbanairship.batch_push(@valid_params)
+      subject.batch_push(@valid_params)
       request_json[0]['schedule_for'].should == ['2010-10-17T20:00:00Z']
     end
 
     it "accepts strings as schedule_for values" do
       @valid_params[0].merge!(:schedule_for => ["2010-10-10 09:09:09 UTC"])
-      Urbanairship.batch_push(@valid_params)
+      subject.batch_push(@valid_params)
       request_json[0]['schedule_for'].should == ['2010-10-10T09:09:09Z']
     end
 
     it "returns false if urbanairship responds with a non-200 response" do
-      Urbanairship.application_key = "my_app_key2"
-      Urbanairship.master_secret = "my_master_secret2"
-      Urbanairship.batch_push.success?.should == false
+      subject.application_key = "my_app_key2"
+      subject.master_secret = "my_master_secret2"
+      subject.batch_push.success?.should == false
     end
   end
 
   describe "::broadcast_push" do
     before(:each) do
       @valid_params = {:aps => {:alert => 'foo'}}
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.master_secret = "my_master_secret"
+      subject.application_key = "my_app_key"
+      subject.master_secret = "my_master_secret"
     end
 
     it "raises an error if call is made without an app key and master secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.master_secret = nil
+      subject.application_key = nil
+      subject.master_secret = nil
 
       lambda {
-        Urbanairship.broadcast_push(@valid_params)
+        subject.broadcast_push(@valid_params)
       }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.broadcast_push(@valid_params)
+      subject.broadcast_push(@valid_params)
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
     end
 
     it "returns true when it successfully pushes a notification" do
-      Urbanairship.broadcast_push(@valid_params).success?.should == true
+      subject.broadcast_push(@valid_params).success?.should == true
     end
 
     it "returns false when the authorization is invalid" do
-      Urbanairship.application_key = "bad_key"
-      Urbanairship.broadcast_push(@valid_params).success?.should == false
+      subject.application_key = "bad_key"
+      subject.broadcast_push(@valid_params).success?.should == false
     end
 
     it "adds schedule_for to the JSON payload" do
       time = Time.parse("Oct 17th, 2010, 8:00 PM UTC")
       @valid_params[:schedule_for] = [time]
-      Urbanairship.broadcast_push(@valid_params)
+      subject.broadcast_push(@valid_params)
       request_json['schedule_for'].should == ['2010-10-17T20:00:00Z']
     end
 
     it "accepts strings as schedule_for values" do
       @valid_params[:schedule_for] = ["2010-10-10 09:09:09 UTC"]
-      Urbanairship.broadcast_push(@valid_params)
+      subject.broadcast_push(@valid_params)
       request_json['schedule_for'].should == ['2010-10-10T09:09:09Z']
     end
 
     it "returns false if urbanairship responds with a non-200 response" do
-      Urbanairship.application_key = "my_app_key2"
-      Urbanairship.master_secret = "my_master_secret2"
-      Urbanairship.broadcast_push.success?.should == false
+      subject.application_key = "my_app_key2"
+      subject.master_secret = "my_master_secret2"
+      subject.broadcast_push.success?.should == false
     end
   end
 
   describe "::feedback" do
     before(:each) do
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.master_secret = "my_master_secret"
+      subject.application_key = "my_app_key"
+      subject.master_secret = "my_master_secret"
     end
 
     it "raises an error if call is made without an app key and master secret configured" do
-      Urbanairship.application_key = nil
-      Urbanairship.master_secret = nil
+      subject.application_key = nil
+      subject.master_secret = nil
 
       lambda {
-        Urbanairship.feedback(Time.now)
+        subject.feedback(Time.now)
       }.should raise_error(RuntimeError, "Must configure application_key, master_secret before making this request.")
     end
 
     it "uses app key and secret to sign the request" do
-      Urbanairship.feedback(Time.now)
+      subject.feedback(Time.now)
       FakeWeb.last_request['authorization'].should == "Basic #{Base64::encode64('my_app_key:my_master_secret').chomp}"
     end
 
     it "encodes the time argument in UTC, ISO 8601 format" do
       time = Time.parse("October 10, 2010, 8:00pm")
       formatted_time = time.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
-      Urbanairship.feedback(time)
+      subject.feedback(time)
       FakeWeb.last_request.path.should include(formatted_time)
     end
 
     it "accepts a string as the time argument" do
-      Urbanairship.feedback("Oct 07, 2010 8:00AM UTC")
+      subject.feedback("Oct 07, 2010 8:00AM UTC")
       FakeWeb.last_request.path.should include("2010-10-07T08:00:00Z")
     end
 
     it "returns an array of responses from the feedback API" do
-      response = Urbanairship.feedback(Time.now)
+      response = subject.feedback(Time.now)
       response[0].should include("device_token")
       response[0].should include("marked_inactive_on")
       response[0].should include("alias")
     end
 
     it "success? is false when the call doesn't return 200" do
-      Urbanairship.application_key = "my_app_key2"
-      Urbanairship.master_secret = "my_master_secret2"
-      Urbanairship.feedback(Time.now).success?.should == false
+      subject.application_key = "my_app_key2"
+      subject.master_secret = "my_master_secret2"
+      subject.feedback(Time.now).success?.should == false
     end
   end
 
@@ -424,54 +424,54 @@ describe Urbanairship do
 
     before(:each) do
       @logger = mock("logger", :info => true)
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.application_secret = "my_app_secret"
-      Urbanairship.master_secret = "my_master_secret"
-      Urbanairship.logger = @logger
+      subject.application_key = "my_app_key"
+      subject.application_secret = "my_app_secret"
+      subject.master_secret = "my_master_secret"
+      subject.logger = @logger
     end
 
     it "logs request and response information when registering a device" do
       @logger.should_receive(:info).with(/\/api\/device_tokens\/new_device_token/)
-      Urbanairship.register_device('new_device_token')
+      subject.register_device('new_device_token')
     end
 
     it "logs request and response information when sending push notifications" do
       @logger.should_receive(:info).with(/\/api\/push/)
-      Urbanairship.push(:device_tokens => ["device_token"], :aps => {:alert => "foo"})
+      subject.push(:device_tokens => ["device_token"], :aps => {:alert => "foo"})
     end
 
     it "logs request and response information when sending batch push notifications" do
       @logger.should_receive(:info).with(/\/api\/push\/batch/)
-      Urbanairship.batch_push([:device_tokens => ["device_token"], :aps => {:alert => "foo"}])
+      subject.batch_push([:device_tokens => ["device_token"], :aps => {:alert => "foo"}])
     end
 
     it "logs request and response information when sending feedback requests" do
       @logger.should_receive(:info).with(/\/api\/device_tokens\/feedback/)
-      Urbanairship.feedback(Time.now)
+      subject.feedback(Time.now)
     end
 
     it "flushes the logger buffer if it's an ActiveSupport::BufferedLogger (Default Rails logger)" do
       @logger.stub(:flush).and_return("message in the buffer\n")
       @logger.should_receive(:flush)
-      Urbanairship.feedback(Time.now)
+      subject.feedback(Time.now)
     end
   end
 
   describe "request timeout" do
     before(:each) do
       @logger = mock("logger", :info => true)
-      Urbanairship.application_key = "my_app_key"
-      Urbanairship.application_secret = "my_app_secret"
-      Urbanairship.master_secret = "my_master_secret"
-      Urbanairship.logger = @logger
+      subject.application_key = "my_app_key"
+      subject.application_secret = "my_app_secret"
+      subject.master_secret = "my_master_secret"
+      subject.logger = @logger
     end
 
     it "does not attempt to log if logger is not set" do
       Urbanairship::Timer.should_receive(:timeout).with(5.0).and_raise(Timeout::Error)
-      Urbanairship.logger = nil
+      subject.logger = nil
 
       lambda {
-        Urbanairship.register_device('new_device_token')
+        subject.register_device('new_device_token')
       }.should_not raise_exception(NoMethodError)
     end
 
@@ -479,19 +479,27 @@ describe Urbanairship do
       Urbanairship::Timer.should_receive(:timeout).with(5.0).and_raise(Timeout::Error)
       @logger.should_receive(:error).with(/Urbanairship request timed out/)
 
-      Urbanairship.register_device('new_device_token')
+      subject.register_device('new_device_token')
     end
 
     it "accepts a configured request_timeout value" do
       Urbanairship::Timer.should_receive(:timeout).with(1.23).and_raise(Timeout::Error)
       @logger.should_receive(:error).with(/Urbanairship request timed out/)
 
-      Urbanairship.request_timeout = 1.23
-      Urbanairship.register_device('new_device_token')
+      subject.request_timeout = 1.23
+      subject.register_device('new_device_token')
     end
   end
 end
 
+describe Urbanairship do
+  it_should_behave_like "an Urbanairship client"
+end
+
+describe Urbanairship::Client do
+  it_should_behave_like "an Urbanairship client"
+end
+
 def request_json
   JSON.parse FakeWeb.last_request.body
 end

metadata

@@ -1,57 +1,75 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: urbanairship
-version: !ruby/object:Gem::Version
-  version: 2.1.2
+version: !ruby/object:Gem::Version 
+  hash: 7
   prerelease: 
+  segments: 
+  - 2
+  - 2
+  - 0
+  version: 2.2.0
 platform: ruby
-authors:
+authors: 
 - Groupon, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-03 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-11-08 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: json
-  requirement: &70132667901780 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :runtime
-  prerelease: false
-  version_requirements: *70132667901780
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &70132667901340 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70132667901340
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: fakeweb
-  requirement: &70132667900900 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70132667900900
-description: Urbanairship is a Ruby library for interacting with the Urban Airship
-  (http://urbanairship.com) API.
-email:
+  version_requirements: *id003
+description: Urbanairship is a Ruby library for interacting with the Urban Airship (http://urbanairship.com) API.
+email: 
 - rubygems@groupon.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - README.markdown
 - LICENSE
 - Rakefile
@@ -60,31 +78,43 @@ files:
 - spec/response_spec.rb
 - spec/spec_helper.rb
 - spec/urbanairship_spec.rb
+has_rdoc: true
 homepage: http://github.com/groupon/urbanairship
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 59
+      segments: 
+      - 1
+      - 8
+      - 6
       version: 1.8.6
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.6
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: A Ruby wrapper for the Urban Airship API
-test_files:
+test_files: 
 - spec/response_spec.rb
 - spec/spec_helper.rb
 - spec/urbanairship_spec.rb