paid 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c131f42824035c881ba3eaf3896d2a8e79aa9a26
-  data.tar.gz: c2b902c2b3d7e0fba75c67b71ec3cff06db9fc98
+  metadata.gz: 19719c911ec26dca4ded160c1bd21384fd783939
+  data.tar.gz: 29fe6d251b7c798dcc9d962a9b3cd1f7b9366d0d
 SHA512:
-  metadata.gz: 97115b5ea5004e528b213f9fc9800d5adfebe63d6ff7c0ed95f98f06a04d4acc0523067a285707521a6ce19ef365ec38768aed459cfa6da6e37afe61a72dd339
-  data.tar.gz: b1b15a66a2e5c093635e35d790bc9c801ad03143f595e1d86c512a26f7e88885a6adbeb69731fd1ca5ee5fa630c90f013549ec1d2b3e8398a1cf1f1bed29258c
+  metadata.gz: 2cb3e08c5d99736ae837e89231465b8a90f24a2558ef0ebb897bf1cc8d6483a1ad99fcc9a8e6228fd30092c5266d6fe52e817308d2af456354515fe677df89a3
+  data.tar.gz: b05a5e6fe08b76c77eae783f9d687bc44fd2c0806c38fcaf5add389ef59ec5d3ff0d989bbf03f84011d9ac6b3cefc6de8c0ccd01713edbff624e4127725fb317

data/.gitignore

@@ -1 +1,5 @@
-pkg
+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/History.txt

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

data/README.md

@@ -0,0 +1,58 @@
+# Paid Ruby bindings ![Travis CI Status](https://travis-ci.org/paidapi/paid-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 Paid Ruby bindings, you should run:
+
+```bash
+gem install paid
+```
+
+If you want to build the gem from source:
+
+```bash
+gem build paid.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 'paid'
+```
+
+
+## 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

@@ -1,34 +1,14 @@
-begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
-end
+require 'rake/testtask'
+require './tasks/api_test.rb'
 
-require 'rdoc/task'
+task :default => [:test]
 
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Paid'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+Rake::TestTask.new do |t|
+  t.pattern = './test/**/*_test.rb'
 end
 
-
-
-
-
-
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+task :test_api, [:api_key] do |t, args|
+  api_key = args[:api_key]
+  api_test = APITest.new(api_key)
+  api_test.run
 end
-
-
-task default: :test

data/VERSION

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

data/bin/paid-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/paid'}"
+puts "Loading paid gem"
+exec "#{irb} #{libs} --simple-prompt"

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/paid.rb

@@ -1,35 +1,30 @@
 # Paid Ruby bindings
-# API spec at https://docs.paidapi.com
+# API spec at https://paid.com/docs/api
 require 'cgi'
 require 'set'
 require 'openssl'
 require 'rest_client'
 require 'json'
+require 'base64'
 
 # Version
 require 'paid/version'
 
-# API operations
-require 'paid/api_operations/create'
-require 'paid/api_operations/update'
-require 'paid/api_operations/delete'
-require 'paid/api_operations/list'
-
 # Resources
-require 'paid/util'
-require 'paid/paid_object'
+require 'paid/api_class'
 require 'paid/api_resource'
-require 'paid/singleton_api_resource'
-require 'paid/list_object'
-require 'paid/account'
-require 'paid/customer'
-require 'paid/certificate_blacklist'
-require 'paid/invoice'
+require 'paid/api_singleton'
+require 'paid/api_list'
+require 'paid/util'
+
+# Requires for classes
 require 'paid/transaction'
+require 'paid/invoice'
 require 'paid/event'
-require 'paid/alias'
+require 'paid/customer'
 require 'paid/plan'
 require 'paid/subscription'
+require 'paid/account'
 
 # Errors
 require 'paid/errors/paid_error'
@@ -39,114 +34,93 @@ require 'paid/errors/invalid_request_error'
 require 'paid/errors/authentication_error'
 
 module Paid
-  DEFAULT_CA_BUNDLE_PATH = File.dirname(__FILE__) + '/data/ca-certificates.crt'
-  @api_base = 'https://api.paidapi.com'
-
-  @ssl_bundle_path  = DEFAULT_CA_BUNDLE_PATH
-  @verify_ssl_certs = false
-  @CERTIFICATE_VERIFIED = false
-
+  @api_base = "https://api.paidapi.com"
+  @api_key = nil
 
   class << self
-    attr_accessor :api_key, :api_base, :verify_ssl_certs, :api_version
+    attr_accessor :api_key, :api_base, :api_test
   end
 
-  def self.api_url(url='', api_base_url=nil)
-    (api_base_url || @api_base) + url
+  def self.api_url(path='')
+    "#{@api_base}#{path}"
   end
 
