checkr-official 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 204fa32aac332586ff0659b1c1ab5713b1cc79bf
+  data.tar.gz: e74b3546eb997df8a6e2e05698652f517bc24060
+SHA512:
+  metadata.gz: f3e1c06a138a2506b738f4d3b8195450a869c819eb6ac2c8546855f9c31747195d8f969ac1d2d7fef7b9499294c7306535d6901cc73595ccd68cd75cb04f99d6
+  data.tar.gz: 3cde6c929301904aadd2f5f53a07f6236eb0826213e926d9691ce8ccb571afa7cc3ab5e204edfbf03b868269aa71265c2e88b71e73709d8df5954d3243e7c9be

data/.gitignore

@@ -0,0 +1,5 @@
+pkg
+Gemfile.lock
+*.gem
+test.rb
+.ruby-version

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1
+  - 2.2
+
+gemfile:
+  - gemfiles/default-with-activesupport.gemfile
+  - gemfiles/json.gemfile
+  - gemfiles/yajl.gemfile
+
+sudo: false

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+gemspec
+
+if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9.3')
+  gem 'i18n', '< 0.7'
+  gem 'rest-client', '~> 1.6.8'
+  gem 'activesupport', '~> 3.2'
+end

data/History.txt

@@ -0,0 +1,4 @@
+=== 1.0 2015-03-04
+
+* 1 major enhancement:
+  * Initial release

data/README.md

@@ -0,0 +1,58 @@
+# Checkr Ruby bindings ![Travis CI Status](https://travis-ci.org/checkr/checkr-ruby.svg?branch=master)
+
+
+## Installation
+
+You don't need this source code unless you want to modify the gem. If
+you just want to use the Checkr Ruby bindings, you should run:
+
+```bash
+gem install checkr
+```
+
+If you want to build the gem from source:
+
+```bash
+gem build checkr.gemspec
+```
+
+
+## Requirements
+
+* Ruby 1.8.7 or above. (Ruby 1.8.6 may work if you load
+  ActiveSupport.) For Ruby versions before 1.9.2, you'll need to add this to your Gemfile:
+
+```ruby
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9.2')
+  gem 'rest-client', '~> 1.6.8'
+end
+```
+
+* rest-client, json
+
+
+## Bundler
+
+If you are installing via bundler, you should be sure to use the https
+rubygems source in your Gemfile, as any gems fetched over http could potentially be compromised.
+
+```ruby
+source 'https://rubygems.org'
+
+gem 'rails'
+gem 'checkr'
+```
+
+
+## Development
+
+Test cases can be run with: `bundle exec rake test`
+
+
+## Test Rake Task
+
+To hit the API with some test calls run:
+
+```bash
+bundle exec rake test_api["sk_test_api_key"]
+```

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/testtask'
+require './tasks/api_test.rb'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.pattern = './test/**/*_test.rb'
+end
+
+task :test_api, [:api_key] do |t, args|
+  api_key = args[:api_key]
+  api_test = APITest.new(api_key)
+  api_test.run
+end

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/checkr-console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/checkr'}"
+puts "Loading checkr-official gem"
+exec "#{irb} #{libs} --simple-prompt"

data/checkr-official.gemspec

@@ -0,0 +1,28 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'checkr/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'checkr-official'
+  s.summary = 'Ruby bindings for Checkr API'
+  s.description = 'Checkr - Automated background screenings and driving records. See https://checkr.com/ for details.'
+  s.homepage = 'https://checkr.com/'
+  s.authors = ['Jon Calhoun']
+  s.email = ['joncalhoun@gmail.com']
+  s.version = Checkr::VERSION
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('mime-types', '>= 1.25', '< 3.0')
+  s.add_dependency('json', '~> 1.8.1')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end
+

data/gemfiles/default-with-activesupport.gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9.3')
+  gem 'i18n', '< 0.7'
+  gem 'rest-client', '~> 1.6.8'
+  gem 'activesupport', '~> 3.2'
+else
+  gem 'activesupport'
+end

