braintree 2.4.0 → 2.5.1

data/lib/braintree/error_result.rb

@@ -1,29 +1,15 @@
 module Braintree
-  # An ErrorResult will be returned from non-bang methods when
-  # validations fail. It will provide access to the params passed
-  # to the server. The params are primarily useful for re-populaing
-  # web forms when using transparent redirect. ErrorResult also
-  # provides access to the validation errors.
-  #
-  #   result = Braintree::Customer.create(:email => "invalid.email.address")
-  #   if result.success?
-  #     # have a SuccessfulResult
-  #   else
-  #     # have an ErrorResult
-  #     puts "Validations failed when attempting to create customer."
-  #     result.errors.for(:customer).each do |error|
-  #       puts error.message
-  #     end
-  #   end
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/result_objects
   class ErrorResult
 
     attr_reader :credit_card_verification, :transaction, :errors, :params, :message
 
-    def initialize(data) # :nodoc:
+    def initialize(gateway, data) # :nodoc:
+      @gateway = gateway
       @params = data[:params]
       @credit_card_verification = CreditCardVerification._new(data[:verification]) if data[:verification]
       @message = data[:message]
-      @transaction = Transaction._new(data[:transaction]) if data[:transaction]
+      @transaction = Transaction._new(gateway, data[:transaction]) if data[:transaction]
       @errors = Errors.new(data[:errors])
     end
 

data/lib/braintree/errors.rb

@@ -1,5 +1,5 @@
 module Braintree
-  # Provides access to errors from an ErrorResult.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/validation_errors
   class Errors
     include Enumerable
 
@@ -11,7 +11,6 @@ module Braintree
       @errors.deep_errors.each(&block)
     end
 
-    # Accesses validation errors for the given +scope+.
     def for(scope)
       @errors.for(scope)
     end

data/lib/braintree/exceptions.rb

@@ -2,46 +2,41 @@ module Braintree # :nodoc:
   # Super class for all Braintree exceptions.
   class BraintreeError < ::StandardError; end
 
-  # Raised when authentication fails. This may be caused by an incorrect <tt>Braintree::Configuration</tt>
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class AuthenticationError < BraintreeError; end
 
-  # Raised when the API key being used is not authorized to perform the attempted action according
-  # to the roles assigned to the user who owns the API key.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class AuthorizationError < BraintreeError; end
 
-  # Raised when the Braintree gem is not completely configured. See <tt>Braintree::Configuration</tt>.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class ConfigurationError < BraintreeError
     def initialize(setting, message) # :nodoc:
       super "Braintree::Configuration.#{setting} #{message}"
     end
   end
 
-  # Raised when the gateway is down for maintenance.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class DownForMaintenanceError < BraintreeError; end
 
-  # Raised from methods that confirm transparent request requests
-  # when the given query string cannot be verified. This may indicate
-  # an attempted hack on the merchant's transparent redirect
-  # confirmation URL.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class ForgedQueryString < BraintreeError; end
 
-  # Raised when a record could not be found.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class NotFoundError < BraintreeError; end
 
-  # Raised when an unexpected server error occurs.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class ServerError < BraintreeError; end
 
-  # Raised when the SSL certificate fails verification.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class SSLCertificateError < BraintreeError; end
 
-  # Raised when an error occurs that the client library is not built to handle.
-  # This shouldn't happen.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class UnexpectedError < BraintreeError; end
 
-  # Raised when a client library that has been End of Life'd is being used.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class UpgradeRequiredError < BraintreeError; end
 
-  # Raised from bang methods when validations fail.
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/general/exceptions
   class ValidationsFailed < BraintreeError
     attr_reader :error_result
 

data/lib/braintree/gateway.rb

@@ -0,0 +1,39 @@
+module Braintree
+  class Gateway # :nodoc:
+    attr_reader :config
+
+    def initialize(config)
+      if config.is_a?(Hash)
+        @config = Configuration.new config
+      elsif config.is_a?(Braintree::Configuration)
+        @config = config
+      else
+        raise ArgumentError, "config is an invalid type"
+      end
+    end
+
+    def address
+      AddressGateway.new(self)
+    end
+
+    def credit_card
+      CreditCardGateway.new(self)
+    end
+
+    def customer
+      CustomerGateway.new(self)
+    end
+
+    def subscription
+      SubscriptionGateway.new(self)
+    end
+
+    def transparent_redirect
+      TransparentRedirectGateway.new(self)
+    end
+
+    def transaction
+      TransactionGateway.new(self)
+    end
+  end
+end

