pagarme 1.9.2 → 1.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: db8bb546fef78ef9030feaa67e4b2653b954b605
-  data.tar.gz: 791ac20fa6349679658a591df295df1fe60af23c
+  metadata.gz: 8641743ec32b982257e8fdd31df4acedcaf111a5
+  data.tar.gz: dad121632d7f8073b6ba047788154cbf965aa775
 SHA512:
-  metadata.gz: 7f268fc7eb1887d3cebbf0b93cc14f5d220023f793d16a9969baafc3de5acc6df4471d0554a031e28c955ae66699629d5d6367de19f58e5589facf4dafd7b8b8
-  data.tar.gz: e2a77cf16a0297be1d12536b34a255de4dc448b373c72d379eaa302396fbb355503ddeac4b05634ca5363935ede8be52fd42ecd884bf835626a55656f25fe64c
+  metadata.gz: 8e5dce369112fdd3d218700340bd65f912c9b2c9a27fc5763f544e95aebf8f22910a78a5445854e2f49007c2d33df29c82dd4f4a293df8773ade39c5ea938199
+  data.tar.gz: 2446887bd86e88057529c3ef18169bdbb36f47c21de44d17f1aa6aa4331a7e84431440d51daa92adbdbe8f6c9e0457d15a2990a866afeaef522158d7d3ed3b94

data/.travis.yml

@@ -2,3 +2,4 @@ language: ruby
 rvm:
   - "1.9.3"
   - "2.0.0"
+  - "2.1.2"

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    pagarme (1.8)
+    pagarme (1.9.3)
       multi_json
       rest-client
 

data/lib/pagarme.rb

@@ -14,11 +14,18 @@ require 'pagarme/errors'
 
 module PagarMe
   @@api_key = nil
-  @@api_endpoint = 'https://api.pagar.me'
-  @@api_version = '1'
+  @@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
+  end
+
+  def self.api_endpoint
+    @@api_endpoint
+  end
+
   def self.api_key=(api_key)
     @@api_key = api_key
   end
@@ -32,10 +39,10 @@ module PagarMe
   end
 
   def self.full_api_url(relative_path)
-   "#{@@api_endpoint}/#{@@api_version}#{relative_path}"
+    "#{@@api_endpoint}#{relative_path}"
   end
 
   def self.validate_fingerprint(id, fingerprint)
-		Digest::SHA1.hexdigest(id.to_s + "#" + @@api_key) == fingerprint	
+    Digest::SHA1.hexdigest(id.to_s + "#" + @@api_key) == fingerprint	
   end
 end

data/lib/pagarme/errors.rb

@@ -1,30 +1,30 @@
 module PagarMe
   class PagarMeError < StandardError
-	attr_accessor :message
-	attr_accessor :parameter_name
-	attr_accessor :type
-	attr_accessor :url
-	attr_accessor :errors
+    attr_accessor :message
+    attr_accessor :parameter_name
+    attr_accessor :type
+    attr_accessor :url
+    attr_accessor :errors
 
-	def initialize(message = "", parameter_name = "", type = "", url = "") 
-	  self.message = message
-	  self.type = type
-	  self.parameter_name = parameter_name
-	  self.errors = []
-	end
+    def initialize(message = "", parameter_name = "", type = "", url = "") 
+      self.message = message
+      self.type = type
+      self.parameter_name = parameter_name
+      self.errors = []
+    end
 
