braintree-rails 0.0.1

data/Gemfile

@@ -0,0 +1,10 @@
+source 'http://rubygems.org'
+gem 'braintree', '~> 2.14.0'
+gem 'activemodel', '~> 3.0'
+gem 'activesupport', '~> 3.0'
+
+group :test do
+  gem 'minitest'
+  gem 'webmock'
+  gem 'turn'
+end

data/Gemfile.lock

@@ -0,0 +1,34 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    addressable (2.3.2)
+    ansi (1.4.3)
+    braintree (2.14.0)
+      builder (>= 2.0.0)
+    builder (3.0.3)
+    crack (0.3.1)
+    i18n (0.6.1)
+    minitest (3.4.0)
+    multi_json (1.3.6)
+    turn (0.9.6)
+      ansi
+    webmock (1.8.10)
+      addressable (>= 2.2.7)
+      crack (>= 0.1.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (~> 3.0)
+  activesupport (~> 3.0)
+  braintree (~> 2.14.0)
+  minitest
+  turn
+  webmock

data/README.md

@@ -0,0 +1,2 @@
+braintree-rails
+===============

data/Rakefile

@@ -0,0 +1,4 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'lib/env'))
+Dir.glob(File.join(ROOT_PATH, 'lib/tasks/*.rake')).each { |file| import file }
+
+task :default => ['test:all']

data/braintree-rails.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'braintree-rails'
+  spec.version     = '0.0.1'
+  spec.summary     = 'Provides ActiveModel compatible wrappers for Braintree models.'
+  spec.description = 'Provides ActiveModel compatible wrappers for Braintree models and more.'
+  spec.author      = 'Lin Yang'
+  spec.email       = 'github@linyang.me'
+  spec.license     = 'MIT'
+  spec.files       = Dir['**/*']
+  spec.test_files  = Dir['test/**']
+  spec.homepage    = 'https://github.com/lyang/braintree-rails'
+  spec.add_runtime_dependency 'braintree', '~> 2.14.0'
+  spec.add_runtime_dependency 'activemodel', '~> 3.0'
+  spec.add_runtime_dependency 'activesupport', '~> 3.0'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'turn'
+end

data/lib/braintree-rails.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'env'))
+require 'active_model'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/hash/except'
+require 'active_support/inflector'
+require 'ostruct'
+require 'delegate'
+require 'braintree'
+require 'braintree/exceptions'
+
+require 'model'
+require 'exceptions'
+require 'address'
+require 'addresses'
+require 'credit_card'
+require 'credit_cards'
+require 'customer'

data/lib/braintree_rails/address.rb

@@ -0,0 +1,75 @@
+module BraintreeRails
+  class Address < SimpleDelegator
+    Attributes = [:id, :customer_id, :first_name, :last_name, :company, :street_address, :extended_address, :locality, :country_name, :country_code_alpha2, :country_code_alpha3, :country_code_numeric, :region, :postal_code]
+    include Model
+
+    validates :first_name, :last_name, :company, :street_address, :extended_address, :locality, :region, :length => {:maximum => 255}
+    validates :country_code_alpha2, :inclusion => { :in => Braintree::Address::CountryNames.map {|country| country[1]} }
+    validates :postal_code, :street_address, :presence => true
+    validates :postal_code, :format => { :with => /^[- a-z0-9]+$/i}
+
+    def initialize(address = {})
+      address = ensure_address(address)
+      assign_attributes(extract_values(address))
+      super
+    end
+
+    def country_name=(val)
+      self.country_code_alpha2= Braintree::Address::CountryNames.find{|country| country[0] == val}.try(:[], 1)
+      @country_name = val
+    end
+
+    def country_code_alpha3=(val)
+      self.country_code_alpha2= Braintree::Address::CountryNames.find{|country| country[2] == val}.try(:[], 1)
+      @country_code_alpha3 = val
+    end
+
+    def country_code_numeric=(val)
+      self.country_code_alpha2= Braintree::Address::CountryNames.find{|country| country[3] == val}.try(:[], 1)
+      @country_code_numeric = val
+    end
+
+    def destroy!
+      if persisted?
+        self.class.braintree_model_class.delete(customer_id, id)
+      end
+      @persisted = false
+      freeze
+    end
+
+    protected
+    def ensure_address(address)
+      case address
+      when Braintree::Address
+        @persisted = true
+        address
+      when Hash
+        @persisted = false
+        OpenStruct.new(address)
+      else
+        @persisted = address.respond_to?(:persisted?) ? address.persisted? : false
+        address
+      end
+    end
+
+    def update
+      with_update_braintree do
+        self.class.braintree_model_class.update(self.customer_id, self.id, self.attributes.except(:id, :customer_id))
+      end
+    end
+
+    def update!
+      with_update_braintree do
+        self.class.braintree_model_class.update!(self.customer_id, self.id, self.attributes.except(:id, :customer_id))
+      end
+    end
+
+    def attributes_to_exclude_from_update
+      [:id, :customer_id, :country_name, :country_code_alpha3, :country_code_numeric]
+    end
+
+    def attributes_to_exclude_from_create
+      [:country_name, :country_code_alpha3, :country_code_numeric]
+    end
+  end
+end

