edh 0.1

data/.autotest

@@ -0,0 +1,12 @@
+# Override autotest default magic to rerun all tests every time a
+# change is detected on the file system.
+class Autotest
+  
+  def get_to_green
+    begin
+      rerun_all_tests
+      wait_for_changes unless all_good
+    end until all_good
+  end
+                            
+end

data/.gitignore

@@ -0,0 +1,8 @@
+pkg
+.project
+Gemfile.lock
+.rvmrc
+*.rbc
+*~
+.yardoc/
+.DS_Store

data/.rspec

@@ -0,0 +1 @@
+--color --order rand

data/.travis.yml

@@ -0,0 +1,13 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - ruby-head
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-18mode
+  - rbx-19mode
+  - ree
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/.yardopts

@@ -0,0 +1,3 @@
+--readme          readme.md
+--title           "Koala Documentation"
+--no-private

data/Gemfile

@@ -0,0 +1,23 @@
+source "https://rubygems.org"
+
+group :development do
+  gem "yard"
+end
+
+group :development, :test do
+  gem "typhoeus" unless defined? JRUBY_VERSION
+
+  # Testing infrastructure
+  gem 'guard'
+  gem 'guard-rspec'
+
+  if RUBY_PLATFORM =~ /darwin/
+    # OS X integration
+    gem "ruby_gntp"
+    gem "rb-fsevent"
+  end
+end
+
+gem "jruby-openssl" if defined? JRUBY_VERSION
+
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+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
+

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010-2011 Alex Koppel, originally Koala Gem
+
+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/Manifest

@@ -0,0 +1,25 @@
+CHANGELOG
+LICENSE
+Manifest
+Rakefile
+init.rb
+edh.gemspec
+lib/edh.rb
+lib/edh/http_services.rb
+lib/edh/rest_api.rb
+lib/edh/test_users.rb
+readme.md
+spec/edh/api_base_tests.rb
+spec/edh/assets/beach.jpg
+spec/edh/http_services/http_service_tests.rb
+spec/edh/http_services/net_http_service_tests.rb
+spec/edh/http_services/typhoeus_service_tests.rb
+spec/edh/live_testing_data_helper.rb
+spec/edh/rest_api/rest_api_no_access_token_tests.rb
+spec/edh/rest_api/rest_api_tests.rb
+spec/edh/rest_api/rest_api_with_access_token_tests.rb
+spec/edh/test_users/test_users_tests.rb
+spec/edh_spec.rb
+spec/edh_spec_helper.rb
+spec/edh_spec_without_mocks.rb
+spec/mock_http_service.rb

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rake'
+
+begin
+  require 'bundler/setup'
+  Bundler::GemHelper.install_tasks
+rescue LoadError
+  puts 'although not required, bundler is recommened for running the tests'
+end
+
+task :default => :spec
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["--color", '--format doc']
+end

data/autotest/discover.rb

@@ -0,0 +1 @@
+Autotest.add_discovery { "rspec2" }

data/changelog.md

@@ -0,0 +1,4 @@
+v0.1
+====
+
+* Initial rework of EDH gem to work for Passport API, based off Koala gem by Alex Koppel.

data/edh.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+require 'edh/version'
+
+Gem::Specification.new do |gem|
+  gem.name        = "edh"
+  gem.summary     = "A lightweight, flexible library for EDH Passport"
+  gem.description = "A lightweight, flexible library for EDH Passport"
+  gem.homepage    = "http://github.com/everydayhero/edh"
+  gem.version     = EDH::VERSION
+
+  gem.authors     = ["Alex Koppel", "Joel Richards"]
+  gem.email       = "joelr@everydayhero.com.au"
+
+  gem.require_paths  = ["lib"]
+  gem.files          = `git ls-files`.split("\n")
+  gem.test_files     = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables    = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+
+  gem.extra_rdoc_files = ["readme.md", "changelog.md"]
+  gem.rdoc_options     = ["--line-numbers", "--inline-source", "--title", "EDH"]
+
+  gem.add_runtime_dependency("multi_json")
+  gem.add_runtime_dependency("faraday")
+  gem.add_runtime_dependency("addressable")
+  gem.add_development_dependency("rspec")
+  gem.add_development_dependency("rake")
+end

data/lib/edh.rb

