recurly 0.4.16 → 2.0.0

data/lib/recurly/add_on.rb

@@ -0,0 +1,20 @@
+module Recurly
+  class AddOn < Resource
+    # @return [Plan]
+    belongs_to :plan
+
+    define_attribute_methods %w(
+      add_on_code
+      name
+      default_quantity
+      unit_amount_in_cents
+      display_quantity_on_hosted_page
+      created_at
+    )
+    alias to_param add_on_code
+
+    # Add-ons are only writeable and readable through {Plan} instances.
+    embedded!
+    private_class_method :find
+  end
+end

data/lib/recurly/adjustment.rb

@@ -0,0 +1,51 @@
+module Recurly
+  class Adjustment < Resource
+    # @macro [attach] scope
+    #   @scope class
+    #   @return [Pager<Adjustment>] a pager that yields +$1+.
+    scope :charges,  :type  => 'charge'
+    scope :credits,  :type  => 'credit'
+
+    scope :pending,  :state => 'pending'
+    scope :invoiced, :state => 'invoiced'
+
+    # @return [Account, nil]
+    belongs_to :account
+    # @return [Invoice, nil]
+    belongs_to :invoice
+
+    define_attribute_methods %w(
+      uuid
+      description
+      accounting_code
+      origin
+      unit_amount_in_cents
+      quantity
+      discount_in_cents
+      tax_in_cents
+      total_in_cents
+      currency
+      taxable
+      start_date
+      end_date
+      created_at
+    )
+    alias to_param uuid
+
+    # @return ["charge", "credit", nil] The type of adjustment.
+    attr_reader :type
+
+    # Adjustments should be built through {Account} instances.
+    #
+    # @return [Adjustment] A new adjustment.
+    # @example
+    #   account.adjustments.new attributes
+    # @see Resource#initialize
+    def initialize attributes = {}
+      super({ :currency => Recurly.default_currency }.merge attributes)
+    end
+
+    # Adjustments are only writeable through an {Account} instance.
+    embedded!
+  end
+end

data/lib/recurly/api.rb

@@ -0,0 +1,73 @@
+module Recurly
+  # The API class handles all requests to the Recurly API. While most of its
+  # functionality is leveraged by the Resource class, it can be used directly,
+  # as well.
+  #
+  # Requests are made with methods named after the four main HTTP verbs
+  # recognized by the Recurly API.
+  #
+  # @example
+  #   Recurly::API.get 'accounts'             # => #<Net::HTTPOK ...>
+  #   Recurly::API.post 'accounts', xml_body  # => #<Net::HTTPCreated ...>
+  #   Recurly::API.put 'accounts/1', xml_body # => #<Net::HTTPOK ...>
+  #   Recurly::API.delete 'accounts/1'        # => #<Net::HTTPNoContent ...>
+  class API
+    require 'recurly/api/errors'
+
+    @@base_uri = "https://api.recurly.com/v2/"
+
+    class << self
+      # @return [String]
+      attr_accessor :accept_language
+
+      # @return [Net::HTTPOK, Net::HTTPResponse]
+      # @raise [ResponseError] With a non-2xx status code.
+      def head uri, params = {}, options = {}
+        request :head, uri, { :params => params }.merge(options)
+      end
+
+      # @return [Net::HTTPOK, Net::HTTPResponse]
+      # @raise [ResponseError] With a non-2xx status code.
+      def get uri, params = {}, options = {}
+        request :get, uri, { :params => params }.merge(options)
+      end
+
+      # @return [Net::HTTPCreated, Net::HTTPResponse]
+      # @raise [ResponseError] With a non-2xx status code.
+      def post uri, body = nil, options = {}
+        request :post, uri, { :body => body.to_s }.merge(options)
+      end
+
+      # @return [Net::HTTPOK, Net::HTTPResponse]
+      # @raise [ResponseError] With a non-2xx status code.
+      def put uri, body = nil, options = {}
+        request :put, uri, { :body => body.to_s }.merge(options)
+      end
+
+      # @return [Net::HTTPNoContent, Net::HTTPResponse]
+      # @raise [ResponseError] With a non-2xx status code.
+      def delete uri, options = {}
+        request :delete, uri, options
+      end
+
+      # @return [URI::Generic]
+      def base_uri
+        URI.parse @@base_uri
+      end
+
+      # @return [String]
+      def user_agent
+        "Recurly/#{Version::VERSION}; #{RUBY_DESCRIPTION}"
+      end
+
+      private
+
+      def accept
+        'application/xml'
+      end
+      alias content_type accept
+    end
+  end
+end
+
+require 'recurly/api/net_http'

data/lib/recurly/api/errors.rb