data/lib/braintree_rails/addresses.rb

@@ -0,0 +1,24 @@
+module BraintreeRails
+  class Addresses < SimpleDelegator
+    def initialize(customer, addresses)
+      @customer = customer
+      super(Array(addresses).map{|address| Address.new(address)})
+    end
+
+    def find(id = nil, &block)
+      id.nil? ? super(&block) : super() { |a| a.id == id }
+    end
+
+    def build(params)
+      Address.new(params.merge(:customer_id => @customer.id))
+    end
+
+    def create(params)
+      build(params).tap { |address| address.save }
+    end
+
+    def create!(params)
+      build(params).tap { |address| address.save! }
+    end
+  end
+end

data/lib/braintree_rails/credit_card.rb

@@ -0,0 +1,67 @@
+module BraintreeRails
+  class CreditCard < SimpleDelegator
+    Attributes = [:customer_id, :number, :token, :cvv, :cardholder_name, :expiration_date, :expiration_month, :expiration_year, :billing_address].freeze
+    
+    include Model
+
+    validates :customer_id, :presence => true, :length => {:maximum => 36}, :if => :new_record?
+    validates :number, :presence => true, :numericality => { :only_integer => true }, :length => {:minimum => 12, :maximum => 19}, :if => :new_record?
+    validates :cvv, :presence => true, :numericality => { :only_integer => true, :greater_than_or_equal_to => 100, :less_than_or_equal_to => 9999 }
+    validates :cardholder_name, :length => {:maximum => 255}
+    validates :expiration_month, :presence => true, :numericality => { :only_integer => true, :greater_than_or_equal_to => 1, :less_than_or_equal_to => 12 }
+    validates :expiration_year,  :presence => true, :numericality => { :only_integer => true, :greater_than_or_equal_to => 1976, :less_than_or_equal_to => 2200 }
+    validates_each :billing_address do |record, attribute, value|
+      record.errors.add(attribute, "is not valid. #{value.errors.full_messages.join("\n")}") unless value.valid?
+    end
+
+    def initialize(credit_card = {})
+      credit_card = ensure_credit_card(credit_card)
+      assign_attributes(extract_values(credit_card))
+      super
+    end
+
+    def id
+      token
+    end
+
+    def expiration_date=(date)
+      expiration_month, expiration_year = date.split('/')
+      self.expiration_month = expiration_month
+      self.expiration_year = expiration_year.gsub(/^(\d\d)$/, '20\1')
+    end
+
+    def expiration_date
+      expiration_month.present? ? "#{expiration_month}/#{expiration_year}" : nil
+    end
+
+    def billing_address=(val)
+      @billing_address = Address.new(val)
+    end
+
+    protected
+    def ensure_credit_card(credit_card)
+      case credit_card
+      when String
+        @persisted = true
+        Braintree::CreditCard.find(credit_card)
+      when Braintree::CreditCard
+        @persisted = true
+        credit_card
+      when Hash
+        @persisted = false
+        OpenStruct.new(credit_card.reverse_merge(:billing_address => {}))
+      else
+        @persisted = credit_card.respond_to?(:persisted?) ? credit_card.persisted? : false
+        credit_card
+      end
+    end
+
+    def attributes_to_exclude_from_update
+      [:token, :customer_id, :expiration_date]
+    end
+
+    def attributes_to_exclude_from_create
+      [:expiration_date]
+    end
+  end
+end

data/lib/braintree_rails/credit_cards.rb

@@ -0,0 +1,24 @@
+module BraintreeRails
+  class CreditCards < SimpleDelegator
+    def initialize(customer, credit_cards)
+      @customer = customer
+      super(Array(credit_cards).map{|card| CreditCard.new(card)})
+    end
+
+    def find(token = nil, &block)
+      token.nil? ? super(&block) : super() { |c| c.token == token }
+    end
+
+    def build(params)
+      CreditCard.new(params.merge(:customer_id => @customer.id))
+    end
+
+    def create(params)
+      build(params).tap { |credit_card| credit_card.save }
+    end
+
+    def create!(params)
+      build(params).tap { |credit_card| credit_card.save! }
+    end
+  end
+end

data/lib/braintree_rails/customer.rb

@@ -0,0 +1,37 @@
+module BraintreeRails
+  class Customer < SimpleDelegator
+    Attributes = [:id, :first_name, :last_name, :email, :company, :website, :phone, :fax].freeze
+    include Model
+
+    validates :id, :format => {:with => /^[-_a-z0-9]*$/i}, :length => {:maximum => 36}, :exclusion => {:in => %w(all new)}
+    validates :first_name, :last_name, :company, :website, :phone, :fax, :length => {:maximum => 255}
+
+    attr_reader :addresses, :credit_cards
+    
+    def initialize(customer = {})
+      customer = ensure_customer(customer)
+      assign_attributes(extract_values(customer))
+      @addresses = Addresses.new(self, customer.addresses)
+      @credit_cards = CreditCards.new(self, customer.credit_cards)
+      super
+    end
+
+    protected
+    def ensure_customer(customer)
+      case customer
+      when String
+        @persisted = true
+        Braintree::Customer.find(customer)
+      when Braintree::Customer
+        @persisted = true
+        customer
+      when Hash
+        @persisted = false
+        OpenStruct.new(customer.reverse_merge(:addresses => [], :credit_cards => []))
+      else
+        @persisted = customer.respond_to?(:persisted?) ? customer.persisted? : false
+        customer
+      end
+    end
+  end
+end

