pagarme 1.9.2 → 1.9.3

data/lib/pagarme/plan.rb

@@ -19,10 +19,10 @@ module PagarMe
 
     def format_amount(amount)
       if amount.kind_of?(String)
-      value = amount.gsub(/\./, "")
-      value = value.strip
-      value = value.match(/\d+/)[0]
-      amount = value
+        value = amount.gsub(/\./, "")
+        value = value.strip
+        value = value.match(/\d+/)[0]
+        amount = value
       end
       amount
     end

data/lib/pagarme/request.rb

@@ -6,73 +6,73 @@ require File.join(File.dirname(__FILE__), '.', 'errors')
 
 module PagarMe
   class Request
-	attr_accessor :path, :method, :parameters, :headers
+    attr_accessor :path, :method, :parameters, :headers
 
-	def initialize(path, method)
-	  self.path = path
-	  self.method = method
-	  self.parameters = {}
-	  self.headers = {}
-	end
+    def initialize(path, method)
+      self.path = path
+      self.method = method
+      self.parameters = {}
+      self.headers = {}
+    end
 
-	def self.encode(params)
-	  Util.normalize_params(params).to_params
-	end
+    def self.encode(params)
+      Util.normalize_params(params).to_params
+    end
 
-	def run
-	  unless PagarMe.api_key
-		raise PagarMeError.new("You need to configure a API key before performing requests.")
-	  end
+    def run
+      unless PagarMe.api_key
+        raise PagarMeError.new("You need to configure a API key before performing requests.")
+      end
 
-	  self.headers =  {}
+      self.headers =  {}
 
-	  parameters = self.parameters.merge({
-		:api_key => PagarMe.api_key
-	  })
-	  error = nil
+      parameters = self.parameters.merge({
+        :api_key => PagarMe.api_key
+      })
+      error = nil
 
-	  begin
-		response = RestClient::Request.execute({
-		  :method => self.method,
-		  :url => PagarMe.full_api_url(self.path),
-		  :headers => self.headers,
-		  :open_timeout => 30,
-		  :payload => self.class.encode(parameters),
-		  :timeout => 90
-		})
-	  rescue SocketError => e
-		error = "Error connecting to server (#{e.message})."
-	  rescue NoMethodError => e
-		if e.message =~ /\WRequestFailed\W/
-		  raise ResponseError.new("Unexpected response code (#{e.inspect}).")
-		else
-		  raise
-		end
-	  rescue RestClient::ExceptionWithResponse => e
-		parsed_error = parse_json_response(e.http_body)
-		if parsed_error['errors']
-		  error = parsed_error
-		  raise PagarMeError.initFromServerResponse(error)
-		else
-		  raise PagarMeError.new(e.http_body)
-		end
-	  rescue RestClient::Exception, Errno::ECONNREFUSED => e
-		error = "Error connecting to server: connection refused"
-	  end
+      begin
+        response = RestClient::Request.execute({
+          :method => self.method,
+          :url => PagarMe.full_api_url(self.path),
+          :headers => self.headers,
+          :open_timeout => 30,
+          :payload => self.class.encode(parameters),
+          :timeout => 90
+        })
+      rescue SocketError => e
+        error = "Error connecting to server (#{e.message})."
+      rescue NoMethodError => e
+        if e.message =~ /\WRequestFailed\W/
+          raise ResponseError.new("Unexpected response code (#{e.inspect}).")
+        else
+          raise
+        end
+      rescue RestClient::ExceptionWithResponse => e
+        parsed_error = parse_json_response(e.http_body)
+        if parsed_error['errors']
+          error = parsed_error
+          raise PagarMeError.initFromServerResponse(error)
+        else
+          raise PagarMeError.new(e.http_body)
+        end
+      rescue RestClient::Exception, Errno::ECONNREFUSED => e
+        error = "Error connecting to server: connection refused"
+      end
 
-	  raise ConnectionError.new(error) if error
+      raise ConnectionError.new(error) if error
 
-	  parse_json_response(response.body)
-	end
+      parse_json_response(response.body)
+    end
 
-	private
+    private
 
-	def parse_json_response(response)
-	  begin
-		MultiJson.load(response)
-	  rescue MultiJson::LoadError => e
-		raise PagarMeError.new("Server response is not a valid JSON.")
-	  end
-	end
+    def parse_json_response(response)
+      begin
+        MultiJson.load(response)
+      rescue MultiJson::LoadError => e
+        raise PagarMeError.new("Server response is not a valid JSON.")
+      end
+    end
   end
 end

data/lib/pagarme/subscription.rb

@@ -5,40 +5,40 @@ module PagarMe
   class Subscription < TransactionCommon
 
 
