pagarme 1.10.0 → 2.0.0

data/lib/pagarme.rb

@@ -19,7 +19,6 @@ module PagarMe
   @@api_key = nil
   @@api_endpoint = 'https://api.pagar.me/1'
   @@live = true
-  @@api_card_encryption_public_key = File.join(File.dirname(__FILE__), '..', 'certs/public_key.pem')
 
   def self.api_endpoint=(api_endpoint)
     @@api_endpoint = api_endpoint
@@ -37,10 +36,6 @@ module PagarMe
     @@api_key
   end
 
-  def self.api_card_encryption_public_key
-    @@api_card_encryption_public_key
-  end
-
   def self.full_api_url(relative_path)
     "#{@@api_endpoint}#{relative_path}"
   end

data/lib/pagarme/errors.rb

@@ -13,12 +13,14 @@ module PagarMe
       self.errors = []
     end
 
-    def self.initFromServerResponse(response = {})
+    def self.fromServerResponse(response = {})
       object = self.new
+
       response['errors'].map do |error|
         object.message += error['message'] + ', '
         object.errors << PagarMeError.new(error['message'],  error['parameter_name'], error['type'], response['url'])
       end
+
       object
     end
 
@@ -36,3 +38,4 @@ module PagarMe
   class ResponseError < PagarMeError
   end
 end
+

data/lib/pagarme/object.rb

@@ -2,134 +2,132 @@
 require 'set'
 
 module PagarMe
-  class PagarMeObject
-
-    def initialize(response = {})
-      #init @attributes - which are the attributes in the object
-      @attributes = {}
-
-      # Values that were changed in the object but weren't saved
-      @unsaved_values = Set.new
-
-	  # Methods that already existed
-	  @@existing_methods = Array.new
-
-      #Update object
-      update(response)
-    end
-
-    def self.build(attributes)
-      object = self.new(attributes)
-      return object
-    end
-
-    def update(attributes)
-
-      removed = Set.new(@attributes.keys - attributes.keys)
-      added = Set.new(attributes.keys - @attributes.keys)
-
-      instance_eval do
-        remove_attribute(removed)
-        add_attribute(added)
-      end
-
-      removed.each do |key|
-        @attributes.delete(key)
-        @unsaved_values.delete(key)
-      end
-
-      attributes.each do |key, value|
-        @attributes[key] = Util.convert_to_pagarme_object(value)
-        @unsaved_values.delete(key)
-      end
-    end
-
-    def each(&block)
-      @attributes.each(&block)
-    end
-
-    def []=(key,value)
-      @attributes[key] = value
-    end
-
-    def [](key)
-      @attributes[key.to_sym]
-    end
-
-    def unsaved_values
-      values = {}
-      @unsaved_values.each do |k|
-        if(@attributes[k].kind_of?(PagarMeObject))
-          values[k] = @attributes[k].unsaved_values
-        else
-          values[k] = @attributes[k]
-        end
-      end
-      values
-    end
-
-    def to_hash
-      ret_attributes = {}
-      @attributes.each do |k,v|
-        if @attributes[k].kind_of?(PagarMeObject)
-          ret_attributes[k] = @attributes[k].to_hash if @attributes[k].kind_of?(PagarMeObject)
-        else
-          ret_attributes[k] = @attributes[k]
-        end
-      end
-      return ret_attributes
-    end
-
-    protected
-
-    def metaclass
-      class << self; self; end
-    end
-
-    def remove_attribute(keys)
-      metaclass.instance_eval do
-        keys.each do |key|
-          key_sym = :"#{key}="
-		  if !@@existing_methods.include?(key)
-          	remove_method(key) if method_defined?(key) 
-		  end
-          remove_method(key_sym) if method_defined?(key_sym)
-        end
-      end
-    end
-
-    def add_attribute(keys)
-      metaclass.instance_eval do
-        keys.each do |key|
-          key_set = "#{key}="
-		  if method_defined?(key)
-			@@existing_methods.push(key)
-		  else
-         	define_method(key) { @attributes[key] } 
-		  end
-          define_method(key_set) do |value|
-                  @attributes[key] = value
-                  @unsaved_values.add(key)
-          end
-        end
-      end
-    end
-
-    def method_missing(name, *args)
-      if name.to_s.end_with?('=')
-        attr = name.to_s[0...-1].to_sym
-        add_attribute([attr])
-        begin
-          mth = method(name)
-        rescue NameError
-          raise NoMethodError.new("O atributo #{name} nao e permitido.")
-        end
-        return mth.call(args[0])
-      else
-        if @attributes.has_key?(name)
-          return @attributes[name]
-        end
-      end
-    end
-  end
+	class PagarMeObject
+		def initialize(response = {})
+			#init @attributes - which are the attributes in the object
+			@attributes = {}
+
+			# Values that were changed in the object but weren't saved
+			@unsaved_values = Set.new
+
+			# Methods that already existed
+			@@existing_methods = Array.new
+
+			#Update object
+			update(response)
+		end
+
+		def self.build(attributes)
+			self.new(attributes)
+		end
+
+		def update(attributes)
+			removed = Set.new(@attributes.keys - attributes.keys)
+			added = Set.new(attributes.keys - @attributes.keys)
+
+			instance_eval do
+				remove_attribute(removed)
+				add_attribute(added)
+			end
+
+			removed.each do |key|
+				@attributes.delete(key)
+				@unsaved_values.delete(key)
+			end
+
+			attributes.each do |key, value|
+				@attributes[key] = Util.convert_to_pagarme_object(value)
+				@unsaved_values.delete(key)
+			end
+		end
+
+		def each(&block)
+			@attributes.each(&block)
+		end
+
+		def []=(key,value)
+			@attributes[key] = value
+		end
+
+		def [](key)
+			@attributes[key.to_sym]
+		end
+
+		def to_hash_value(value, type)
+			case value
+			when PagarMeObject
+				value.send type
+			when Array
+				value.map do |v|
+					to_hash_value v, type
+				end
+			else
+				value
+			end
+		end
+
+		def unsaved_values
+			Hash[@unsaved_values.map { |k| [k, to_hash_value(@attributes[k], 'unsaved_values')] }]
+		end
+
+		def to_hash
+			Hash[@attributes.map { |k, v| [k, to_hash_value(v, 'to_hash')] }]
+		end
+
+		protected
+
+		def metaclass
+			class << self; self; end
+		end
+
+		def remove_attribute(keys)
+			metaclass.instance_eval do
+				keys.each do |key|
+					key_sym = :"#{key}="
+
+					if !@@existing_methods.include?(key)
+						remove_method(key) if method_defined?(key) 
+					end
+
+					remove_method(key_sym) if method_defined?(key_sym)
+				end
+			end
+		end
+
+		def add_attribute(keys)
+			metaclass.instance_eval do
+				keys.each do |key|
+					key_set = "#{key}="
+
+					if method_defined?(key)
+						@@existing_methods.push(key)
+					else
+						define_method(key) { @attributes[key] } 
+					end
+
+					define_method(key_set) do |value|
+						@attributes[key] = value
+						@unsaved_values.add(key)
+					end
+				end
+			end
+		end
+
+		def method_missing(name, *args)
+			if name.to_s.end_with?('=')
+				attr = name.to_s[0...-1].to_sym
+				add_attribute([attr])
+
+				begin
+					m = method(name)
+				rescue NameError
+					raise NoMethodError.new("O atributo #{name} nao e permitido.")
+				end
+
+				m.call *args
+			else
+				@attributes[name] if @attributes.has_key?(name)
+			end
+		end
+	end
 end

