zeppelin 0.5.0 → 0.6.0

data/.gitignore

@@ -8,8 +8,6 @@ lib/bundler/man
 pkg
 rdoc
 spec/reports
-test/tmp
-test/version_tmp
 tmp
 
 # YARD artifacts
@@ -18,4 +16,5 @@ _yardoc
 doc/
 
 # Gem-specific
-Gemfile.lock
+Gemfile.lock
+bin/

data/.travis.yml

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

data/.yardopts

@@ -3,4 +3,7 @@
 --markup-provider maruku
 --default-return  ""
 --title           "Zeppelin Documentation"
---hide-void-return
+--hide-void-return
+-
+Changelog.md
+LICENSE

data/Changelog.md

@@ -0,0 +1,28 @@
+# 0.6.0
+
+## Enhancements
+
+* [MultiJson](https://github.com/intridea/multi_json) used to handle JSON
+  encoding/decoding. Using the JSON engine of your choice is as simple
+  as: `MultiJson.engine = :your_choice`
+
+## Breaking Changes
+
+* Instead of having an invalid request return false, exceptions will be raised
+  with messages containing details about the fail. This allows for
+  better error handling. Should the desired resource not be found,
+  `Zeppelin::ResourceNotFound` will be raised, for other errors,
+  `Zeppelin::ClientError` will be raised. Successful responses will still
+  return `true`.
+
+## Changes
+
+* Now using RSpec as the test harness
+* CI covers Ruby 1.9.3
+* [James Herdman](https://github.com/jherdman) added as a contributor
+
+# 0.5.0
+
+## Changes
+
+* Refactored handling of responses

data/Gemfile

@@ -1,2 +1,10 @@
 source :rubygems
-gemspec
+gemspec
+
+group :development do
+  gem 'rb-fsevent', :require => RUBY_PLATFORM.include?('darwin') && 'rb-fsevent'
+  gem 'growl', :require => RUBY_PLATFORM.include?('darwin') && 'growl'
+  gem 'guard'
+  gem 'guard-bundler'
+  gem 'guard-rspec'
+end

data/Guardfile

@@ -0,0 +1,10 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end

data/Rakefile

@@ -1,11 +1,11 @@
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-task :default => 'test'
+require 'rspec/core/rake_task'
 
-require 'rake/testtask'
-Rake::TestTask.new do |t|
-  t.ruby_opts += ['-rubygems']
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-end
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec

data/lib/zeppelin.rb

@@ -13,6 +13,8 @@ class Zeppelin
   BROADCAST_URI = '/api/push/broadcast/'
   JSON_HEADERS = { 'Content-Type' => 'application/json' }
 
+  attr_reader :application_key, :application_master_secret, :options
+
   # @param [String] application_key your Urban Airship Application Key
   #
   # @param [String] application_master_secret your Urban Airship Application
@@ -33,97 +35,107 @@ class Zeppelin
   #
   # @param [String] device_token
   # @param [Hash] payload the payload to send during registration
+  #
   # @return [Boolean] whether or not the registration was successful
+  #
+  # @raise [Zeppelin::ClientError] malformed request
   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
-
-    response.success?
+    put_request(uri, payload)
   end
 
   # Retrieves information on a device token.
   #
   # @param [String] device_token
   # @return [Hash, nil]
+  #
+  # @raise [Zeppelin::ResourceNotFound] invalid device token provided
   def device_token(device_token)
-    response = connection.get(device_token_uri(device_token))
-    response.success? ? response.body : nil
+    uri = device_token_uri(device_token)
+    get_request(uri)
   end
 
   # Deletes a device token.
   #
   # @param [String] device_token
+  #
   # @return [Boolean] whether or not the deletion was successful
+  #
+  # @raise [Zeppelin::ResourceNotFound] invalid device token provided
   def delete_device_token(device_token)
-    response = connection.delete(device_token_uri(device_token))
-    response.success?
+    uri = device_token_uri(device_token)
+    delete_request(uri)
   end
 
   # Registers an APID.
   #
   # @param [String] apid
+  #
   # @param [Hash] payload the payload to send during registration
+  #
   # @return [Boolean] whether or not the registration was successful
+  #
+  # @raise [Zeppelin::ClientError] invalid payload format
   def register_apid(apid, payload = {})
     uri = apid_uri(apid)
-
-    if payload.empty?
-      response = connection.put(uri)
-    else
-      response = connection.put(uri, payload, JSON_HEADERS)
-    end
-
-    response.success?
+    put_request(uri, payload)
   end
 
   # Retrieves information on an APID.
   #
   # @param [String] apid
+  #
   # @return [Hash, nil]
+  #
+  # @raise [Zeppelin::ResourceNotFound] invalid APID provided
   def apid(apid)
-    response = connection.get(apid_uri(apid))
-    response.success? ? response.body : nil
+    uri = apid_uri(apid)
+    get_request(uri)
   end
 
   # Deletes an APID.
   #
   # @param [String] apid
+  #
   # @return [Boolean] whether or not the deletion was successful
+  #
+  # @raise [Zeppelin::ResourceNotFound] invalid APID provided
   def delete_apid(apid)
-    response = connection.delete(apid_uri(apid))
-    response.success?
+    uri = apid_uri(apid)
+    delete_request(uri)
   end
 
   # Pushes a message.
   #
   # @param [Hash] payload the payload of the message
+  #
   # @return [Boolean] whether or not pushing the message was successful
+  #
+  # @raise [Zeppelin::ClientError] invalid payload format
   def push(payload)
-    response = connection.post(PUSH_URI, payload, JSON_HEADERS)
-    response.success?
+    post_request(PUSH_URI, payload)
   end
 
   # Batch pushes multiple messages.
   #
   # @param [<Hash>] payload the payloads of each message
+  #
   # @return [Boolean] whether or not pushing the messages was successful
+  #
+  # @raise [Zeppelin::ClientError] invalid payload format
   def batch_push(*payload)
-    response = connection.post(BATCH_PUSH_URI, payload, JSON_HEADERS)
-    response.success?
+    post_request(BATCH_PUSH_URI, payload)
   end
 
   # Broadcasts a message.
   #
   # @param [Hash] payload the payload of the message
+  #
   # @return [Boolean] whether or not broadcasting the message was successful
+  #
+  # @raise [Zeppelin::ClientError] invalid payload format
   def broadcast(payload)
-    response = connection.post(BROADCAST_URI, payload, JSON_HEADERS)
-    response.success?
+    post_request(BROADCAST_URI, payload)
   end
 
   # Retrieves feedback on device tokens.
@@ -131,18 +143,21 @@ class Zeppelin
   # This is useful for removing inactive device tokens for the database.
   #
   # @param [Time] since the time to retrieve inactive tokens from
+  #
   # @return [Hash, nil]
+  #
+  # @raise [Zeppelin::ClientError] invalid time param
   def feedback(since)
-    response = connection.get(feedback_uri(since))
-    response.success? ? response.body : nil
+    uri = feedback_uri(since)
+    get_request(uri)
   end
 
   # Retrieve all tags on the service
   #
   # @return [Hash, nil]
   def tags
-    response = connection.get(tag_uri(nil))
-    response.success? ? response.body : nil
+    uri = tag_uri(nil)
+    get_request(uri)
   end
 
   # Modifies device tokens associated with a tag.
@@ -153,7 +168,8 @@ class Zeppelin
   #
   # @see http://urbanairship.com/docs/tags.html#modifying-device-tokens-on-a-tag
   def modify_device_tokens_on_tag(tag_name, payload = {})
-    connection.post(tag_uri(tag_name), payload, JSON_HEADERS)
+    uri = tag_uri(tag_name)
+    post_request(uri, payload)
   end
 
   # Creates a tag that is not associated with any device
@@ -162,8 +178,8 @@ class Zeppelin
   #
   # @return [Boolean] whether or not the request was successful
   def add_tag(name)
-    response = connection.put(tag_uri(name))
-    response.success?
+    uri = tag_uri(name)
+    put_request(uri)
   end
 
   # Removes a tag from the service
@@ -172,17 +188,21 @@ class Zeppelin
   #
   # @return [Boolean] true when the request was successful. Note that this
   #   method will return false if the tag has already been removed.
+  #
+  # @raise [Zeppelin::ResourceNotFound] tag already removed
   def remove_tag(name)
-    response = connection.delete(tag_uri(name))
-    response.success?
+    uri = tag_uri(name)
+    delete_request(uri)
   end
 
   # @param [String] device_token
   #
   # @return [Hash, nil]
+  #
+  # @raise [Zeppelin::ResourceNotFound] device does not exist
   def device_tags(device_token)
-    response = connection.get(device_tag_uri(device_token, nil))
-    response.success? ? response.body : nil
+    uri = device_tag_uri(device_token, nil)
+    get_request(uri)
   end
 
   # @param [String] device_token
@@ -191,9 +211,11 @@ class Zeppelin
   #
   # @return [Boolean] whether or not a tag was successfully associated with
   #   a device
+  #
+  # @raise [Zeppelin::ResourceNotFound] device does not exist
   def add_tag_to_device(device_token, tag_name)
-    response = connection.put(device_tag_uri(device_token, tag_name))
-    response.success?
+    uri = device_tag_uri(device_token, tag_name)
+    put_request(uri)
   end
 
   # @param [String] device_token
@@ -202,18 +224,23 @@ class Zeppelin
   #
   # @return [Boolean] whether or not a tag was successfully dissociated from
   #   a device
+  #
+  # @raise [Zeppelin::ResourceNotFound] device does not exist
   def remove_tag_from_device(device_token, tag_name)
-    response = connection.delete(device_tag_uri(device_token, tag_name))
-    response.success?
+    uri = device_tag_uri(device_token, tag_name)
+    delete_request(uri)
   end
 
   private
 
   def initialize_connection
+    Faraday::Request::JSON.adapter = MultiJson
+
     conn = Faraday::Connection.new(BASE_URI, @options) do |builder|
       builder.request :json
 
-      builder.use Zeppelin::JsonParserMiddleware
+      builder.use Zeppelin::Middleware::JsonParser
+      builder.use Zeppelin::Middleware::ResponseRaiseError
 
       builder.adapter :net_http
     end
@@ -223,6 +250,29 @@ class Zeppelin
     conn
   end
 
+  def put_request(uri, payload={})
+    if !(payload.nil? || payload.empty?)
+      response =connection.put(uri, payload, JSON_HEADERS)
+    else
+      response = connection.put(uri)
+    end
+
+    response.success?
+  end
+
+  def delete_request(uri)
+    connection.delete(uri).success?
+  end
+
+  def get_request(uri)
+    response = connection.get(uri)
+    response.body if response.success?
+  end
+
+  def post_request(uri, payload)
+    connection.post(uri, payload, JSON_HEADERS).success?
+  end
+
   def device_token_uri(device_token)
     "/api/device_tokens/#{device_token}"
   end
@@ -244,5 +294,5 @@ class Zeppelin
   end
 end
 
-require 'zeppelin/json_parser_middleware'
+require 'zeppelin/middleware'
 require 'zeppelin/version'

data/lib/zeppelin/middleware.rb

@@ -0,0 +1,7 @@
+class Zeppelin
+  module Middlware
+  end
+end
+
+require 'zeppelin/middleware/json_parser'
+require 'zeppelin/middleware/response_raise_error'

data/lib/zeppelin/middleware/json_parser.rb

@@ -0,0 +1,37 @@
+require 'multi_json'
+
+class Zeppelin
+  module Middleware
+    # Middleware for Faraday that parses JSON response bodies. Based on code in
+    # the FaradayMiddleware project.
+    #
+    # @private
+    class JsonParser < Faraday::Middleware
+      CONTENT_TYPE = 'Content-Type'
+
+      def initialize(app=nil)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env).on_complete do
+          parse_response(env) if process_content_type?(env) && parse_response?(env)
+        end
+      end
+
+      private
+
+      def parse_response(env)
+        env[:body] = MultiJson.decode(env[:body])
+      end
+
+      def process_content_type?(env)
+        env[:response_headers][CONTENT_TYPE].to_s =~ /\bjson$/
+      end
+
+      def parse_response?(env)
+        env[:body].respond_to? :to_str
+      end
+    end
+  end
+end