braintree 1.0.0

data/lib/braintree/transaction/address_details.rb

@@ -0,0 +1,15 @@
+module Braintree
+  class Transaction
+    class AddressDetails # :nodoc:
+      include BaseModule
+      
+      attr_reader :first_name, :last_name, :company,
+        :street_address, :extended_address, :locality, :region,
+        :postal_code, :country_name
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/transaction/credit_card_details.rb

@@ -0,0 +1,22 @@
+module Braintree
+  class Transaction
+    class CreditCardDetails # :nodoc:
+      include BaseModule
+      
+      attr_reader :bin, :card_type, :expiration_month,
+        :expiration_year, :issuer_location, :last_4, :token
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+      
+      def expiration_date
+        "#{expiration_month}/#{expiration_year}"
+      end
+
+      def masked_number
+        "#{bin}******#{last_4}"
+      end
+    end
+  end
+end

data/lib/braintree/transaction/customer_details.rb

@@ -0,0 +1,13 @@
+module Braintree
+  class Transaction
+    class CustomerDetails # :nodoc:
+      include BaseModule
+      
+      attr_reader :company, :email, :fax, :first_name, :id, :last_name, :phone, :website
+
+      def initialize(attributes)
+        set_instance_variables_from_hash attributes unless attributes.nil?
+      end
+    end
+  end
+end

data/lib/braintree/transparent_redirect.rb

@@ -0,0 +1,110 @@
+module Braintree
+  # The TransparentRedirect module provides methods to build the tr_data param
+  # that must be submitted when using the transparent redirect API. For more information
+  # about transparent redirect, see (TODO).
+  #
+  # You must provide a redirect_url that the gateway will redirect the user to when the
+  # action is complete.
+  #
+  #   tr_data = Braintree::TransparentRedirect.create_customer_data(
+  #     :redirect_url => "http://example.com/redirect_back_to_merchant_site
+  #   )
+  #
+  # In addition to the redirect_url, any data that needs to be protected from user tampering
+  # should be included in the tr_data. For example, to prevent the user from tampering with the transaction
+  # amount, include the amount in the tr_data.
+  #
+  #   tr_data = Braintree::TransparentRedirect.transaction_data(
+  #     :redirect_url => "http://example.com/complete_transaction",
+  #     :transaction => {:amount => "100.00"}
+  #   )
+  module TransparentRedirect
+    TransparentRedirectKeys = [:redirect_url] # :nodoc:
+    CreateCustomerSignature = TransparentRedirectKeys + [{:customer => Customer._create_signature}] # :nodoc:
+    UpdateCustomerSignature = TransparentRedirectKeys + [:customer_id, {:customer => Customer._update_signature}] # :nodoc:
+    TransactionSignature = TransparentRedirectKeys + [{:transaction => Transaction._create_signature}] # :nodoc:
+    CreateCreditCardSignature = TransparentRedirectKeys + [{:credit_card => CreditCard._create_signature}] # :nodoc:
+    UpdateCreditCardSignature = TransparentRedirectKeys + [:payment_method_token, {:credit_card => CreditCard._update_signature}] # :nodoc:
+
+    # Returns the tr_data string for creating a credit card.
+    def self.create_credit_card_data(params)
+      Util.verify_keys(CreateCreditCardSignature, params)
+      _data(params)
+    end
+
+    # Returns the tr_data string for creating a customer.
+    def self.create_customer_data(params)
+      Util.verify_keys(CreateCustomerSignature, params)
+      _data(params)
+    end
+
+    # Returns the tr_data string for creating a transaction.
+    def self.transaction_data(params)
+      Util.verify_keys(TransactionSignature, params)
+      transaction_type = params[:transaction] && params[:transaction][:type]
+      unless %w[sale credit].include?(transaction_type)
+        raise ArgumentError, "expected transaction[type] of sale or credit, was: #{transaction_type.inspect}"
+      end
+      _data(params)
+    end
+
+    # Returns the tr_data string for updating a credit card.
+    # The payment_method_token of the credit card to update is required.
+    #
+    #   tr_data = Braintree::TransparentRedirect.update_credit_card_data(
+    #     :redirect_url => "http://example.com/redirect_here",
+    #     :payment_method_token => "token123"
+    #   )
+    def self.update_credit_card_data(params)
+      Util.verify_keys(UpdateCreditCardSignature, params)
+      unless params[:payment_method_token]
+        raise ArgumentError, "expected params to contain :payment_method_token of payment method to update"
+      end
+      _data(params)
+    end
+
+    # Returns the tr_data string for updating a customer.
+    # The customer_id of the customer to update is required.
+    #
+    #   tr_data = Braintree::TransparentRedirect.update_customer_data(
+    #     :redirect_url => "http://example.com/redirect_here",
+    #     :customer_id => "customer123"
+    #   )
+    def self.update_customer_data(params)
+      Util.verify_keys(UpdateCustomerSignature, params)
+      unless params[:customer_id]
+        raise ArgumentError, "expected params to contain :customer_id of customer to update"
+      end
+      _data(params)
+    end
+
+    def self.parse_and_validate_query_string(query_string) # :nodoc:
+      params = Util.symbolize_keys(Util.parse_query_string(query_string))
+      query_string_without_hash = query_string[/(.*)&hash=.*/, 1]
+      if _hash(query_string_without_hash) == params[:hash]
+        if params[:http_status] == '200'
+          params
+        else
+          Util.raise_exception_for_status_code(params[:http_status])
+        end
+      else
+        raise ForgedQueryString
+      end
+    end
+
+    def self._data(params) # :nodoc:
+      raise ArgumentError, "expected params to contain :redirect_url" unless params[:redirect_url]
+      tr_data_segment = Util.hash_to_query_string(params.merge(
+        :api_version => Configuration::API_VERSION,
+        :time => Time.now.utc.strftime("%Y%m%d%H%M%S"),
+        :public_key => Configuration.public_key
+      ))
+      tr_data_hash = _hash(tr_data_segment)
+      "#{tr_data_hash}|#{tr_data_segment}"
+    end
+    
+    def self._hash(string) # :nodoc:
+      ::Braintree::Digest.hexdigest(string)
+    end
+  end
+end