@@ -0,0 +1,47 @@
+# useful tools
+require 'digest/md5'
+require 'multi_json'
+
+# include edh modules
+require 'edh/errors'
+require 'edh/api'
+require 'edh/test_users'
+
+# HTTP module so we can communicate with Passport
+require 'edh/http_service'
+
+# miscellaneous
+require 'edh/utils'
+require 'edh/version'
+
+module EDH
+  # A Ruby client library for the Passport Platform.
+  
+  # Making HTTP requests
+  class << self
+    # Control which HTTP service framework EDH uses. 
+    attr_accessor :http_service
+  end
+
+  # @private
+  # For current HTTPServices, switch the service as expected.
+  def self.http_service=(service)
+    if service.respond_to?(:deprecated_interface)
+      # if this is a deprecated module, support the old interface
+      # by changing the default adapter so the right library is used
+      # we continue to use the single HTTPService module for everything
+      service.deprecated_interface 
+    else
+      # if it's a real http_service, use it
+      @http_service = service
+    end
+  end
+
+  # An convenenient alias to EDH.http_service.make_request. 
+  def self.make_request(path, args, verb, options = {})
+    http_service.make_request(path, args, verb, options)
+  end
+
+  # we use Faraday as our main service, with mock as the other main one
+  self.http_service = HTTPService
+end

data/lib/edh/api.rb

@@ -0,0 +1,93 @@
+# graph_batch_api and legacy are required at the bottom, since they depend on API being defined
+require 'edh/api/rest_api'
+
+module EDH
+  module Passport
+    class API
+      # Creates a new API client.
+      # @param [String] access_token access token
+      # @note If no access token is provided, you can only access some public information.
+      # @return [EDH::Passport::API] the API client
+      def initialize(access_token = nil, server = nil)
+        @access_token = access_token
+        @server = server
+      end
+
+      attr_accessor :access_token
+
+      include RestAPIMethods
+
+      # Makes a request to the appropriate Passport API.
+      # @note You'll rarely need to call this method directly.
+      #
+      # @see RestAPIMethods#rest_call
+      #
+      # @param path the server path for this request (leading / is prepended if not present)
+      # @param args arguments to be sent to Passport
+      # @param verb the HTTP method to use
+      # @param options request-related options for EDH and Faraday.
+      # @option options [Symbol] :http_component which part of the response (headers, body, or status) to return
+      # @option options [Boolean] :use_ssl force SSL for this request, even if it's tokenless.
+      #                                    (All API requests with access tokens use SSL.)
+      # @param error_checking_block a block to evaluate the response status for additional JSON-encoded errors
+      #
+      # @yield The response for evaluation
+      #
+      # @raise [EDH::Passport::ServerError] if Passport returns an error (response status >= 500)
+      #
+      # @return the body of the response from Passport (unless another http_component is requested)
+      def api(path, args = {}, verb = "get", options = {}, &error_checking_block)
+        # If a access token is explicitly provided, use that
+        # This is explicitly needed in batch requests so GraphCollection
+        # results preserve any specific access tokens provided
+        args["access_token"] ||= @access_token || @app_access_token if @access_token || @app_access_token
+        options.merge!({:server => @server}) unless @server.nil?
+
+        # Translate any arrays in the params into comma-separated strings
+        args = sanitize_request_parameters(args)
+
+        # add a leading /
+        path = "/#{path}" unless path =~ /^\//
+
+        # make the request via the provided service
+        result = EDH.make_request(path, args, verb, options)
+
+        if result.status.to_i >= 500
+          raise EDH::Passport::ServerError.new(result.status.to_i, result.body)
+        end
+
+        yield result if error_checking_block
+
+        # if we want a component other than the body (e.g. redirect header for images), return that
+        if component = options[:http_component]
+          component == :response ? result : result.send(options[:http_component])
+        else
+          # parse the body as JSON and run it through the error checker (if provided)
+          # Note: Passport sometimes sends results like "true" and "false", which aren't strictly objects
+          # and cause MultiJson.load to fail -- so we account for that by wrapping the result in []
+          MultiJson.load("[#{result.body.to_s}]")[0]
+        end
+      end
+
+      private
+
+      # Sanitizes Ruby objects into Passport-compatible string values.
+      #
+      # @param parameters a hash of parameters.
+      #
+      # Returns a hash in which values that are arrays of non-enumerable values
+      #         (Strings, Symbols, Numbers, etc.) are turned into comma-separated strings.
+      def sanitize_request_parameters(parameters)
+        parameters.reduce({}) do |result, (key, value)|
+          # if the parameter is an array that contains non-enumerable values,
+          # turn it into a comma-separated list
+          # in Ruby 1.8.7, strings are enumerable, but we don't care
+          if value.is_a?(Array) && value.none? {|entry| entry.is_a?(Enumerable) && !entry.is_a?(String)}
+            value = value.join(",")
+          end
+          result.merge(key => value)
+        end
+      end
+    end
+  end
+end