data/lib/pagarme/request.rb

@@ -5,75 +5,48 @@ require File.join(File.dirname(__FILE__), '.', 'util')
 require File.join(File.dirname(__FILE__), '.', 'errors')
 
 module PagarMe
-  class Request
-    attr_accessor :path, :method, :parameters, :headers
-
-    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 run
-      unless PagarMe.api_key
-        raise PagarMeError.new("You need to configure a API key before performing requests.")
-      end
-
-      self.headers =  {}
-
-      parameters = self.parameters.merge({
-        :api_key => PagarMe.api_key
-      })
-      error = nil
-	  # puts parameters.inspect
-
-      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
-
-      parse_json_response(response.body)
-    end
-
-    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
-  end
+	class Request
+		attr_accessor :path, :method, :parameters, :headers, :query
+
+		def initialize(path, method)
+			self.path = path
+			self.method = method
+			self.parameters = {}
+			self.query = {}
+			self.headers = {}
+		end
+
+		def run
+			raise PagarMeError, "You need to configure a API key before performing requests." unless PagarMe.api_key
+
+			begin
+				response = RestClient::Request.execute({
+					:method => self.method,
+					:user => PagarMe.api_key,
+					:password => 'x',
+					:url => PagarMe.full_api_url(self.path) + '?' + URI.encode_www_form(query),
+					:payload => MultiJson.encode(parameters),
+					:open_timeout => 30,
+					:timeout => 90,
+					:ssl_ca_file => File.join(File.dirname(__FILE__), '..', '..', 'certs', 'cabundle.pem'),
+					:headers => {
+						'Content-Type' => 'application/json; charset=utf8',
+						'Accept' => 'application/json',
+						'User-Agent' => 'pagarme-ruby/1.0'
+					}
+				})
+			rescue RestClient::ExceptionWithResponse => e
+				parsed_error = MultiJson.decode(e.http_body)
+
+				if parsed_error['errors']
+					raise PagarMeError.fromServerResponse(parsed_error)
+				else
+					raise PagarMeError.new(e.http_body)
+				end
+			end
+
+			MultiJson.decode response.body
+		end
+	end
 end
+

data/lib/pagarme/transaction.rb

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