data/lib/braintree/util.rb

@@ -0,0 +1,94 @@
+module Braintree
+  module Util # :nodoc:
+    def self.extract_attribute_as_array(hash, attribute)
+      value = hash.delete(attribute)
+      value.is_a?(Array) ? value : [value]
+    end
+
+    def self.hash_to_query_string(hash, namespace = nil)
+      hash.collect do |key, value|
+        full_key = namespace ? "#{namespace}[#{key}]" : key
+        if value.is_a?(Hash)
+          hash_to_query_string(value, full_key)
+        else
+          url_encode(full_key) + "=" + url_encode(value)
+        end
+      end.sort * '&'
+    end
+    
+    def self.parse_query_string(qs)
+      qs.split('&').inject({}) do |result, couplet|
+        pair = couplet.split('=')
+        result[CGI.unescape(pair[0]).to_sym] = CGI.unescape(pair[1])
+        result
+      end
+    end
+    
+    def self.url_encode(text)
+      CGI.escape text.to_s
+    end
+
+    def self.symbolize_keys(hash)
+      hash.each do |key, value|
+        hash.delete(key)
+        hash[key.to_sym] = value
+        if value.is_a?(Hash)
+          symbolize_keys(value)
+        elsif value.is_a?(Array) && value.all? { |v| v.is_a?(Hash) }
+          value.each { |v| symbolize_keys(v) }
+        end
+      end 
+      hash
+    end
+    
+    def self.raise_exception_for_status_code(status_code)
+      case status_code.to_i
+      when 401
+        raise AuthenticationError
+      when 403
+        raise AuthorizationError
+      when 404
+        raise NotFoundError
+      when 500
+        raise ServerError
+      when 503
+        raise DownForMaintenanceError
+      else
+        raise UnexpectedError, "Unexpected HTTP_RESPONSE #{status_code.to_i}"
+      end
+    end
+    
+    def self.verify_keys(valid_keys, hash)
+      invalid_keys = _flatten_hash_keys(hash) - _flatten_valid_keys(valid_keys)
+      if invalid_keys.any?
+        sorted = invalid_keys.sort_by { |k| k.to_s }.join(", ")
+        raise ArgumentError, "invalid keys: #{sorted}"
+      end
+    end
+    
+    def self._flatten_valid_keys(valid_keys, namespace = nil)
+      valid_keys.inject([]) do |result, key|
+        if key.is_a?(Hash)
+          full_key = key.keys[0]
+          full_key = (namespace ? "#{namespace}[#{full_key}]" : full_key)
+          result += _flatten_valid_keys(key.values[0], full_key)
+        else
+          result << (namespace ? "#{namespace}[#{key}]" : key.to_s)
+        end
+        result
+      end.sort
+    end
+    
+    def self._flatten_hash_keys(hash, namespace = nil)
+      hash.inject([]) do |result, (key, value)|
+        full_key = (namespace ? "#{namespace}[#{key}]" : key.to_s)
+        if value.is_a?(Hash)
+          result += _flatten_hash_keys(value, full_key)
+        else
+          result << full_key
+        end
+        result
+      end.sort
+    end
+  end
+end