data/gemfiles/json.gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9.3')
+  gem 'i18n', '< 0.7'
+  gem 'rest-client', '~> 1.6.8'
+  gem 'activesupport', '~> 3.2'
+else
+  gem 'activesupport'
+end
+
+gem 'json'

data/gemfiles/yajl.gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+gemspec :path => File.join(File.dirname(__FILE__), "..")
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('1.9.3')
+  gem 'i18n', '< 0.7'
+  gem 'rest-client', '~> 1.6.8'
+  gem 'activesupport', '~> 3.2'
+else
+  gem 'activesupport'
+end
+
+gem 'yajl-ruby'

data/lib/checkr.rb

@@ -0,0 +1,241 @@
+# Checkr Ruby bindings
+# API spec at https://checkr.com/docs/api
+require 'cgi'
+require 'set'
+require 'openssl'
+require 'rest_client'
+require 'json'
+require 'base64'
+
+# Version
+require 'checkr/version'
+
+# Resources
+require 'checkr/api_class'
+require 'checkr/api_resource'
+require 'checkr/api_singleton'
+require 'checkr/api_list'
+require 'checkr/util'
+
+# Requires for classes
+require 'checkr/candidate'
+require 'checkr/county_criminal_search'
+require 'checkr/document'
+require 'checkr/document_list'
+require 'checkr/geo'
+require 'checkr/motor_vehicle_report'
+require 'checkr/national_criminal_search'
+require 'checkr/report'
+require 'checkr/report_list'
+require 'checkr/sex_offender_search'
+require 'checkr/ssn_trace'
+require 'checkr/subscription'
+require 'checkr/terrorist_watchlist_search'
+
+# Errors
+require 'checkr/errors/checkr_error'
+require 'checkr/errors/api_error'
+require 'checkr/errors/api_connection_error'
+require 'checkr/errors/invalid_request_error'
+require 'checkr/errors/authentication_error'
+
+module Checkr
+  @api_base = "https://api.checkr.com"
+  @api_key = nil
+
+  class << self
+    attr_accessor :api_key, :api_base, :api_test
+  end
+
+  def self.api_url(path='')
+    "#{@api_base}#{path}"
+  end
+
+  def self.request(method, path, params={}, headers={})
+    verify_api_key(api_key)
+
+    url = api_url(path)
+
+    request_opts = { :verify_ssl => false }
+
+    if [:get, :head, :delete].include?(method.to_s.downcase.to_sym)
+      unless params.empty?
+        url += URI.parse(url).query ? '&' : '?' + Util.query_string(params)
+      end
+      params = nil
+    end
+
+    headers = default_headers.update(basic_auth_headers(api_key)).update(headers)
+    request_opts.update(:headers => headers,
+                        :method => method,
+                        :open_timeout => 30,
+                        :payload => params,
+                        :url => url,
+                        :timeout => 60)
+
+    begin
+      response = execute_request(request_opts)
+    rescue Exception => e
+      handle_request_error(e, url)
+    end
+
+    parse(response)
+  end
+
+  # Mostly here for stubbing out during tests.
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      json = JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise APIError.generic(response.code, response.body)
+    end
+
+    # TODO(jonclahoun): Remove this when Checkr's API returns the correct status code.
+    json = Util.symbolize_keys(json)
+    if json.has_key?(:error)
+      raise CheckrError.new(json[:error][:message], response.code, response.body, json)
+    end
+
+    json
+  end
+
+  def self.default_headers
+    headers = {
+      :user_agent => "Checkr/::API_VERSION:: RubyBindings/#{Checkr::VERSION}",
+      :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    begin
+      headers.update(:x_checkr_client_user_agent => JSON.generate(user_agent))
+    rescue => e
+      headers.update(:x_checkr_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+    headers
+  end
+
+  def self.basic_auth_headers(api_key=@api_key)
+    api_key ||= @api_key
+    unless api_key
+      raise ArgumentError.new('No API key provided. Set your API key using "Checkr.api_key = <API-KEY>".')
+    end
+
+    base_64_key = Base64.encode64("#{api_key}:")
+    {
+      "Authorization" => "Basic #{base_64_key}",
+    }
+  end
+
+  def self.user_agent
+    @uname ||= get_uname
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+      :bindings_version => Checkr::VERSION,
+      :lang => 'ruby',
+      :lang_version => lang_version,
+      :platform => RUBY_PLATFORM,
+      :publisher => 'checkr',
+      :uname => @uname
+    }
+  end
+
+  def self.get_uname
+    `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+  rescue Errno::ENOMEM => ex # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+  def self.verify_api_key(api_key)
+    unless api_key
+      raise AuthenticationError.new('No API key provided. ' +
+        'Set your API key using "Checkr.api_key = <API-KEY>". ' +
+        'You can generate API keys from the Checkr web interface. ' +
+        'See https://checkr.com/docs#authentication for details, ' +
+        'or email hello@checkr.com if you have any questions.')
+    end
+
+    if api_key =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' +
+        'whitespace. (HINT: You can double-check your API key from the ' +
+        'Checkr web interface. See https://checkr.com/docs#authentication for details, or ' +
+        'email hello@checkr.com if you have any questions.)')
+    end
+  end
+
+  def self.handle_request_error(error, url)
+    # First we see if this is an error with a response, and if it is
+    # we check to see if there is an http code and body to work with.
+    if error.is_a?(RestClient::ExceptionWithResponse)
+      if error.http_code && error.http_body
+        handle_api_error(error.http_code, error.http_body)
+      end
+    end
+
+    # If we got here then the error hasn't been handled yet.
+    # Handle it as a connection error.
+    handle_connection_error(error, url)
+
+    # Finally if we get here we don't know what type of error it is, so just raise it.
+    raise error
+  end
+
+  def self.handle_connection_error(error, url)
+    message = "An error occurred while connecting to Checkr at #{url}."
+
+    case error
+    when RestClient::RequestTimeout
+      message +=  connection_message
+
+    when RestClient::ServerBrokeConnection
+      message = "The connection to the server at (#{url}) broke before the " \
+        "request completed. #{connection_message}"
+
+    when RestClient::SSLCertificateNotVerified
+      message = "Could not verify Checkr's SSL certificate. " \
+        "Please make sure that your network is not intercepting certificates. " \
+        "If this problem persists, let us know at hello@checkr.com."
+
+    when SocketError
+      message = "Unexpected error when trying to connect to Checkr. " \
+        "You may be seeing this message because your DNS is not working. " \
+        "To check, try running 'host api.checkr.com' from the command line."
+
+    else
+      message = "Unexpected error communicating with Checkr. " \
+        "If this problem persists, let us know at hello@checkr.com. #{connection_message}"
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{error.message}")
+  end
+
+  def self.connection_message
+    "Please check your internet connection and try again. " \
+    "If this problem persists, you should check Checkr's service status at " \
+    "https://twitter.com/checkr, or let us know at hello@checkr.com."
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = JSON.parse(rbody)
+    rescue JSON::ParserError
+      raise APIError.generic(rcode, rbody)
+    end
+    error_obj = Util.symbolize_keys(error_obj)
+    raise APIError.generic(rcode, rbody) unless error = error_obj[:error]
+
+    case rcode
+    when 400, 404
+      raise InvalidRequestError.new(error, "", rcode, rbody, error_obj)
+    when 401
+      raise AuthenticationError.new(error, rcode, rbody, error_obj)
+    else
+      raise APIError.new(error, rcode, rbody, error_obj)
+    end
+  end
+
+end

data/lib/checkr/api_class.rb

@@ -0,0 +1,395 @@
+module Checkr
+  class APIClass
+    attr_accessor :json
+
+    def self.path
+      raise NotImplementedError.new("APIClass is an abstract class. Please refer to its subclasses: #{subclasses}")
+    end
+
+    def path
+      raise NotImplementedError.new("APIClass is an abstract class. Please refer to its subclasses: #{APIClass.subclasses}")
+    end
+
+    def self.api_class_method(name, method, path=nil, opts={})
+      singleton = class << self; self end
+      singleton.send(:define_method, name, api_lambda(name, method, path, opts))
+    end
+
+    def self.api_instance_method(name, method, path=nil, opts={})
+      self.send(:define_method, name, api_lambda(name, method, path, opts))
+    end
+
+    def self.attribute(name, klass=nil, opts={})
+      @attribute_names ||= Set.new
+      @attribute_names << name.to_sym
+
+      self.send(:define_method, "#{name}", attribute_get_lambda(name, opts))
+      self.send(:define_method, "#{name}=", attribute_set_lambda(name, klass, opts))
+    end
+
+    def self.attribute_writer_alias(name, attr_name)
+      @attribute_aliases ||= Set.new
+      @attribute_aliases << name.to_sym
+
+      # self.send(:alias_method, name, attr_name)
+      self.send(:alias_method, "#{name}=", "#{attr_name}=")
+    end
+
+    def attributes
+      attributes = {}
+      self.class.attribute_names.each do |attr|
+        attributes[attr.to_sym] = self.send(attr)
+      end
+      attributes
+    end
+
+    def non_nil_attributes
+      attributes.select{|k, v| !v.nil? }
+    end
+
+    def self.attribute_names
+      @attribute_names ||= Set.new
+      unless self == APIClass
+        @attribute_names + self.superclass.attribute_names
+      else
+        @attribute_names
+      end
+    end
+
+    def self.attribute_aliases
+      @attribute_aliases ||= Set.new
+      unless self == APIClass
+        @attribute_aliases + self.superclass.attribute_aliases
+      else
+        @attribute_aliases
+      end
+    end
+
+    def self.attribute_writer_names
+      self.attribute_names + self.attribute_aliases
+    end
+
+    def mark_attribute_changed(attr_name)
+      @changed_attribute_names ||= Set.new
+      @changed_attribute_names << attr_name.to_sym
+    end
+
+    def changed_attribute_names
+      @changed_attribute_names ||= Set.new
+      attributes.each do |key, val|
+        next if @changed_attribute_names.include?(key)
+        if val.is_a?(Array) || val.is_a?(Hash)
+          @changed_attribute_names << key if json[key] != val
+        end
+      end
+      @changed_attribute_names
+    end
+
+    def changed_attributes
+      ret = {}
+      changed_attribute_names.each do |attr|
+        ret[attr] = send(attr)
+      end
+      ret
+    end
+
+    def clear_changed_attributes
+      @changed_attribute_names = Set.new
+    end
+
+
+    def self.changed_lambda
+      # This runs in the context of an instance since it is used in
+      # an api_instance_method
+      lambda do |instance|
+        instance.changed_attributes
+      end
+    end
+
+    def initialize(id=nil)
+      refresh_from(id)
+    end
+
+    def self.construct(json={})
+      self.new.refresh_from(json)
+    end
+
+    def refresh_from(json={})
+      unless json.is_a?(Hash)
+        json = { :id => json }
+      end
+      self.json = Util.sorta_deep_clone(json)
+
+      json.each do |k, v|
+        if self.class.attribute_writer_names.include?(k.to_sym)
+          self.send("#{k}=", v)
+        end
+      end
+      clear_changed_attributes
+      self
+    end
+
+    # Alias, but dont declare it as one because we need to use overloaded methods.
+    def construct(json={})
+      refresh_from(json)
+    end
+
+    def self.subclasses
+      return @subclasses ||= Set.new
+    end
+
+    def self.subclass_fetch(name)
+      @subclasses_hash ||= {}
+      if @subclasses_hash.has_key?(name)
+        @subclasses_hash[name]
+      end
+    end
+
+    def self.register_subclass(subclass, name=nil)
+      @subclasses ||= Set.new
+      @subclasses << subclass
+
+      unless name.nil?
+        @subclasses_hash ||= {}
+        @subclasses_hash[name] = subclass
+      end
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(json)
+    end
+
+    def to_json(*a)
+      JSON.generate(json)
+    end
+
+
+    private
+
+    def instance_variables_include?(name)
+      if RUBY_VERSION <= '1.9'
+        instance_variables.include?("@#{name}")
+      else
+        instance_variables.include?("@#{name}".to_sym)
+      end
+    end
+
+    def self.attribute_get_lambda(name, opts={})
+      lambda do
+        if !instance_variables_include?(name)
+          if opts[:default]
+            self.send("#{name}=", opts[:default])
+            instance_variable_get("@#{name}")
+          else
+            nil
+          end
+        else
+          instance_variable_get("@#{name}")
+        end
+      end
+    end
+
+    # TODO(joncalhoun): Add tests for this
+    def self.attribute_set_lambda(name, klass=nil, opts={})
+      lambda do |val|
+        if klass
+          val = determine_attr_value(klass, val, opts)
+        end
+        instance_variable_set("@#{name}", val)
+        mark_attribute_changed(name)
+      end
+    end
+
+    # TODO(joncalhoun): Maybe make this delay calling nested constructors until the main obj is fully constructed otherwise.. for now code around it by references to parent in nested objects.
+    def self.determine_attr_value(klass, val, opts={}, this=self)
+      args = (opts && opts[:nested]) ? [val, this] : [val]
+      if klass.is_a?(Proc)
+        klass.call(*args)
+      elsif klass.is_a?(Class)
+        klass.construct(*args)
+      else
+        klass = Util.constantize(klass)
+        klass.construct(*args)
+      end
+    end
+    def determine_attr_value(klass, val, opts={})
+      self.class.determine_attr_value(klass, val, opts, self)
+    end
+
+    def self.api_lambda(out_name, out_method, out_path=nil, out_opts={})
+      # Path, Opts, and Klass are all optional, so we have to determine
+      # which were provided using the criteria:
+      temp = [out_path, out_opts]
+      out_path = temp.select{ |t| t.is_a?(String) }.first || nil
+      out_opts = temp.select{ |t| t.is_a?(Hash) }.first || {}
+
+      out_arg_names = out_opts[:arguments] || []
+      out_constructor = out_opts[:constructor] || :self
+      out_default_params = out_opts[:default_params] || {}
+
+      lambda do |*args|
+        # Make sure we have clean data
+        constructor = out_constructor
+        method = out_method
+        path = nil
+        path = out_path.dup if out_path
+        arg_names = nil
+        arg_names = out_arg_names.dup if out_arg_names
+        default_params = out_default_params # dont need to dup this since it isn't modified directly
+
+        validate_args(arg_names, *args)
+        arguments = compose_arguments(method, arg_names, *args)
+        composed_path = compose_api_path(path, arguments)
+        unused_args = determine_unused_args(path, arg_names, arguments)
+        arguments[:params] = compose_params(arguments[:params], unused_args, default_params)
+
+        resp = Checkr.request(method, composed_path, arguments[:params], arguments[:opts])
+
+
+        api_lambda_construct(resp, constructor, self)
+      end
+    end
+
+    def self.api_lambda_construct(resp, constructor, this)
+      case constructor
+      when Class
+        constructor.construct(resp)
+      when Proc
+        constructor.call(resp)
+      when Symbol
+        if constructor == :self
+          this.construct(resp)
+        else
+          klass = Util.constantize(constructor)
+          if klass
+            klass.construct(resp)
+          else
+            raise ArgumentError.new("Invalid constructor. See method definition.")
+          end
+        end
+      else
+        this.construct(resp)
+      end
+    end
+    def api_lambda_construct(resp, constructor, this)
+      self.class.api_lambda_construct(resp, constructor, this)
+    end
+
+    def self.validate_args(arg_names, *args)
+      # Make sure we have valid arguments
+      if args.length > arg_names.length
+        if args.length > arg_names.length + 2 # more than params and opts were included
+          raise ArgumentError.new("Too many arguments")
+        else
+          # Params and opts are allowed, but they must be hashes
+          args[arg_names.length..-1].each do |arg|
+            unless arg.is_a?(Hash) || arg.nil?
+              raise ArgumentError.new("Invalid Param or Opts argument")
+            end
+          end
+        end
+      end
+
+      if args.length < arg_names.length
+        missing = arg_names[args.length..-1]
+        raise ArgumentError.new("Missing arguments #{missing}")
+      end
+    end
+    def validate_args(arg_names, *args)
+      self.class.validate_args(arg_names, *args)
+    end
+
+    # Priority: params > unused_args > default_params
+    def self.compose_params(params={}, unused_args={}, default_params={}, this=self)
+      ret = {}
+
+      # Handle the default params
+      if default_params.is_a?(Proc)
+        default_params = default_params.call(this)
+      elsif default_params.is_a?(Symbol)
+        default_params = this.send(default_params)
+      end
+
+      ret.update(default_params || {})
+      ret.update(unused_args || {})
+      ret.update(params || {})
+      ret
+    end
+    def compose_params(params={}, unused_args={}, default_params={})
+      self.class.compose_params(params, unused_args, default_params, self)
+    end
+
+    def self.compose_arguments(method, arg_names, *args)
+      arguments = {}
+      names = arg_names.dup + [:params, :opts]
+
+      names.each_with_index do |k, i|
+        arguments[k] = args[i] if args.length > i
+      end
+      arguments[:params] ||= {}
+      arguments[:opts] ||= {}
+
+      arguments
+    end
+    def compose_arguments(method, arg_names, *args)
+      self.class.compose_arguments(method, arg_names, *args)
+    end
+
+    def self.compose_api_path(path, arguments, this=self)
+      # Setup the path using the following attribute order:
+      #   1. Args passed in
+      #   2. Args on this
+      #   3. Args on this.class
+      ret = (path || this.path || "").dup
+      if ret.include?(":")
+        missing = Set.new
+        matches = ret.scan(/:([^\/]*)/).flatten.map(&:to_sym)
+        matches.each do |match|
+          value = arguments[match]
+          begin
+            value ||= this.send(match)
+          rescue NoMethodError
+          end
+          begin
+            value ||= this.class.send(match) unless this.class == Class
+          rescue NoMethodError
+          end
+
+          if value.nil?
+            missing << match
+          end
+
+          ret.sub!(match.inspect, "#{value}")
+        end
+
+        unless missing.empty?
+          raise InvalidRequestError.new("Could not determine the full URL to request. Missing the following values: #{missing.to_a.join(', ')}.")
+        end
+      end
+      ret
+    end
+    def compose_api_path(path, arguments)
+      self.class.compose_api_path(path, arguments, self)
+    end
+
+    def self.determine_unused_args(path, arg_names, arguments, this=self)
+      unused = Set.new(arg_names)
+      path ||= this.path
+      raise ArgumentError.new("Path has never been set") unless path
+      if path.include?(":")
+        matches = path.scan(/:([^\/]*)/).flatten.map(&:to_sym)
+        matches.each{ |m| unused.delete(m) }
+      end
+      ret = {}
+      unused.each do |arg_name|
+        ret[arg_name] = arguments[arg_name]
+      end
+      ret
+    end
+    def determine_unused_args(path, arg_names, arguments)
+      self.class.determine_unused_args(path, arg_names, arguments, self)
+    end
+
+  end
+end