-	def create
-	  if self.plan
-		self.plan_id = plan.id
-	  end
-
-	  self.plan = nil
-	  super
-	end
-
-	def save
-	  if self.plan
-		self.plan_id = plan.id
-	  end
-
-	  self.plan = nil
-	  super
-	end
-
-	def cancel
-	  request = PagarMe::Request.new(self.url + '/cancel', 'POST')
-	  response = request.run
-	  update(response)
-	end
-
-	def charge(amount)
-	  request = PagarMe::Request.new(self.url + '/transactions', 'POST')
-	  request.parameters = {
-		:amount => amount,
-	  }
-	  response = request.run
-
-	  request = PagarMe::Request.new(self.url, 'GET')
-	  update(request.run)
-	end
+    def create
+      if self.plan
+        self.plan_id = plan.id
+      end
+
+      self.plan = nil
+      super
+    end
+
+    def save
+      if self.plan
+        self.plan_id = plan.id
+      end
+
+      self.plan = nil
+      super
+    end
+
+    def cancel
+      request = PagarMe::Request.new(self.url + '/cancel', 'POST')
+      response = request.run
+      update(response)
+    end
+
+    def charge(amount)
+      request = PagarMe::Request.new(self.url + '/transactions', 'POST')
+      request.parameters = {
+        :amount => amount,
+      }
+      response = request.run
+
+      request = PagarMe::Request.new(self.url, 'GET')
+      update(request.run)
+    end
 
   end
 end

data/lib/pagarme/transaction.rb

@@ -5,14 +5,21 @@ require File.join(File.dirname(__FILE__), '..', 'pagarme')
 
 module PagarMe
   class Transaction < TransactionCommon
-	def charge
-	 	create
-	end
+    def self.calculate_installments(params)
+      request = PagarMe::Request.new('/transactions/calculate_installments_amount', 'GET')
+      request.parameters.merge!(params)
+      response = request.run
+      response
+    end
 
-	def refund
-	  request = PagarMe::Request.new(self.url + '/refund', 'POST')
-	  response = request.run
-	  update(response)
-	end
+    def charge
+      create
+    end
+
+    def refund
+      request = PagarMe::Request.new(self.url + '/refund', 'POST')
+      response = request.run
+      update(response)
+    end
   end
 end

data/lib/pagarme/transaction_common.rb

@@ -4,94 +4,94 @@ require File.join(File.dirname(__FILE__), '..', 'pagarme')
 module PagarMe
   class TransactionCommon < Model
 
-	def initialize(response = {})
-	  super(response)
-	  self.payment_method = 'credit_card' unless self.payment_method
-	  self.installments = 1  unless self.installments
-	  self.status = 'local' unless self.status
-	  before_set_filter :amount, :format_amount
-	end
+    def initialize(response = {})
+      super(response)
+      self.payment_method = 'credit_card' unless self.payment_method
+      self.installments = 1  unless self.installments
+      self.status = 'local' unless self.status
+      before_set_filter :amount, :format_amount
+    end
 
-	def create
-	  validation_error = self.card_hash ? nil : validate
-	  self.card_hash = generate_card_hash unless self.card_hash
-	  unset_creditcard_information
-	  super
-	end
-	
-	def unset_creditcard_information
-	  self.card_number = nil
-	  self.card_holder_name = nil
-	  self.card_expiration_year = nil
-	  self.card_expiration_month = nil
-	  self.card_cvv = nil
-	end
+    def create
+      validation_error = self.card_hash ? nil : validate
+      self.card_hash = generate_card_hash unless self.card_hash
+      unset_creditcard_information
+      super
+    end
 
-	def is_valid_credit_card(card)
-	  s1 = s2 = 0
-	  card.to_s.reverse.chars.each_slice(2) do |odd, even| 
-		s1 += odd.to_i
+    def unset_creditcard_information
+      self.card_number = nil
+      self.card_holder_name = nil
+      self.card_expiration_year = nil
+      self.card_expiration_month = nil
+      self.card_cvv = nil
+    end
 
-		double = even.to_i * 2
-		double -= 9 if double >= 10
-		s2 += double
-	  end
-	  (s1 + s2) % 10 == 0
-	end
+    def is_valid_credit_card(card)
+      s1 = s2 = 0
+      card.to_s.reverse.chars.each_slice(2) do |odd, even| 
+        s1 += odd.to_i
 