data/lib/braintree/validation_error.rb

@@ -0,0 +1,15 @@
+module Braintree
+  class ValidationError
+    include BaseModule
+
+    attr_reader :attribute, :code, :message
+
+    def initialize(attributes)
+      set_instance_variables_from_hash attributes
+    end
+    
+    def inspect # :nodoc:
+      "#<#{self.class} (#{code}) #{message}>"
+    end
+  end
+end

data/lib/braintree/validation_error_collection.rb

@@ -0,0 +1,80 @@
+module Braintree
+  # A collection of validation errors.
+  #
+  #   result = Braintree::Customer.create(
+  #     :email => "invalid",
+  #     :credit_card => {
+  #       :number => "invalidnumber",
+  #       :billing_address => {
+  #         :country_name => "invalid"
+  #       }
+  #     }
+  #   )
+  #   result.success?
+  #   #=> false
+  #   result.errors.for(:customer).on(:email)
+  #   #=> [#<Braintree::ValidationError (81604) Email is an invalid format.>]
+  #   result.errors.for(:customer).for(:credit_card).on(:number)
+  #   #=> [#<Braintree::ValidationError (81715) Credit card number is invalid.>]
+  #   result.errors.for(:customer).for(:credit_card).for(:billing_address).on(:country_name)
+  #   #=> [#<Braintree::ValidationError (91803) Country name is not an accepted country.>]
+  class ValidationErrorCollection
+    include Enumerable
+  
+    def initialize(data) # :nodoc:
+      @errors = data[:errors].map { |hash| Braintree::ValidationError.new(hash) }
+      @nested = {}
+      data.keys.each do |key|
+        next if key == :errors
+        @nested[key] = ValidationErrorCollection.new(data[key])
+      end
+    end
+    
+    # Accesses the error at the given index.
+    def [](index)
+      @errors[index]
+    end
+
+    def deep_size # :nodoc:
+      size + @nested.values.inject(0) { |count, error_collection| count + error_collection.deep_size }
+    end
+  
+    # Iterates over errors at the current level. Nested errors will not be yielded.
+    def each(&block)
+      @errors.each(&block)
+    end
+
+    # Returns a ValidationErrorCollection of errors nested under the given nested_key.
+    # Returns nil if there are not any errors nested under the given key.
+    def for(nested_key)
+      @nested[nested_key]
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class} errors#{_inner_inspect}>"
+    end
+
+    # Returns an array of ValidationError objects on the given attribute.
+    def on(attribute)
+      @errors.select { |error| error.attribute == attribute.to_s }
+    end
+  
+    # The number of errors at this level. This does not include nested errors.
+    def size
+      @errors.size
+    end  
+
+    def _inner_inspect(scope = []) # :nodoc:
+      all = []
+      scope_string = scope.join("/")
+      if @errors.any?
+        all << "#{scope_string}:[" + @errors.map { |e| "(#{e.code}) #{e.message}" }.join(", ") + "]"
+      end
+      @nested.each do |key, values|
+        all << values._inner_inspect(scope + [key])
+      end
+      all.join(", ")
+    end
+  end  
+end
+