-  def self.request(method, url, api_key, params={}, headers={}, api_base_url=nil)
-    api_base_url = api_base_url || @api_base
-
-
-    unless api_key ||= @api_key
-      raise AuthenticationError.new('No API key provided. ' +
-        'Set your API key using "Paid.api_key = <API-KEY>". ' +
-        'You can generate API keys from the Paid web interface. ' +
-        'See https://paidapi.com/api for details, or email hello@paidapi.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 ' +
-        'Paid web interface. See https://paidapi.com/api for details, or ' +
-        'email hello@paidapi.com if you have any questions.)')
-    end
+  def self.request(method, path, params={}, headers={})
+    verify_api_key(api_key)
 
+    url = api_url(path)
 
     request_opts = { :verify_ssl => false }
 
-    if ssl_preflight_passed?
-      request_opts.update(:verify_ssl => OpenSSL::SSL::VERIFY_PEER,
-                          :ssl_ca_file => @ssl_bundle_path)
-    end
-
-    if @verify_ssl_certs and !@CERTIFICATE_VERIFIED
-      @CERTIFICATE_VERIFIED = CertificateBlacklist.check_ssl_cert(api_base_url, @ssl_bundle_path)
-    end
-
-    params = Util.objects_to_ids(params)
-    url = api_url(url, api_base_url)
-
-    case method.to_s.downcase.to_sym
-    when :get, :head, :delete
-      # Make params into GET parameters
-      url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
-      payload = nil
-    else
-      if headers[:content_type] && headers[:content_type] == "multipart/form-data"
-        payload = params
-      else
-        payload = uri_encode(params)
+    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
 
-    request_opts.update(:headers => request_headers(api_key).update(headers),
-                        :method => method, :open_timeout => 30,
-                        :payload => payload, :url => url, :timeout => 80)
+    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 SocketError => e
-      handle_restclient_error(e, api_base_url)
-    rescue NoMethodError => e
-      # Work around RestClient bug
-      if e.message =~ /\WRequestFailed\W/
-        e = APIConnectionError.new('Unexpected HTTP response code')
-        handle_restclient_error(e, api_base_url)
-      else
-        raise
-      end
-    rescue RestClient::ExceptionWithResponse => e
-      if rcode = e.http_code and rbody = e.http_body
-        handle_api_error(rcode, rbody)
-      else
-        handle_restclient_error(e, api_base_url)
-      end
-    rescue RestClient::Exception, Errno::ECONNREFUSED => e
-      handle_restclient_error(e, api_base_url)
     rescue Exception => e
+      handle_request_error(e, url)
     end
 
+    parse(response)
+  end
 
-    [parse(response), api_key]
+  # Mostly here for stubbing out during tests.
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
   end
 
-  private
+  def self.parse(response)
+    begin
+      json = JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise APIError.generic(response.code, response.body)
+    end
 
-  def self.ssl_preflight_passed?
-    if !verify_ssl_certs && !@no_verify
-        "Execute 'Paid.verify_ssl_certs = true' to enable verification."
+    # TODO(jonclahoun): Remove this when Paid's API returns the correct status code.
+    json = Util.symbolize_keys(json)
+    if json.has_key?(:error)
+      raise PaidError.new(json[:error][:message], response.code, response.body, json)
+    end
+    json
+  end
 
-      @no_verify = true
+  def self.default_headers
+    headers = {
+      :user_agent => "Paid/::API_VERSION:: RubyBindings/#{Paid::VERSION}",
+      :content_type => 'application/x-www-form-urlencoded'
+    }
 
-    elsif !Util.file_readable(@ssl_bundle_path) && !@no_bundle
-        "because #{@ssl_bundle_path} isn't readable"
+    begin
+      headers.update(:x_paid_client_user_agent => JSON.generate(user_agent))
+    rescue => e
+      headers.update(:x_paid_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+    headers
+  end
 
-      @no_bundle = true
+  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 "Paid.api_key = <API-KEY>".')
     end
 
-    !(@no_verify || @no_bundle)
+    base_64_key = Base64.encode64("#{api_key}:")
+    {
+      "Authorization" => "Basic #{base_64_key}",
+    }
   end
 
   def self.user_agent
@@ -161,7 +135,6 @@ module Paid
       :publisher => 'paid',
       :uname => @uname
     }
-
   end
 
   def self.get_uname
@@ -170,95 +143,49 @@ module Paid
     "uname lookup failed"
   end
 