data/lib/braintree_rails/exceptions.rb

@@ -0,0 +1,2 @@
+class RecordInvalid < Braintree::BraintreeError; end
+class RecordInvalid < Braintree::BraintreeError; end

data/lib/braintree_rails/model.rb

@@ -0,0 +1,192 @@
+module BraintreeRails
+  module Model
+    module ClassMethods
+      def self.extended(receiver)
+        receiver.class_eval do
+          extend ::ActiveModel::Naming
+          include ::ActiveModel::Validations
+          include ::ActiveModel::Serialization
+          attr_accessor(*self::Attributes)
+
+          class << receiver
+            alias :build :new
+            
+            def create(params)
+              new(params).tap { |new_record| new_record.save }
+            end
+
+            def create!(params)
+              new(params).tap { |new_record| new_record.save! }
+            end
+
+            def braintree_model_class
+              "braintree/#{braintree_model_name}".camelize.constantize
+            end
+
+            def braintree_model_name
+              name.demodulize.underscore
+            end
+          end
+        end
+      end   
+    end
+    
+    module InstanceMethods
+      def persisted?
+        @persisted
+      end
+
+      def new_record?
+        !persisted?
+      end
+
+      def to_key
+        persisted? ? [id] : nil
+      end
+
+      def to_param
+        to_key.join("-")
+      end
+
+      def attributes
+        self.class::Attributes.inject({}) do |hash, attribute|
+          value = self.send(attribute)
+          hash[attribute] =  value if value.present?
+          hash
+        end
+      end
+
+      def save
+        create_or_update
+      rescue RecordInvalid
+        false
+      end
+
+      def save!
+        create_or_update || raise(RecordNotSaved)
+      end
+
+      def update_attributes(attributes)
+        assign_attributes(attributes)
+        save
+      end
+
+      def update_attributes!(attributes)
+        assign_attributes(attributes)
+        save!
+      end
+
+      def destroy
+        destroy!
+      rescue Braintree::NotFoundError
+        @persisted = false
+        freeze
+      end
+      alias :delete :destroy
+
+      def destroy!
+        if persisted?
+          self.class.braintree_model_class.delete(id)
+        end
+        @persisted = false
+        freeze
+      end
+      alias :delete! :destroy!
+
+      def attributes_for_update
+        attributes.except(*attributes_to_exclude_from_update).tap do |hash|
+          hash.each_pair do |key, value|
+            hash[key] = value.attributes_for_update if value.respond_to?(:attributes_for_update)
+          end
+        end
+      end
+
+      def attributes_for_create
+        attributes.except(*attributes_to_exclude_from_create).tap do |hash|
+          hash.each_pair do |key, value|
+            hash[key] = value.attributes_for_create if value.respond_to?(:attributes_for_create)
+          end
+        end
+      end
+
+      private
+      def create_or_update
+        !!(new_record? ? create : update)
+      end
+
+      def create
+        with_update_braintree do
+          self.class.braintree_model_class.create(attributes_for_create)
+        end
+      end
+
+      def create!
+        with_update_braintree do
+          self.class.braintree_model_class.create!(attributes_for_create)
+        end
+      end
+
+      def update
+        with_update_braintree do
+          self.class.braintree_model_class.update(id, attributes_for_update)
+        end
+      end
+
+      def update!
+        with_update_braintree do
+          self.class.braintree_model_class.update!(id, attributes_for_update)
+        end
+      end
+
+      def attributes_to_exclude_from_update
+        [:id]
+      end
+
+      def attributes_to_exclude_from_create
+        []
+      end
+
+      def extract_values(obj)
+        self.class::Attributes.inject({}) do |hash, attr|
+          hash[attr] = obj.send(attr) if obj.respond_to?(attr)
+          hash
+        end
+      end
+
+      def assign_attributes(hash)
+        hash.each do |attribute, value|
+          send("#{attribute}=", value) if respond_to?("#{attribute}=")
+        end
+      end
+
+      def add_errors(validation_errors)
+        validation_errors.each do |error|
+          if respond_to?(error.attribute)
+            self.errors.add error.attribute, error.message
+          else
+            self.error.add :base, error.message
+          end
+        end
+      end
+
+      def with_update_braintree
+        raise RecordInvalid unless valid?
+        result = yield
+        if result.respond_to?(:success?) && !result.success?
+          add_errors(result.errors)
+          false
+        else
+          new_record = result.respond_to?(self.class.braintree_model_name) ? result.send(self.class.braintree_model_name) : result
+          assign_attributes(extract_values(new_record))
+          @persisted = true
+          self.__setobj__(new_record)
+        end
+      end
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+end