-	def self.initFromServerResponse(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
-	
-	def to_s
-	  "#{self.class.to_s} - #{message}"
-	end
+    def self.initFromServerResponse(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
+
+    def to_s
+      "#{self.class.to_s} - #{message}"
+    end
   end
 
   class RequestError < PagarMeError

data/lib/pagarme/model.rb

@@ -1,64 +1,64 @@
 module PagarMe
   class Model < PagarMeObject
 
-	def self.class_name
-	  self.name.split('::')[-1]
-	end
+    def self.class_name
+      self.name.split('::')[-1]
+    end
 
-	def self.url()
-	  if self == Model
-		raise PagarMeError.new('Cant request for model')
-	  end
-	  "/#{CGI.escape(class_name.downcase)}s"
-	end
+    def self.url()
+      if self == Model
+        raise PagarMeError.new('Cant request for model')
+      end
+      "/#{CGI.escape(class_name.downcase)}s"
+    end
 
-	def url
-		raise PagarMeError.new("ID invalido", 'id') if !self.id
-	  "#{self.class.url}/#{CGI.escape(id.to_s)}"
-	end
+    def url
+      raise PagarMeError.new("ID invalido", 'id') if !self.id
+      "#{self.class.url}/#{CGI.escape(id.to_s)}"
+    end
 
-	def create
-	  request = PagarMe::Request.new(self.class.url, 'POST')
-	  request.parameters = self.to_hash
-	  response = request.run
-	  update(response)
-	end
+    def create
+      request = PagarMe::Request.new(self.class.url, 'POST')
+      request.parameters = self.to_hash
+      response = request.run
+      update(response)
+    end
 
-	def save
-	  request = PagarMe::Request.new(self.url, 'PUT')
-	  request.parameters = self.unsaved_values
-	  response = request.run
-	  update(response)
-	end
+    def save
+      request = PagarMe::Request.new(self.url, 'PUT')
+      request.parameters = self.unsaved_values
+      response = request.run
+      update(response)
+    end
 
-	def self.find_by_id(id)
-	  request = PagarMe::Request.new(self.url + "/#{id}", 'GET')
-	  response = request.run
-	  PagarMe::Util.convert_to_pagarme_object(response)
-	end
+    def self.find_by_id(id)
+      request = PagarMe::Request.new(self.url + "/#{id}", 'GET')
+      response = request.run
+      PagarMe::Util.convert_to_pagarme_object(response)
+    end
 
-	def self.find_by(hash, page = 1, count = 10)
-	  raise RequestError.new("Invalid page count") if page < 1 or count < 1
-	  
-	  request = PagarMe::Request.new(self.url,  'GET')
-	  
-	  request.parameters = hash
-	  request.parameters.merge!({:page => page, :count => count})
-	  response = request.run
-	  PagarMe::Util.convert_to_pagarme_object(response)
-	end
+    def self.find_by(hash, page = 1, count = 10)
+      raise RequestError.new("Invalid page count") if page < 1 or count < 1
 
-	def self.all(page = 1, count = 10)
-	  raise RequestError.new("Invalid page count") if page < 1 or count < 1
+      request = PagarMe::Request.new(self.url,  'GET')
 
-	  request = PagarMe::Request.new(url, 'GET')
-	  request.parameters = {
-		:page => page,
-		:count => count
-	  }
+      request.parameters = hash
+      request.parameters.merge!({:page => page, :count => count})
+      response = request.run
+      PagarMe::Util.convert_to_pagarme_object(response)
+    end
 
-	  response = request.run
-	  response.map { |obj_response| self.new(obj_response) }
-	end
+    def self.all(page = 1, count = 10)
+      raise RequestError.new("Invalid page count") if page < 1 or count < 1
+
+      request = PagarMe::Request.new(url, 'GET')
+      request.parameters = {
+        :page => page,
+        :count => count
+      }
+
+      response = request.run
+      response.map { |obj_response| self.new(obj_response) }
+    end
   end
 end

data/lib/pagarme/object.rb

@@ -4,140 +4,140 @@ require 'set'
 module PagarMe
   class PagarMeObject
 
-	def initialize(response = {})
-	  #init @attributes - which are the attributes in the object
-	  @attributes = {}
-
-	  # filters - which are the filters that will be called when appropriate , such as before_set
-	  @filters =  {}
-
-	  # Values that were changed in the object but weren't saved
-	  @unsaved_values = Set.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}="
-		  remove_method(key) if method_defined?(key)
-		  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}="
-		  define_method(key) { @attributes[key] }
-		  define_method(key_set) do |value|
-			if @filters[key]
-			  @filters[key].each do |meth|
-				if methods.include?(meth)
-				  @attributes[key] = method(meth).call(value)
-				  @unsaved_values.add(key)
-				end
-			  end
-			else
-			  @attributes[key] = value
-			  @unsaved_values.add(key)
-			end
-		  end
-		end
-	  end
-	end
-
-	def before_set_filter(attribute, method)
-	  @filters[attribute.to_sym] = Array.new unless @filters[attribute.to_sym]
-	  @filters[attribute.to_sym] << method.to_sym
-	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
+    def initialize(response = {})
+      #init @attributes - which are the attributes in the object
+      @attributes = {}
+
+      # filters - which are the filters that will be called when appropriate , such as before_set
+      @filters =  {}
+
+      # Values that were changed in the object but weren't saved
+      @unsaved_values = Set.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}="
+          remove_method(key) if method_defined?(key)
+          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}="
+          define_method(key) { @attributes[key] }
+          define_method(key_set) do |value|
+            if @filters[key]
+              @filters[key].each do |meth|
+                if methods.include?(meth)
+                  @attributes[key] = method(meth).call(value)
+                  @unsaved_values.add(key)
+                end
+              end
+            else
+              @attributes[key] = value
+              @unsaved_values.add(key)
+            end
+          end
+        end
+      end
+    end
+
+    def before_set_filter(attribute, method)
+      @filters[attribute.to_sym] = Array.new unless @filters[attribute.to_sym]
+      @filters[attribute.to_sym] << method.to_sym
+    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
 end