-  def self.uri_encode(params)
-    Util.flatten_params(params).
-      map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
-  end
-
-  def self.request_headers(api_key)
-    headers = {
-      :user_agent => "Paid/v0 RubyBindings/#{Paid::VERSION}",
-      :authorization => "Bearer #{api_key}",
-      :content_type => 'application/x-www-form-urlencoded'
-    }
-
-    headers[:paid_version] = api_version if api_version
-
-    begin
-      headers.update(:x_paid_client_user_agent => JSON.generate(user_agent))
-    rescue => e
-      headers.update(:x_paid_client_raw_user_agent => user_agent.inspect,
-                     :error => "#{e} (#{e.class})")
+  def self.verify_api_key(api_key)
+    unless api_key
+      raise AuthenticationError.new('No API key provided. ' +
+        'Set your API key using "Paid.api_key = <API-KEY>". ' +
+        'You can generate API keys from the Paid web interface. ' +
+        'See http://docs.paidapi.com/#authentication for details, or email hello@paidapi.com ' +
+        'if you have any questions.')
     end
-  end
-
-  def self.execute_request(opts)
-    RestClient::Request.execute(opts)
-  end
 
-  def self.parse(response)
-    begin
-      # Would use :symbolize_names => true, but apparently there is
-      # some library out there that makes symbolize_names not work.
-      response = JSON.parse(response.body)
-    rescue JSON::ParserError
-      raise general_api_error(response.code, response.body)
+    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 ' +
+        'Paid web interface. See http://docs.paidapi.com/#authentication for details, or ' +
+        'email hello@paidapi.com if you have any questions.)')
     end
-
-    Util.symbolize_names(response)
-  end
-
-  def self.general_api_error(rcode, rbody)
-    APIError.new("Invalid response object from API: #{rbody.inspect} " +
-                 "(HTTP response code was #{rcode})", rcode, rbody)
   end
 
-  def self.handle_api_error(rcode, rbody)
-    begin
-      error_obj = JSON.parse(rbody)
-      error_obj = Util.symbolize_names(error_obj)
-      error = error_obj[:error] or raise PaidError.new # escape from parsing
-
-    rescue JSON::ParserError, PaidError
-      raise general_api_error(rcode, rbody)
+  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
 
-    case rcode
-    when 400, 404
-      raise invalid_request_error error, rcode, rbody, error_obj
-    when 401
-      raise authentication_error error, rcode, rbody, error_obj
-    else
-      raise api_error error, rcode, rbody, error_obj
-    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.invalid_request_error(error, rcode, rbody, error_obj)
-    InvalidRequestError.new(error[:message], error[:param], rcode,
-                            rbody, error_obj)
-  end
+  def self.handle_connection_error(error, url)
+    message = "An error occurred while connecting to Paid at #{url}."
 
-  def self.authentication_error(error, rcode, rbody, error_obj)
-    AuthenticationError.new(error[:message], rcode, rbody, error_obj)
-  end
-
-  def self.api_error(error, rcode, rbody, error_obj)
-    APIError.new(error[:message], rcode, rbody, error_obj)
-  end
-
-  def self.handle_restclient_error(e, api_base_url=nil)
-    api_base_url = @api_base unless api_base_url
-    connection_message = "Please check your internet connection and try again. " \
-        "If this problem persists, you should check Paid's service status at " \
-        "https://twitter.com/paidstatus, or let us know at hello@paidapi.com."
-
-    case e
+    case error
     when RestClient::RequestTimeout
-      message = "Could not connect to Paid (#{api_base_url}). #{connection_message}"
+      message +=  connection_message
 
     when RestClient::ServerBrokeConnection
-      message = "The connection to the server (#{api_base_url}) broke before the " \
+      message = "The connection to the server at (#{url}) broke before the " \
         "request completed. #{connection_message}"
 
     when RestClient::SSLCertificateNotVerified
@@ -268,16 +195,41 @@ module Paid
         "If this problem persists, let us know at hello@paidapi.com."
 
     when SocketError
-      message = "Unexpected error communicating when trying to connect to Paid. " \
+      message = "Unexpected error when trying to connect to Paid. " \
         "You may be seeing this message because your DNS is not working. " \
-        "To check, try running 'host paidapi.com' from the command line."
+        "To check, try running 'host api.paidapi.com' from the command line."
 
     else
       message = "Unexpected error communicating with Paid. " \
-        "If this problem persists, let us know at hello@paidapi.com."
+        "If this problem persists, let us know at hello@paidapi.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 Paid's service status at " \
+    "https://twitter.com/paidstatus, or let us know at hello@paidapi.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]
 
-    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+    case rcode
+    when 400, 404
+      raise InvalidRequestError.new(error[:message], error[:param], rcode, rbody, error_obj)
+    when 401
+      raise AuthenticationError.new(error[:message], rcode, rbody, error_obj)
+    else
+      raise APIError.new(error[:message], rcode, rbody, error_obj)
+    end
   end
+
 end