recurly 2.18.15 → 3.0.0.beta.1

data/lib/recurly/api/errors.rb

@@ -1,208 +0,0 @@
-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
-        @xml ||= begin
-          XML.new(response.body) if response and response.body and not response.body.empty?
-        rescue Recurly::XML::ParseError
-          nil
-        end
-      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_adapter.rb

@@ -1,111 +0,0 @@
-require 'cgi'
-require 'net/https'
-
-module Recurly
-  class API
-    module Net
-      module HTTPAdapter
-        # A hash of Net::HTTP settings configured before the request.
-        #
-        # @return [Hash]
-        def net_http
-          @net_http ||= {}
-        end
-
-        # Used to store any Net::HTTP settings.
-        #
-        # @example
-        #   Recurly::API.net_http = {
-        #     :verify_mode => OpenSSL::SSL::VERIFY_PEER,
-        #     :ca_path     => "/etc/ssl/certs",
-        #     :ca_file     => "/opt/local/share/curl/curl-ca-bundle.crt"
-        #   }
-        attr_writer :net_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 = headers.dup
-          head.update options[:head] if options[:head]
-          head.delete_if { |_, value| value.nil? }
-          uri = base_uri + uri
-          if options[:params] && !options[:params].empty?
-            pairs = options[:params].map { |key, value|
-              "#{CGI.escape key.to_s}=#{CGI.escape value.to_s}"
-            }
-            uri += "?#{pairs.join '&'}"
-          end
-          self.validate_uri!(uri)
-          request = METHODS[method].new uri.request_uri, head
-          request.basic_auth(*[Recurly.api_key, nil].flatten[0, 2])
-          if options[:body]
-            request['Content-Type'] = content_type
-            request.body = options[:body]
-          end
-          if options[:etag]
-            request['If-None-Match'] = options[:etag]
-          end
-          if options[:format]
-            request['Accept'] = FORMATS[options[:format]]
-          end
-          if options[:locale]
-            request['Accept-Language'] = options[:locale]
-          end
-          http = ::Net::HTTP.new uri.host, uri.port
-          http.use_ssl = uri.scheme == 'https'
-          net_http.each_pair { |key, value| http.send "#{key}=", value }
-
-          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
-        rescue Errno::ECONNREFUSED => e
-          raise Error, e.message
-        end
-      end
-    end
-
-    extend Net::HTTPAdapter
-  end
-end

data/lib/recurly/billing_info.rb