data/lib/braintree/http.rb

@@ -1,7 +1,11 @@
 module Braintree
-  module Http # :nodoc:
+  class Http # :nodoc:
 
-    def self.delete(path)
+    def initialize(config)
+      @config = config
+    end
+
+    def delete(path)
       response = _http_do Net::HTTP::Delete, path
       if response.code.to_i == 200
         true
@@ -10,7 +14,7 @@ module Braintree
       end
     end
 
-    def self.get(path)
+    def get(path)
       response = _http_do Net::HTTP::Get, path
       if response.code.to_i == 200
         Xml.hash_from_xml(_body(response))
@@ -19,7 +23,7 @@ module Braintree
       end
     end
 
-    def self.post(path, params = nil)
+    def post(path, params = nil)
       response = _http_do Net::HTTP::Post, path, _build_xml(params)
       if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 422
         Xml.hash_from_xml(_body(response))
@@ -28,7 +32,7 @@ module Braintree
       end
     end
 
-    def self.put(path, params = nil)
+    def put(path, params = nil)
       response = _http_do Net::HTTP::Put, path, _build_xml(params)
       if response.code.to_i == 200 || response.code.to_i == 201 || response.code.to_i == 422
         Xml.hash_from_xml(_body(response))
@@ -37,65 +41,65 @@ module Braintree
       end
     end
 
-    def self._build_xml(params)
+    def _build_xml(params)
       return nil if params.nil?
       Braintree::Xml.hash_to_xml params
     end
 
-    def self._http_do(http_verb, path, body = nil)
-      connection = Net::HTTP.new(Configuration.server, Configuration.port)
-      if Configuration.ssl?
+    def _http_do(http_verb, path, body = nil)
+      connection = Net::HTTP.new(@config.server, @config.port)
+      if @config.ssl?
         connection.use_ssl = true
         connection.verify_mode = OpenSSL::SSL::VERIFY_PEER
-        connection.ca_file = Configuration.ca_file
+        connection.ca_file = @config.ca_file
         connection.verify_callback = proc { |preverify_ok, ssl_context| _verify_ssl_certificate(preverify_ok, ssl_context) }
       end
       connection.start do |http|
-        request = http_verb.new("#{Configuration.base_merchant_path}#{path}")
+        request = http_verb.new("#{@config.base_merchant_path}#{path}")
         request["Accept"] = "application/xml"
-        request["User-Agent"] = Configuration.user_agent
+        request["User-Agent"] = @config.user_agent
         request["Accept-Encoding"] = "gzip"
-        request["X-ApiVersion"] = Configuration::API_VERSION
-        request.basic_auth Configuration.public_key, Configuration.private_key
-        Configuration.logger.debug "[Braintree] [#{_current_time}] #{request.method} #{path}"
+        request["X-ApiVersion"] = @config.api_version
+        request.basic_auth @config.public_key, @config.private_key
+        @config.logger.debug "[Braintree] [#{_current_time}] #{request.method} #{path}"
         if body
           request["Content-Type"] = "application/xml"
           request.body = body
-          Configuration.logger.debug _format_and_sanitize_body_for_log(body)
+          @config.logger.debug _format_and_sanitize_body_for_log(body)
         end
         response = http.request(request)
-        Configuration.logger.info "[Braintree] [#{_current_time}] #{request.method} #{path} #{response.code}"
-        Configuration.logger.debug "[Braintree] [#{_current_time}] #{response.code} #{response.message}"
-        if Configuration.logger.level == Logger::DEBUG
-          Configuration.logger.debug _format_and_sanitize_body_for_log(_body(response))
+        @config.logger.info "[Braintree] [#{_current_time}] #{request.method} #{path} #{response.code}"
+        @config.logger.debug "[Braintree] [#{_current_time}] #{response.code} #{response.message}"
+        if @config.logger.level == Logger::DEBUG
+          @config.logger.debug _format_and_sanitize_body_for_log(_body(response))
         end
         response
       end
     end
 
-    def self._body(response)
+    def _body(response)
       if response.header["Content-Encoding"] == "gzip"
         Zlib::GzipReader.new(StringIO.new(response.body)).read
       else
-        raise UnexpectedError, "expected a gzip'd response"
+        raise UnexpectedError, "expected a gzipped response"
       end
     end
 
-    def self._current_time
+    def _current_time
       Time.now.utc.strftime("%d/%b/%Y %H:%M:%S %Z")
     end
 