@@ -0,0 +1,205 @@
+require 'cgi'
+
+module Recurly
+  class API
+    # The superclass to all errors that occur when making an API request.
+    class ResponseError < Error
+      attr_reader :request
+      attr_reader :response
+
+      def initialize request, response
+        @request, @response = request, response
+      end
+
+      def code
+        response.code.to_i if response
+      end
+
+      def to_s
+        if description
+          return CGI.unescapeHTML [description, details].compact.join(' ')
+        end
+
+        return super unless code
+        "%d %s (%s %s)" % [
+          code, http_error, request.method, API.base_uri + request.path
+        ]
+      end
+
+      def symbol
+        xml and xml.root and xml.text '/error/symbol'
+      end
+
+      def description
+        xml and xml.root and xml.text '/error/description'
+      end
+
+      def details
+        xml and xml.root and xml.text '/error/details'
+      end
+
+      private
+
+      def http_error
+        Helper.demodulize self.class.name.gsub(/([a-z])([A-Z])/, '\1 \2')
+      end
+
+      def xml
+        return @xml if defined? @xml
+        @xml = (XML.new(response.body) if response && !response.body.empty?)
+      end
+    end
+
+    # === 3xx Redirection
+    #
+    # Not an error, per se, but should result in one in the normal course of
+    # API interaction.
+    class Redirection < ResponseError
+    end
+
+    # === 304 Not Modified
+    #
+    # Catchably raised when a request is made with an ETag.
+    class NotModified < ResponseError
+    end
+
+    # === 4xx Client Error
+    #
+    # The superclass to all client errors (responses with status code 4xx).
+    class ClientError < ResponseError
+    end
+
+    # === 400 Bad Request
+    #
+    # The request was invalid or could not be understood by the server.
+    # Resubmitting the request will likely result in the same error.
+    class BadRequest < ClientError
+    end
+
+    # === 401 Unauthorized
+    #
+    # The API key is missing or invalid for the given request.
+    class Unauthorized < ClientError
+      def description
+        response.body.strip
+      end
+    end
+
+    # === 402 Payment Required
+    #
+    # Your Recurly account is in production mode but is not in good standing.
+    # Please pay any outstanding invoices.
+    class PaymentRequired < ClientError
+    end
+
+    # === 403 Forbidden
+    #
+    # The login is attempting to perform an action it does not have privileges
+    # to access. The login credentials are correct.
+    class Forbidden < ClientError
+    end
+
+    # === 404 Not Found
+    #
+    # The resource was not found. This may be returned if the given account
+    # code or subscription plan does not exist. The response body will explain
+    # which resource was not found.
+    class NotFound < ClientError
+    end
+
+    # === 405 Method Not Allowed
+    #
+    # A method was attempted where it is not allowed.
+    #
+    # If this is raised, there may be a bug with the client library or with
+    # the server. Please contact support@recurly.com or
+    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
+    class MethodNotAllowed < ClientError
+    end
+
+    # === 406 Not Acceptable
+    #
+    # The request content type was not acceptable.
+    #
+    # If this is raised, there may be a bug with the client library or with
+    # the server. Please contact support@recurly.com or
+    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
+    class NotAcceptable < ClientError
+    end
+
+    # === 412 Precondition Failed
+    #
+    # The request was unsuccessful because a condition was not met. For
+    # example, this message may be returned if you attempt to cancel a
+    # subscription for an account that has no subscription.
+    class PreconditionFailed < ClientError
+    end
+
+    # === 415 Unsupported Media Type
+    #
+    # The request body was not recognized as XML.
+    #
+    # If this is raised, there may be a bug with the client library or with
+    # the server. Please contact support@recurly.com or
+    # {file a bug}[https://github.com/recurly/recurly-client-ruby/issues].
+    class UnsupportedMediaType < ClientError
+    end
+
+    # === 422 Unprocessable Entity
+    #
+    # Could not process a POST or PUT request because the request is invalid.
+    # See the response body for more details.
+    class UnprocessableEntity < ClientError
+    end
+
+    # === 5xx Server Error
+    #
+    # The superclass to all server errors (responses with status code 5xx).
+    class ServerError < ResponseError
+    end
+
+    # === 500 Internal Server Error
+    #
+    # The server encountered an error while processing your request and failed.
+    class InternalServerError < ServerError
+    end
+
+    # === 502 Gateway Error
+    #
+    # The load balancer or web server had trouble connecting to the Recurly.
+    # Please try the request again.
+    class GatewayError < ServerError
+    end
+
+    # === 503 Service Unavailable
+    #
+    # The service is temporarily unavailable. Please try the request again.
+    class ServiceUnavailable < ServerError
+    end
+
+    # Error mapping by status code.
+    ERRORS = Hash.new { |hash, code|
+      unless hash.key? code
+        case code
+          when 400...500 then ClientError
+          when 500...600 then ServerError
+          else                ResponseError
+        end
+      end
+    }.update(
+      304 => NotModified,
+      400 => BadRequest,
+      401 => Unauthorized,
+      402 => PaymentRequired,
+      403 => Forbidden,
+      404 => NotFound,
+      406 => NotAcceptable,
+      412 => PreconditionFailed,
+      415 => UnsupportedMediaType,
+      422 => UnprocessableEntity,
+      500 => InternalServerError,
+      502 => GatewayError,
+      503 => ServiceUnavailable
+    ).freeze
+  end
+end