data/lib/braintree/version.rb

@@ -0,0 +1,9 @@
+module Braintree
+  module Version
+    Major = 1
+    Minor = 0
+    Tiny = 0
+    
+    String = "#{Major}.#{Minor}.#{Tiny}"
+  end
+end

data/lib/braintree/xml.rb

@@ -0,0 +1,12 @@
+module Braintree
+  module Xml # :nodoc:
+    def self.hash_from_xml(xml)
+      Parser.hash_from_xml(xml)
+    end
+
+    def self.hash_to_xml(hash)
+      Generator.hash_to_xml(hash)
+    end
+  end
+end
+

data/lib/braintree/xml/generator.rb

@@ -0,0 +1,80 @@
+# Portions of this code were copied and modified from Ruby on Rails, released
+# under the MIT license, copyright (c) 2005-2009 David Heinemeier Hansson
+module Braintree
+  module Xml
+    module Generator # :nodoc:
+      XML_TYPE_NAMES = {
+        "Fixnum"     => "integer",
+        "Bignum"     => "integer",
+        "TrueClass"  => "boolean",
+        "FalseClass" => "boolean",
+        "DateTime"   => "datetime",
+        "Time"       => "datetime",
+      }
+      XML_FORMATTING = {
+        "symbol"   => Proc.new { |symbol| symbol.to_s },
+        "datetime" => Proc.new { |time| time.xmlschema },
+      }
+      
+      def self.hash_to_xml(hash)
+        root, contents = hash.keys[0], hash.values[0]
+
+        if contents.is_a?(String)
+          builder = Builder::XmlMarkup.new
+          builder.__send__(root) { |b| b.text! contents }
+        else
+          _convert_to_xml contents, :root => root
+        end
+      end
+
+      def self._convert_to_xml(hash_to_convert, options = {})
+        raise ArgumentError, "need root" unless options[:root]
+        options[:indent] ||= 2
+        options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+        options[:builder].instruct! unless options.delete(:skip_instruct)
+        root = options[:root].to_s.tr("_", "-")
+
+        options[:builder].__send__(:method_missing, root) do
+          hash_to_convert.each do |key, value|
+            case value
+            when ::Hash
+              _convert_to_xml(value, options.merge(:root => key, :skip_instruct => true))
+            when ::Array
+              _array_to_xml(value, options.merge(:root => key, :skip_instruct => true))
+            else
+              type_name = XML_TYPE_NAMES[value.class.name]
+
+              key = key.to_s.tr("_", "-")
+
+              attributes = ((value.nil? || type_name.nil?) ? {} : { :type => type_name })
+              if value.nil?
+                attributes[:nil] = true
+              end
+
+              options[:builder].tag!(key,
+                XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
+                attributes
+              )
+            end
+          end
+        end
+
+      end
+      
+      def self._array_to_xml(array, options = {})
+        raise "expected all elements to be hashes" unless array.all? { |e| e.is_a?(Hash) }
+        raise "expected options[:root]" unless options[:root]
+        raise "expected options[:builder]" unless options[:builder]
+        options[:indent] ||= 2
+        root = options.delete(:root).to_s.tr("_", "-")
+        if array.empty?
+          options[:builder].tag!(root, :type => "array")
+        else
+          options[:builder].tag!(root, :type => "array") do
+            array.each { |e| _convert_to_xml(e, options.merge(:root => "item", :skip_instruct => true)) }
+          end
+        end
+      end
+    end
+  end
+end