-    def self._format_and_sanitize_body_for_log(input_xml)
+    def _format_and_sanitize_body_for_log(input_xml)
       formatted_xml = input_xml.gsub(/^/, "[Braintree] ")
       formatted_xml = formatted_xml.gsub(/<number>(.{6}).+?(.{4})<\/number>/, '<number>\1******\2</number>')
       formatted_xml = formatted_xml.gsub(/<cvv>.+?<\/cvv>/, '<cvv>***</cvv>')
       formatted_xml
     end
 
-    def self._verify_ssl_certificate(preverify_ok, ssl_context)
+    def _verify_ssl_certificate(preverify_ok, ssl_context)
       if preverify_ok != true || ssl_context.error != 0
         err_msg = "SSL Verification failed -- Preverify: #{preverify_ok}, Error: #{ssl_context.error_string} (#{ssl_context.error})"
-        Configuration.logger.error err_msg
+        @config.logger.error err_msg
         raise SSLCertificateError.new(err_msg)
       end
       true

data/lib/braintree/modification.rb

@@ -0,0 +1,23 @@
+module Braintree
+  class Modification # :nodoc:
+    include BaseModule
+
+    attr_reader :amount, :id, :number_of_billing_cycles, :quantity
+
+    class << self
+      protected :new
+      def _new(*args) # :nodoc:
+        self.new *args
+      end
+    end
+
+    def initialize(attributes) # :nodoc:
+      set_instance_variables_from_hash(attributes)
+      @amount = Util.to_big_decimal(amount)
+    end
+
+    def never_expires?
+      @never_expires
+    end
+  end
+end

data/lib/braintree/resource_collection.rb

@@ -1,5 +1,5 @@
 module Braintree
-  class ResourceCollection
+  class ResourceCollection # :nodoc:
     include Enumerable
 
     def initialize(response, &block) # :nodoc:

data/lib/braintree/subscription.rb

@@ -1,36 +1,16 @@
 module Braintree
-  # == Creating a Subscription
-  #
-  # At minimum, a plan_id and payment_method_token are required. Any other values not
-  # provided will be defaulted to the plan's values:
-  #
-  #  Braintree::Subscription.create(
-  #    :payment_method_token => "my_token",
-  #    :plan_id => "my_plan"
-  #  )
-  #
-  # Full example:
-  #
-  #  Braintree::Subscription.create(
-  #    :id => "my_id",
-  #    :payment_method_token => "my_token",
-  #    :plan_id => "my_plan",
-  #    :price => "1.00",
-  #    :trial_period => true,
-  #    :trial_duration => "2",
-  #    :trial_duration_unit => Subscription::TrialDurationUnit::Day
-  #  )
-  #
-  # == More Information
-  #
-  # For more detailed documentation on Subscriptions, see http://www.braintreepaymentsolutions.com/gateway/subscription-api
+  # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/overview
   class Subscription
     include BaseModule
 
     module Status
       Active = 'Active'
       Canceled = 'Canceled'
+      Expired = 'Expired'
       PastDue = 'Past Due'
+      Pending = 'Pending'
+
+      All = constants.map { |c| const_get(c) }
     end
 
     module TrialDurationUnit
@@ -38,111 +18,57 @@ module Braintree
       Month = "month"
     end
 
-    attr_reader :price, :plan_id, :id, :status, :payment_method_token, :merchant_account_id
+    attr_reader :days_past_due, :price, :plan_id, :id, :status, :payment_method_token, :merchant_account_id
     attr_reader :first_billing_date, :next_billing_date, :billing_period_start_date, :billing_period_end_date
     attr_reader :trial_period, :trial_duration, :trial_duration_unit
     attr_reader :failure_count
     attr_reader :transactions
+    attr_reader :next_bill_amount
+    attr_reader :number_of_billing_cycles, :billing_day_of_month
+    attr_reader :add_ons, :discounts
 
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/cancel
     def self.cancel(subscription_id)
