paid 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7bda48a84419fc70d7200704ab421c9b4980e49a
-  data.tar.gz: 4ac182f0c95b23739c0ee2346b3b3b73874b999f
+  metadata.gz: 2e07a6ca29545de7c32a15851ab9742341f9c0a4
+  data.tar.gz: dd51cf68c35c3211960950660273101a5d306126
 SHA512:
-  metadata.gz: ae4a45c77debf4fe5cccff176525159bcf74d72e0e2700028321c63d21b906df022ad33dfe306c7d1cf91bba5329de65b7062b023afb10e2797b579725c84e40
-  data.tar.gz: 3fe73b9564435a8824ad55f99954c85e5e303c4ae8a915440ad37c27cc197e319381ec0ece68e916ce5b912d0556b4a421368f4bd0d52b3c842fa64ff909c378
+  metadata.gz: 9a9dd416fff9f14807f3773311ffadacee30624275e1a2ea50616ecf616593894f4223a1a0f32a26a5aa94f1a475d01eeb4db4ef0d813e854bc28c80aea9009d
+  data.tar.gz: f3d20bde96f8e59e963236dbc97df50bcfb75969b6a32fcf7fc908c3cdf67481cbb0bf2078264842b1a4487ca28bdc91b371b182546d7c18db6964dd65e706b7

data/History.txt

@@ -1,3 +1,9 @@
+=== 1.0.2 2015-04-13
+
+* 1 minor enhancement:
+  * Adding support for refunds endpoint.
+
+
 === 1.0 2015-03-04
 
 * 1 major enhancement:

data/Rakefile

@@ -4,7 +4,7 @@ require './tasks/api_test.rb'
 task :default => [:test]
 
 Rake::TestTask.new do |t|
-  t.pattern = './test/**/*_test.rb'
+  t.pattern = './test/**/[^_]*_test.rb'
 end
 
 task :test_api, [:api_key] do |t, args|

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/lib/paid.rb

@@ -10,226 +10,51 @@ require 'base64'
 # Version
 require 'paid/version'
 
-# Resources
-require 'paid/api_class'
-require 'paid/api_resource'
-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/customer'
-require 'paid/plan'
-require 'paid/subscription'
-require 'paid/account'
-
 # Errors
 require 'paid/errors/paid_error'
 require 'paid/errors/api_error'
 require 'paid/errors/api_connection_error'
-require 'paid/errors/invalid_request_error'
 require 'paid/errors/authentication_error'
 
-module Paid
-  @api_base = "https://api.paidapi.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 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
-
-  def self.default_headers
-    headers = {
-      :user_agent => "Paid/::API_VERSION:: RubyBindings/#{Paid::VERSION}",
-      :content_type => 'application/x-www-form-urlencoded'
-    }
-
-    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
-
-  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
-
-    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 => Paid::VERSION,
-      :lang => 'ruby',
-      :lang_version => lang_version,
-      :platform => RUBY_PLATFORM,
-      :publisher => 'paid',
-      :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 "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
-
-    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
-  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 Paid at #{url}."
+# Wrapper around RestClient
+require 'paid/requester'
 
-    case error
-    when RestClient::RequestTimeout
-      message +=  connection_message
+# Builders for creating API methods.
+require 'paid/path_builder'
+require 'paid/headers_builder'
+require 'paid/params_builder'
+require 'paid/api_method'
 
-    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 Paid's SSL certificate. " \
-        "Please make sure that your network is not intercepting certificates. " \
-        "(Try going to https://api.paidapi.com/v0 in your browser.) " \
-        "If this problem persists, let us know at hello@paidapi.com."
-
-    when SocketError
-      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 api.paidapi.com' from the command line."
+# Generic resources
+require 'paid/api_resource'
+require 'paid/api_list'
+require 'paid/util'
 
-    else
-      message = "Unexpected error communicating with Paid. " \
-        "If this problem persists, let us know at hello@paidapi.com. #{connection_message}"
-    end
+# API specific resources
+require 'paid/account'
+require 'paid/customer'
+require 'paid/event'
+require 'paid/event_data'
+require 'paid/invoice'
+require 'paid/plan'
+require 'paid/subscription'
+require 'paid/transaction'
+require 'paid/refund_list'
 
-    raise APIConnectionError.new(message + "\n\n(Network error: #{error.message}")
-  end
+module Paid
+  @api_key = nil
 
-  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
+  @api_base = "https://api.paidapi.com/v0"
+  @api_staging = "https://api-staging.paidapi.com/v0"
+  @auth_header = nil
+  @api_version = "v0"
+  @support_email = "support@paidapi.com"
+  @docs_url = "https://paidapi.com/docs"
 