data/lib/recurly/api/net_http.rb

@@ -0,0 +1,77 @@
+require 'net/https'
+
+module Recurly
+  class API
+    module Net
+      module HTTP
+        private
+
+        METHODS = {
+          :head   => ::Net::HTTP::Head,
+          :get    => ::Net::HTTP::Get,
+          :post   => ::Net::HTTP::Post,
+          :put    => ::Net::HTTP::Put,
+          :delete => ::Net::HTTP::Delete
+        }
+
+        def request method, uri, options = {}
+          head = { 'Accept' => accept, 'User-Agent' => user_agent }
+          accept_language and head['Accept-Language'] ||= accept_language
+          head.update options[:head] if options[:head]
+          uri = base_uri + uri
+          if options[:params] && !options[:params].empty?
+            uri += "?#{options[:params].map { |k, v| "#{k}=#{v}" }.join '&' }"
+          end
+          request = METHODS[method].new uri.request_uri, head
+          request.basic_auth Recurly.api_key, nil
+          if options[:body]
+            head['Content-Type'] = content_type
+            request.body = options[:body]
+          end
+          http = ::Net::HTTP.new uri.host, uri.port
+          http.use_ssl = uri.scheme == 'https'
+
+          if Recurly.logger
+            Recurly.log :info, "===> %s %s" % [request.method, uri]
+            headers = request.to_hash
+            headers['authorization'] &&= ['Basic [FILTERED]']
+            Recurly.log :debug, headers.inspect
+            if request.body && !request.body.empty?
+              Recurly.log :debug, XML.filter(request.body)
+            end
+            start_time = Time.now
+          end
+
+          response = http.start { http.request request }
+          code = response.code.to_i
+
+          if Recurly.logger
+            latency = (Time.now - start_time) * 1_000
+            level = case code
+              when 200...300 then :info
+              when 300...400 then :warn
+              when 400...500 then :error
+              else                :fatal
+            end
+            Recurly.log level, "<=== %d %s (%.1fms)" % [
+              code,
+              response.class.name[9, response.class.name.length].gsub(
+                /([a-z])([A-Z])/, '\1 \2'
+              ),
+              latency
+            ]
+            Recurly.log :debug, response.to_hash.inspect
+            Recurly.log :debug, response.body if response.body
+          end
+
+          case code
+            when 200...300 then response
+            else                raise ERRORS[code].new request, response
+          end
+        end
+      end
+    end
+
+    extend Net::HTTP
+  end
+end

data/lib/recurly/billing_info.rb

@@ -1,49 +1,52 @@
 module Recurly
-  class BillingInfo < AccountBase
-    self.element_name = "billing_info"
+  class BillingInfo < Resource
+    # @return [Account]
+    belongs_to :account
 
-    def self.known_attributes
-      [
-        "first_name",
-        "last_name",
-        "address1",
-        "address2",
-        "city",
-        "state",
-        "zip",
-        "country",
-        "phone",
-        "ip_address",
-        "vat_number"
-      ]
-    end
+    define_attribute_methods %w(
+      first_name
+      last_name
+      company
+      address1
+      address2
+      city
+      state
+      zip
+      country
+      phone
+      vat_number
+      ip_address
+      ip_address_country
+      card_type
+      year
+      month
+      start_year
+      start_month
+      issue_number
+      first_six
+      last_four
+      paypal_billing_agreement_id
+    )
 
-    # define attributes for inner CreditCard type
-    class CreditCard < Base
-      def self.known_attributes
-        [
-          "number",
-          "last_four",
-          "type",
-          "verification_value",
-          "month",
-          "year",
-          "start_month",
-          "start_year",
-          "issue_number"
-        ]
-      end
-    end
+    # @return ["credit_card", "paypal", nil] The type of billing info.
+    attr_reader :type
 
-    # initialize associations
-    def initialize(attributes = {}, persisted = false)
-      attributes = attributes.with_indifferent_access
-      attributes[:credit_card] ||= {}
-      super
+    # @return [String]
+    def inspect
+      attributes = self.class.attribute_names
+      case type
+      when 'credit_card'
+        attributes -= %w(paypal_billing_agreement_id)
+      when 'paypal'
+        attributes -= %w(
+          card_type year month start_year start_month issue_number
+          first_six last_four
+        )
+      end
+      super attributes
     end
 
-    def update_only
-      true
-    end
+    # Billing info is only writeable through an {Account} instance.
+    embedded!
   end
-end
+end