@@ -1,109 +0,0 @@
-module Recurly
-  # Represents an account's Billing Information. You normally want to use a token when creating billing information.
-  #
-  # Recurly Documentation: https://dev.recurly.com/docs/create-an-accounts-billing-info-token
-  class BillingInfo < Resource
-    BANK_ACCOUNT_ATTRIBUTES = %w(name_on_account account_type last_four routing_number).freeze
-    CREDIT_CARD_ATTRIBUTES = %w(number verification_value card_type year month first_six last_four).freeze
-    AMAZON_ATTRIBUTES = %w(amazon_billing_agreement_id amazon_region).freeze
-    PAYPAL_ATTRIBUTES = %w(paypal_billing_agreement_id).freeze
-    ROKU_ATTRIBUTES = %w(roku_billing_agreement_id last_four).freeze
-    SEPA_ATTRIBUTES = %w(iban).freeze
-    BACS_ATTRIBUTES = %w(account_number sort_code type).freeze
-    BECS_ATTRIBUTES = %w(account_number bsb_code type).freeze
-
-    # @return [Account]
-    belongs_to :account
-
-    define_attribute_methods %w(
-      first_name
-      last_name
-      company
-      address1
-      address2
-      city
-      state
-      zip
-      country
-      phone
-      vat_number
-      ip_address
-      ip_address_country
-      token_id
-      currency
-      geo_code
-      updated_at
-      external_hpp_type
-      gateway_token
-      gateway_code
-      fraud_session_id
-      three_d_secure_action_result_token_id
-      transaction_type
-      mandate_reference
-      tax_identifier
-      tax_identifier_type
-    ) | CREDIT_CARD_ATTRIBUTES | BANK_ACCOUNT_ATTRIBUTES | AMAZON_ATTRIBUTES | PAYPAL_ATTRIBUTES | ROKU_ATTRIBUTES | SEPA_ATTRIBUTES | BACS_ATTRIBUTES | BECS_ATTRIBUTES
-
-    # Verify an account's stored billing info
-    #
-    # @param [Hash] gateway_code (optional) is the code for the gateway to use for verification. If unspecified, a gateway will be selected using the normal rules.
-    # @return [Transaction]
-    # @raise [Invalid] Raise if the account's billing info cannot be verified
-    def verify(attrs = {})
-      Transaction.from_response API.post("#{path}/verify", attrs.empty? ? nil : Verify.to_xml(attrs))
-    end
-
-    # @return [String]
-    def inspect
-      attributes = self.class.attribute_names
-      case type
-      when 'credit_card'
-        attributes -= (AMAZON_ATTRIBUTES + PAYPAL_ATTRIBUTES + BANK_ACCOUNT_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-        attributes |= CREDIT_CARD_ATTRIBUTES
-      when 'paypal'
-        attributes -= (CREDIT_CARD_ATTRIBUTES | BANK_ACCOUNT_ATTRIBUTES + AMAZON_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-      when 'amazon'
-        attributes -= (CREDIT_CARD_ATTRIBUTES | BANK_ACCOUNT_ATTRIBUTES + PAYPAL_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-      when 'bank_account'
-        attributes -= (CREDIT_CARD_ATTRIBUTES + PAYPAL_ATTRIBUTES + AMAZON_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-        attributes |= BANK_ACCOUNT_ATTRIBUTES
-      when 'roku'
-        attributes -= (CREDIT_CARD_ATTRIBUTES + PAYPAL_ATTRIBUTES + AMAZON_ATTRIBUTES + BANK_ACCOUNT_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-        attributes |= ROKU_ATTRIBUTES
-      when 'sepa'
-        attributes -= (CREDIT_CARD_ATTRIBUTES + PAYPAL_ATTRIBUTES + AMAZON_ATTRIBUTES + BANK_ACCOUNT_ATTRIBUTES + ROKU_ATTRIBUTES + BACS_ATTRIBUTES + BECS_ATTRIBUTES)
-        attributes |= SEPA_ATTRIBUTES
-      when 'bacs'
-        attributes -= (CREDIT_CARD_ATTRIBUTES + PAYPAL_ATTRIBUTES + AMAZON_ATTRIBUTES + BANK_ACCOUNT_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BECS_ATTRIBUTES)
-        attributes |= BACS_ATTRIBUTES
-      when 'becs'
-        attributes -= (CREDIT_CARD_ATTRIBUTES + PAYPAL_ATTRIBUTES + AMAZON_ATTRIBUTES + BANK_ACCOUNT_ATTRIBUTES + ROKU_ATTRIBUTES + SEPA_ATTRIBUTES + BACS_ATTRIBUTES)
-        attributes |= BECS_ATTRIBUTES
-      end
-      super attributes
-    end
-
-    # @return ["credit_card", "paypal", "amazon", "bank_account", "roku", "sepa", "bacs", "becs", nil] The type of billing info.
-    def type
-      self[:type] || @type
-    end
-
-    class << self
-      # Overrides the inherited member_path method to allow for billing info's
-      # irregular URL structure.
-      #
-      # @return [String] The relative path to an account's billing info from the
-      #   API's base URI.
-      # @param uuid [String]
-      # @example
-      #   Recurly::BillingInfo.member_path "code"
-      #   # => "accounts/code/billing_info"
-      def member_path uuid
-        "accounts/#{uuid}/billing_info"
-      end
-    end
-
-    # Billing info is only writeable through an {Account} instance.
-    embedded!
-  end
-end

data/lib/recurly/coupon.rb

@@ -1,134 +0,0 @@
-module Recurly
-
-  # Recurly Documentation: https://dev.recurly.com/docs/list-active-coupons
-  class Coupon < Resource
-    BULK = 'bulk'.freeze
-    SINGLE_CODE = 'single_code'.freeze
-
-    # @macro [attach] scope
-    #   @scope class
-    #   @return [Pager<Coupon>] A pager that yields +$1+ coupons.
-    scope :redeemable, :state => :redeemable
-    scope :expired,    :state => :expired
-    scope :maxed_out,  :state => :maxed_out
-
-    # @return [Pager<Redemption>, []] A pager that yields Redemptions
-    has_many :redemptions
-
-    # @return [Pager<Coupon>, []] A pager that yields coupon-code type Coupons
-    has_many :unique_coupon_codes, class_name: :Coupon
-
-    define_attribute_methods %w(
-      id
-      coupon_code
-      name
-      state
-      discount_type
-      discount_percent
-      discount_in_cents
-      redeem_by_date
-      single_use
-      applies_for_months
-      duration
-      temporal_unit
-      temporal_amount
-      max_redemptions
-      max_redemptions_per_account
-      applies_to_all_plans
-      created_at
-      updated_at
-      plan_codes
-      description
-      invoice_description
-      applies_to_non_plan_charges
-      redemption_resource
-      coupon_type
-      unique_template_code
-      free_trial_amount
-      free_trial_unit
-    )
-    alias to_param coupon_code
-
-    # Redeem a coupon with a given account or account code.
-    #
-    # @return [true]
-    # @param account_or_code [Account, String]
-    # @param currency [String] Three-letter currency code
-    # @param extra_opts [Hash] extra options that go into the {Redemption}
-    # @example
-    #   coupon = Coupon.find(coupon_code)
-    #   coupon.redeem(account_code, 'USD', subscription_uuid: 'ab3b1dbabc3195')
-    #
-    #   coupon = Coupon.find(coupon_code)
-    #   account = Account.find(account_code)
-    #   coupon.redeem(account)
-    def redeem account_or_code, currency = nil, extra_opts={}
-      return false unless link? :redeem
-
-      account_code = if account_or_code.is_a? Account
-        account_or_code.account_code
-      else
-        account_or_code
-      end
-
-      redemption_options = {
-        :account_code => account_code,
-        :currency     => currency || Recurly.default_currency
-      }.merge(extra_opts)
-
-      redemption = Redemption.new(redemption_options)
-
-      Redemption.from_response follow_link(:redeem,
-        :body => redemption.to_xml
-      )
-    rescue API::UnprocessableEntity => e
-      redemption.apply_errors e
-      redemption
-    end
-
-    # Generate unique coupon codes on the server. This is based on the unique_template_code.
-    #
-    # @param amount [Integer]
-    # @return [Pager<Coupon>] A pager that yields the coupon-code type Coupons
-    # @example
-    #   unique_codes = coupon.generate(10)
-    #   unique_codes.each do |c|
-    #     puts c.coupon_code
-    #   end
-    def generate(amount)
-      builder = XML.new("<coupon/>")
-      builder.add_element 'number_of_unique_codes', amount
-
-      resp = follow_link(:generate,
-        :body => builder.to_s
-      )
-
-      Pager.new(Recurly::Coupon, uri: resp['location'], parent: self, etag: resp['ETag'])
-    end
-
-    # Redeem a coupon on the given account code
-    #
-    # @param account_code [String] Acccount's account code
-    # @param currency [String] Three-letter currency code
-    # @raise [Invalid] If the coupon cannot be redeemed
-    # @return [Redemption] The Coupon Redemption
-    def redeem!(account_code, currency = nil)
-      redemption = redeem(account_code, currency)
-      raise Invalid.new(self) unless redemption && redemption.persisted?
-      redemption
-    end
-
-    # Restores the coupon
-    def restore!
-      return false unless link? :restore
-      reload follow_link(:restore, body: self.to_xml(delta: true))
-    end
-
-    # Will return true if there are no limits on number of redemptions for this Coupon.
-    #
-    # @return [true, false]
-    def unlimited_redemptions_per_account?
-      !max_redemptions_per_account
-    end
-  end
-end