data/lib/edh/api/rest_api.rb

@@ -0,0 +1,58 @@
+module EDH
+  module Passport
+    REST_SERVER = "passport.everydayhero.com/api/v1"
+
+    # Methods used to interact with Passport's REST API.  
+
+    module RestAPIMethods
+      #convenience methods
+      def create pp_method, args = {}, options = {}
+        rest_call("me/#{pp_method}", args, options, :post)
+      end
+
+      def delete pp_action_uid, args = {}, options = {}
+        rest_call("actions/#{pp_action_uid}", args, options, :delete)
+      end
+
+      def update pp_action_uid, args = {}, options = {}
+        rest_call("actions/#{pp_action_uid}", args, options, :put)
+      end
+
+      # Make a call to the REST API. 
+      #
+      # @note The order of the last two arguments is non-standard (for historical reasons).  Sorry.
+      # 
+      # @param pp_method the API call you want to make
+      # 
+      # @raise [EDH::Passport::APIError] if Passport returns an error
+      # 
+      # @return the result from Passport
+      def rest_call(pp_method, args = {}, options = {}, verb = "get")
+        args = MultiJson.load(args) if args.is_a?(String)
+        api("#{pp_method}", args.merge('format' => 'json'), verb, options) do |response|
+          # check for REST API-specific errors
+          if response.status >= 400
+            begin
+              response_hash = MultiJson.load(response.body)
+            rescue MultiJson::DecodeError
+              response_hash = {}
+            end
+
+            error_info = {
+              'code' => response_hash['error_code'],
+              'error_subcode' => response_hash['error_subcode'],
+              'message' => response_hash['error_msg']
+            }
+
+            if response.status >= 500
+              raise ServerError.new(response.status, response.body, error_info)
+            else
+              raise ClientError.new(response.status, response.body, error_info)
+            end
+          end
+        end
+      end
+    end
+
+  end # module Passport
+end # module EDH

data/lib/edh/errors.rb

@@ -0,0 +1,78 @@
+module EDH
+
+  class EDHError < StandardError; end
+
+  module Passport
+
+    class APIError < ::EDH::EDHError
+      attr_accessor :pp_error_type, :pp_error_code, :pp_error_subcode, :pp_error_message,
+                    :http_status, :response_body
+
+      # Create a new API Error
+      #
+      # @param http_status [Integer] The HTTP status code of the response
+      # @param response_body [String] The response body
+      # @param error_info One of the following:
+      #                   [Hash] The error information extracted from the request 
+      #                          ("type", "code", "error_subcode", "message")
+      #                   [String] The error description
+      #                   If error_info is nil or not provided, the method will attempt to extract
+      #                   the error info from the response_body
+      #
+      # @return the newly created APIError
+      def initialize(http_status, response_body, error_info = nil)
+        if response_body
+          self.response_body = response_body.strip
+        else
+          self.response_body = ''
+        end
+        self.http_status = http_status
+
+        if error_info && error_info.is_a?(String)
+          message = error_info
+        else
+          unless error_info
+            begin
+              error_info = MultiJson.load(response_body)['error'] if response_body
+            rescue
+            end
+            error_info ||= {}
+          end
+
+          self.pp_error_type = error_info["type"]
+          self.pp_error_code = error_info["code"]
+          self.pp_error_subcode = error_info["error_subcode"]
+          self.pp_error_message = error_info["message"]
+
+          error_array = []
+          %w(type code error_subcode message).each do |key|
+            error_array << "#{key}: #{error_info[key]}" if error_info[key]
+          end
+
+          if error_array.empty?
+            message = self.response_body
+          else
+            message = error_array.join(', ')
+          end
+        end
+        message += " [HTTP #{http_status}]" if http_status
+
+        super(message)
+      end
+    end
+
+    # Passport returned an invalid response body
+    class BadPassportResponse < APIError; end
+
+    # Any error with a 5xx HTTP status code
+    class ServerError < APIError; end
+
+    # Any error with a 4xx HTTP status code 
+    class ClientError < APIError; end
+
+    # All graph API authentication failures.
+    class AuthenticationError < ClientError; end
+
+  end
+
+end