-  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[: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
+  class << self
+    attr_accessor :api_key, :api_base, :api_version
+    attr_reader :auth_header, :support_email, :docs_url, :api_staging
   end
 
 end

data/lib/paid/account.rb

@@ -1,17 +1,29 @@
 module Paid
-  class Account < APISingleton
-    # attribute :object inherited from APISingleton
-    attribute :id
-    attribute :business_name
-    attribute :business_url
-    attribute :business_logo
+  class Account < APIResource
+    attr_reader :id
+    attr_reader :object
+    attr_accessor :business_name
+    attr_accessor :business_url
+    attr_accessor :business_logo
 
-    api_class_method :retrieve, :get, ":path"
+    def self.retrieve(params={}, headers={})
+      method = APIMethod.new(:get, "/account", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    def self.path
-      "/v0/account"
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/account", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "account")
+    # Everything below here is used behind the scenes.
+    APIResource.register_api_subclass(self, "account")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :business_name => nil,
+      :business_url => nil,
+      :business_logo => nil
+    }
   end
 end

data/lib/paid/api_list.rb

@@ -1,9 +1,46 @@
 module Paid
-  class APIList < APIClass
+  class APIList < APIResource
     include Enumerable
 
-    attribute :object
-    attribute :data
+    attr_reader :data
+    attr_reader :klass
+
+    def initialize(klass, json={}, api_method=nil)
+      if klass.is_a?(Class)
+        @klass = klass
+      else
+        @klass = Util.constantize(klass)
+      end
+
+      refresh_from(json)
+    end
+
+    def refresh_from(json, api_method=nil)
+      unless json.is_a?(Hash)
+        json = {
+          :data => json
+        }
+      end
+      json = Util.symbolize_keys(json)
+
+      clear_api_attributes
+      @api_method = api_method
+      @data = []
+      @json = Util.sorta_deep_clone(json)
+
+      json.each do |k, v|
+        if k.to_sym == :data
+          if v.respond_to?(:map)
+            instance_variable_set("@#{k}", v.map{ |i| @klass.new(i) })
+          else
+            instance_variable_set("@#{k}", v || [])
+          end
+        elsif self.class.api_attribute_names.include?(k)
+          instance_variable_set("@#{k}", determine_api_attribute_value(k, v))
+        end
+      end
+      self
+    end
 
     def [](k)
       data[k]
@@ -25,23 +62,25 @@ module Paid
       data.each(&blk)
     end
 
-    def self.constructor(klass)
-      lambda do |json|
-        instance = self.new
-        instance.json = json
+    def inspect
+      "#<#{self.class}[#{@klass}]:0x#{self.object_id.to_s(16)}> Data: " + JSON.pretty_generate(inspect_data)
+    end
 
-        json.each do |k, v|
-          if attribute_names.include?(k.to_sym)
-            if k.to_sym == :data
-              instance.send("#{k}=", v.map{ |i| klass.construct(i) })
-            else
-              instance.send("#{k}=", v)
-            end
-          end
+    def inspect_data
+      ret = []
+      data.each do |d|
+        if d.respond_to?(:inspect_nested)
+          ret << d.inspect_nested
+        else
+          ret << d
         end
-        instance.clear_changed_attributes
-        instance
       end
+      ret
     end
+
+
+    @api_attributes = {
+      :data => { :readonly => true }
+    }
   end
 end

data/lib/paid/api_method.rb

@@ -0,0 +1,93 @@
+module Paid
+  class APIMethod
+
+    attr_accessor :path
+    attr_accessor :method
+    attr_accessor :params
+    attr_accessor :headers
+
+    attr_accessor :response_body
+    attr_accessor :response_code
+    attr_accessor :error
+
+    attr_accessor :api_key
+    attr_accessor :api_base
+
+    def initialize(method, path, params, headers, object, api_key=nil, api_base=nil)
+      @api_key = api_key || Paid.api_key
+      @api_base = api_base || Paid.api_base
+
+      @method = method.to_sym
+      @path = PathBuilder.build(path, object, params)
+      @params = ParamsBuilder.build(params)
+      @headers = HeadersBuilder.build(headers, @api_key, Paid.auth_header)
+    end
+
+    def execute
+      begin
+        response = Requester.request(method, url, params, headers)
+        @response_body = response.body
+        @response_code = response.code
+      rescue Exception => e
+        @response_body = e.http_body if e.respond_to?(:http_body)
+        @response_code = e.http_code if e.respond_to?(:http_code)
+        @error = compose_error(e)
+        raise @error
+      end
+
+      response_json
+    end
+
+    def url
+      "#{api_base}#{@path}"
+    end
+
+    def response_json
+      begin
+        json = Util.symbolize_keys(JSON.parse(@response_body))
+      rescue JSON::ParserError
+        raise APIError.new("Unable to parse the server response as JSON.", self)
+      end
+    end
+
+    def compose_error(error)
+      msg = "An error occured while making the API call."
+
+      case error
+      when RestClient::ExceptionWithResponse
+        return error_with_response(error)
+
+      when RestClient::RequestTimeout
+        msg = "The request timed out while making the API call."
+
+      when RestClient::ServerBrokeConnection
+        msg = "The connection to the server broke before the request completed."
+
+      when SocketError
+        msg = "An unexpected error occured while trying to connect to " \
+          "the API. You may be seeing this message because your DNS is " \
+          "not working. To check, try running 'host #{Paid.api_base}' "\
+          "from the command line."
+
+      else
+        msg = "An unexpected error occured. If this problem persists let us " \
+          "know at #{Paid.support_email}."
+      end
+
+      return APIConnectionError.new(msg, self)
+    end
+
+    # Handle a few common cases.
+    def error_with_response(error)
+      case @response_code
+      when 400, 404
+        return APIError.new("Invalid request. Please check the URL and parameters.", self)
+      when 401
+        return AuthenticationError.new("Authentication failed. Please check your API key and verify that it is correct.", self)
+      else
+        return APIError.new("An error occured while making the API call.", self)
+      end
+    end
+
+  end
+end