-	def validate
-	  error = PagarMeError.new
-	  if self.payment_method == 'credit_card'
-		if !self.card_number || self.card_number.to_s.length > 20 || !is_valid_credit_card(self.card_number.to_s)
-		  error.errors << PagarMeError.new("Número do cartão inválido.", 'card_number')
-		end
-		if !self.card_holder_name || !self.card_holder_name || self.card_holder_name.length == 0
-		  error.errors << PagarMeError.new("Nome do portador inválido.", 'card_holder_name')
-		end
-		if !self.card_expiration_month || self.card_expiration_month.to_i <= 0 || self.card_expiration_month.to_i > 12
-		  error.errors << PagarMeError.new("Mês de expiração inválido.", 'card_expiration_date')
-		end
-		if !self.card_expiration_year || self.card_expiration_year.to_i <= 0
-		  error.errors << PagarMeError.new("Ano de expiração inválido.", 'card_expiration_date')
-		end
-		if !self.card_cvv || self.card_cvv.to_s.length < 3 || self.card_cvv.to_s.length > 4
-		  error.errors << PagarMeError.new("Código de segurança inválido.", 'card_cvv')
-		end
-	  end
-	  if(error.errors.any?)
-		error.message = error.errors.map {|e| e.message}
-		error.message = error.message.join(',')
-		raise error
-	  else
-		nil
-	  end
-	end
+        double = even.to_i * 2
+        double -= 9 if double >= 10
+        s2 += double
+      end
+      (s1 + s2) % 10 == 0
+    end
 
-	def format_amount(amount)
-	  if amount.kind_of?(String)
-		value = amount.gsub(/\./, "")
-		value = value.strip
-		value = value.match(/\d+/)[0]
-		amount = value
-	  end
-	  amount
-	end
+    def validate
+      error = PagarMeError.new
+      if self.payment_method == 'credit_card'
+        if !self.card_number || self.card_number.to_s.length > 20 || !is_valid_credit_card(self.card_number.to_s)
+          error.errors << PagarMeError.new("Número do cartão inválido.", 'card_number')
+        end
+        if !self.card_holder_name || !self.card_holder_name || self.card_holder_name.length == 0
+          error.errors << PagarMeError.new("Nome do portador inválido.", 'card_holder_name')
+        end
+        if !self.card_expiration_month || self.card_expiration_month.to_i <= 0 || self.card_expiration_month.to_i > 12
+          error.errors << PagarMeError.new("Mês de expiração inválido.", 'card_expiration_date')
+        end
+        if !self.card_expiration_year || self.card_expiration_year.to_i <= 0
+          error.errors << PagarMeError.new("Ano de expiração inválido.", 'card_expiration_date')
+        end
+        if !self.card_cvv || self.card_cvv.to_s.length < 3 || self.card_cvv.to_s.length > 4
+          error.errors << PagarMeError.new("Código de segurança inválido.", 'card_cvv')
+        end
+      end
+      if(error.errors.any?)
+        error.message = error.errors.map {|e| e.message}
+        error.message = error.message.join(',')
+        raise error
+      else
+        nil
+      end
+    end
 
-	def card_data_parameters
-	  {
-		:card_number => self.card_number,
-		:card_holder_name => self.card_holder_name,
-		:card_expiration_date => "#{self.card_expiration_month}#{self.card_expiration_year}",
-		:card_cvv => self.card_cvv
-	  }
-	end
+    def format_amount(amount)
+      if amount.kind_of?(String)
+        value = amount.gsub(/\./, "")
+        value = value.strip
+        value = value.match(/\d+/)[0]
+        amount = value
+      end
+      amount
+    end
 
-	def generate_card_hash
-	  request = PagarMe::Request.new("/transactions/card_hash_key", 'GET')
-	  response = request.run
+    def card_data_parameters
+      {
+        :card_number => self.card_number,
+        :card_holder_name => self.card_holder_name,
+        :card_expiration_date => "#{self.card_expiration_month}#{self.card_expiration_year}",
+        :card_cvv => self.card_cvv
+      }
+    end
 
-	  public_key = OpenSSL::PKey::RSA.new(response['public_key'])
-	  ret = "#{response['id']}_#{Base64.strict_encode64(public_key.public_encrypt(card_data_parameters.to_params))}"
-	end
+    def generate_card_hash
+      request = PagarMe::Request.new("/transactions/card_hash_key", 'GET')
+      response = request.run
+
+      public_key = OpenSSL::PKey::RSA.new(response['public_key'])
+      ret = "#{response['id']}_#{Base64.strict_encode64(public_key.public_encrypt(card_data_parameters.to_params))}"
+    end
   end
 end

data/lib/pagarme/util.rb

@@ -1,24 +1,27 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'pagarme')
+
 module PagarMe
   class Util
     def self.pagarme_classes
       return {
-      'transaction' => Transaction,
-      'plan' => Plan,
-      'customer' => Customer,
-      'subscription' => Subscription,
-      'address' => Address,
-      'phone' => Phone,
+        'transaction' => Transaction,
+        'plan' => Plan,
+        'customer' => Customer,
+        'subscription' => Subscription,
+        'address' => Address,
+        'phone' => Phone,
       }
     end
 
     def self.convert_to_pagarme_object(response)
       case response
       when Array
-      response.map{ |i| convert_to_pagarme_object(i)}
+        response.map{ |i| convert_to_pagarme_object(i)}
       when Hash
-      self.pagarme_classes.fetch(response['object'], PagarMeObject).build(response)
+        self.pagarme_classes.fetch(response['object'], PagarMeObject).build(response)
       else
-      response
+        response
       end
     end