-      response = Http.put "/subscriptions/#{subscription_id}/cancel"
-      if response[:subscription]
-        SuccessfulResult.new(:subscription => _new(response[:subscription]))
-      elsif response[:api_error_response]
-        ErrorResult.new(response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :subscription or :api_error_response"
-      end
-    rescue NotFoundError
-      raise NotFoundError, "subscription with id #{subscription_id.inspect} not found"
+      Configuration.gateway.subscription.cancel(subscription_id)
     end
 
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/create
     def self.create(attributes)
-      Util.verify_keys(_create_signature, attributes)
-      _do_create "/subscriptions", :subscription => attributes
+      Configuration.gateway.subscription.create(attributes)
     end
 
-    # Finds the subscription with the given id. Raises a Braintree::NotFoundError
-    # if the subscription cannot be found.
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/search
     def self.find(id)
-      response = Http.get "/subscriptions/#{id}"
-      _new(response[:subscription])
-    rescue NotFoundError
-      raise NotFoundError, "subscription with id #{id.inspect} not found"
+      Configuration.gateway.subscription.find(id)
     end
 
     def self.retry_charge(subscription_id, amount=nil)
-      attributes = {
-        :amount => amount,
-        :subscription_id => subscription_id,
-        :type => Transaction::Type::Sale
-      }
-
-      Transaction.send(:_do_create, "/transactions", :transaction => attributes)
+      Configuration.gateway.transaction.retry_subscription_charge(subscription_id, amount)
     end
 
-    # Allows searching on subscriptions. There are two types of fields that are searchable: text and
-    # multiple value fields. Searchable text fields are:
-    # - plan_id
-    # - days_past_due
-    #
-    # Searchable multiple value fields are:
-    # - status
-    #
-    # For text fields, you can search using the following operators: is, is_not, starts_with, ends_with
-    # and contains. For mutiple value fields, you can search using the in operator. An example:
-    #
-    #  Subscription.search do |s|
-    #    s.plan_id.starts_with "abc"
-    #    s.days_past_due.is "30"
-    #    s.status.in [Subscription::Status::PastDue]
-    #  end
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/search
     def self.search(&block)
-      search = SubscriptionSearch.new
-      block.call(search) if block
-
-      response = Http.post "/subscriptions/advanced_search_ids", {:search => search.to_hash}
-      ResourceCollection.new(response) { |ids| _fetch_subscriptions(search, ids) }
-    end
-
-    def self._fetch_subscriptions(search, ids)
-      search.ids.in ids
-      response = Http.post "/subscriptions/advanced_search", {:search => search.to_hash}
-      attributes = response[:subscriptions]
-      Util.extract_attribute_as_array(attributes, :subscription).map { |attrs| _new(attrs) }
+      Configuration.gateway.subscription.search(&block)
     end
 
+    # See http://www.braintreepaymentsolutions.com/docs/ruby/subscriptions/update
     def self.update(subscription_id, attributes)
-      Util.verify_keys(_update_signature, attributes)
-      response = Http.put "/subscriptions/#{subscription_id}", :subscription => attributes
-      if response[:subscription]
-        SuccessfulResult.new(:subscription => _new(response[:subscription]))
-      elsif response[:api_error_response]
-         ErrorResult.new(response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :subscription or :api_error_response"
-      end
+      Configuration.gateway.subscription.update(subscription_id, attributes)
     end
 
-    def self._create_signature # :nodoc:
-      [
-        :id,
-        :merchant_account_id,
-        :payment_method_token,
-        :plan_id,
-        :price,
-        :trial_duration,
-        :trial_duration_unit,
-        :trial_period
-      ]
+    def initialize(gateway, attributes) # :nodoc:
+      @gateway = gateway
+      set_instance_variables_from_hash(attributes)
+      @price = Util.to_big_decimal(price)
+      transactions.map! { |attrs| Transaction._new(gateway, attrs) }
+      add_ons.map! { |attrs| AddOn._new(attrs) }
+      discounts.map! { |attrs| Discount._new(attrs) }
     end
 
-    def initialize(attributes) # :nodoc:
-      _init attributes
-      transactions.map! {|attrs| Transaction._new(attrs) }
+    def never_expires?
+      @never_expires
     end
 
-
     # True if <tt>other</tt> has the same id.
     def ==(other)
       return false unless other.is_a?(Subscription)
@@ -155,31 +81,5 @@ module Braintree
         self.new *args
       end
     end
-
-    def self._do_create(url, params) # :nodoc:
-      response = Http.post url, params
-      if response[:subscription]
-        SuccessfulResult.new(:subscription => new(response[:subscription]))
-      elsif response[:api_error_response]
-        ErrorResult.new(response[:api_error_response])
-      else
-        raise UnexpectedError, "expected :subscription or :api_error_response"
-      end
-    end
-
-    def _init(attributes) # :nodoc:
-      set_instance_variables_from_hash(attributes)
-      @price = Util.to_big_decimal(price)
-    end
-
-    def self._update_signature # :nodoc:
-      [
-        :id,
-        :merchant_account_id,
-        :payment_method_token,
-        :plan_id,
-        :price
-      ]
-    end
   end
 end