pagarme 2.0.2 → 2.1.0

data/lib/pagarme/model.rb

@@ -1,64 +1,59 @@
 module PagarMe
   class Model < PagarMeObject
 
-    def self.class_name
-      self.name.split('::')[-1]
+    def create
+      update PagarMe::Request.post(self.class.url, params: to_hash).run
+      self
     end
 
-    def self.url()
-      if self == Model
-        raise PagarMeError.new('Cant request for model')
-      end
-      "/#{CGI.escape(class_name.downcase)}s"
+    def save
+      update PagarMe::Request.put(url, params: unsaved_attributes).run
+      self
     end
 
-    def url
-      raise PagarMeError.new("ID invalido", 'id') if !self.id
-      "#{self.class.url}/#{CGI.escape(id.to_s)}"
+    def url(*params)
+      raise RequestError.new('Invalid ID') unless id.present?
+      self.class.url CGI.escape(id.to_s), *params
     end
 
-    def create
-      request = PagarMe::Request.new(self.class.url, 'POST')
-      request.parameters = self.to_hash
-      response = request.run
-      update(response)
-    end
+    class << self
 
-    def save
-      request = PagarMe::Request.new(self.url, 'PUT')
-      request.parameters = self.unsaved_values
-      response = request.run
-      update(response)
-    end
+      def create(*args, &block)
+        self.new(*args, &block).create
+      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 find_by_id(id)
+        raise RequestError.new('Invalid ID') unless id.present?
+        PagarMe::Request.get(url id).call
+      end
+      alias :find :find_by_id
 
-    def self.find_by(hash, page = 1, count = 10)
-      raise RequestError.new("Invalid page count") if page < 1 or count < 1
+      def 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')
+        PagarMe::Request.get(url, params: hash.merge(
+          page:  page,
+          count: count
+        )).call
+      end
+      alias :find_by_hash :find_by
 
-      request.parameters = hash
-      request.parameters.merge!({:page => page, :count => count})
-      response = request.run
-      PagarMe::Util.convert_to_pagarme_object(response)
-    end
+      def all(page = 1, count = 10)
+        find_by Hash.new, page, count
+      end
 
-    def self.all(page = 1, count = 10)
-      raise RequestError.new("Invalid page count") if page < 1 or count < 1
+      def url(*params)
+        ["/#{ CGI.escape underscored_class_name }s", *params].join '/'
+      end
+
+      def class_name
+        self.name.split('::').last
+      end
 
-      request = PagarMe::Request.new(url, 'GET')
-      request.parameters = {
-        :page => page,
-        :count => count
-      }
+      def underscored_class_name
+        class_name.gsub(/[a-z0-9][A-Z]/){|s| "#{s[0]}_#{s[1]}"}.downcase
+      end
 
-      response = request.run
-      response.map { |obj_response| self.new(obj_response) }
     end
   end
-end
+end

data/lib/pagarme/nested_model.rb

@@ -0,0 +1,56 @@
+module PagarMe
+  class NestedModel < Model
+    attr_reader :parent_id
+
+    def initialize(hash = Hash.new)
+      hash = hash.dup
+      @parent_id = hash.delete(:parent_id) || hash.delete('parent_id')
+      super hash
+    end
+
+    def create
+      update PagarMe::Request.post(self.class.url(parent_id), params: to_hash).run
+      self
+    end
+
+    def url(*params)
+      raise RequestError.new('Invalid ID') unless id.present?
+      self.class.url parent_id, CGI.escape(id.to_s), *params
+    end
+
+    class << self
+
+      def parent_resource_name
+        raise NotImplementedError
+      end
+
+      def find_by_id(parent_id, id)
+        raise RequestError.new('Invalid ID')        unless        id.present?
+        raise RequestError.new('Invalid parent ID') unless parent_id.present?
+
+        PagarMe::Request.get(url parent_id, id).call
+      end
+      alias :find :find_by_id
+
+      def find_by(parent_id, hash, page = 1, count = 10)
+        raise RequestError.new('Invalid page count') if page < 1 or count < 1
+
+        PagarMe::Request.get(url(parent_id), params: hash.merge(
+          page:  page,
+          count: count
+        )).call
+      end
+      alias :find_by_hash :find_by
+
+      def all(parent_id, page = 1, count = 10)
+        find_by parent_id, Hash.new, page, count
+      end
+
+      def url(parent_id, *params)
+        raise RequestError.new('Invalid parent ID') unless parent_id.present?
+        ["/#{parent_resource_name}", parent_id, "#{ CGI.escape underscored_class_name }s", *params].join '/'
+      end
+
+    end
+  end
+end

data/lib/pagarme/object.rb

@@ -1,94 +1,135 @@
-# encoding: utf-8
-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)
-			self.new(attributes)
-		end
-
-		def update(attributes)
-			removed_attributes = @attributes.keys - attributes.keys
-
-			removed_attributes.each do |key|
-				@attributes.delete key
-			end
-
-			attributes.each do |key, value|
-				key = key.to_s
-
-				@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
-			@unsaved_values.add key
-		end
-
-		def [](key)
-			@attributes[key]
-		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
-
-		def respond_to?(name, include_all = false)
-			return true if name.to_s.end_with? '='
-
-			@attributes.has_key?(name.to_s) || super
-		end
-
-		protected
-
-		def method_missing(name, *args)
-			name = name.to_s
-
-			if name.end_with? '='
-				attribute_name = name[0...-1]
-
-				self[attribute_name] = args[0]
-			else
-				self[name]
-			end
-		end
-	end
+  class PagarMeObject
+    attr_reader :attributes, :unsaved_attributes
+
+    RESOURCES = Dir[File.expand_path('../resources/*.rb', __FILE__)].map do |path|
+      File.basename(path, '.rb').to_sym
+    end
+
+    def initialize(response = {})
+      @attributes         = Hash.new
+      @unsaved_attributes = Set.new
+      update response
+    end
+
+    def []=(key,value)
+      @attributes[key] = value
+      @unsaved_attributes.add key
+    end
+
+    def empty?
+      @attributes.empty?
+    end
+
+    def ==(other)
+      self.class == other.class && id == other.id
+    end
+
+    def unsaved_attributes
+      Hash[@unsaved_attributes.map do |key|
+        [ key, to_hash_value(self[key], :unsaved_attributes) ]
+      end]
+    end
+
+    def to_hash
+      Hash[@attributes.map do |key, value|
+        [ key, to_hash_value(value, :to_hash) ]
+      end]
+    end
+
+    def respond_to?(name, include_all = false)
+      return true if name.to_s.end_with? '='
+
+      @attributes.has_key?(name.to_s) || super
+    end
+
+    def to_s
+      attributes_str = ''
+      (attributes.keys - ['id', 'object']).sort.each do |key|
+        attributes_str += " \033[1;33m#{key}:\033[0m#{self[key].inspect}" unless self[key].nil?
+      end
+      "\033[1;31m#<#{self.class.name}:\033[0;32m#{id}#{attributes_str}\033[0m\033[0m\033[1;31m>\033[0;32m"
+    end
+    alias :inspect :to_s
+
+    protected
+    def update(attributes)
+      removed_attributes = @attributes.keys - attributes.keys
+
+      removed_attributes.each do |key|
+        @attributes.delete key
+      end
+
+      attributes.each do |key, value|
+        key = key.to_s
+
+        @attributes[key] = PagarMeObject.convert(value)
+        @unsaved_attributes.delete key
+      end
+    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 method_missing(name, *args, &block)
+      name = name.to_s
+
+      unless block_given?
+        if name.end_with?('=') && args.size == 1
+          attribute_name = name[0...-1]
+          return self[attribute_name] = args[0]
+        end
+
+        if args.size == 0
+          return self[name]
+        end
+      end
+
+      if attributes.respond_to? name
+        return attributes.public_send name, *args, &block
+      end
+
+      super name, *args, &block
+    end
+
+    class << self
+
+      def convert(response)
+        case response
+        when Array
+          response.map{ |i| convert i }
+        when Hash
+          resource_class_for(response['object']).new(response)
+        else
+          response
+        end
+      end
+
+      protected
+      def resource_class_for(resource_name)
+        return PagarMe::PagarMeObject if resource_name.nil?
+
+        if RESOURCES.include? resource_name.to_sym
+          Object.const_get "PagarMe::#{capitalize_name resource_name}"
+        else
+          PagarMe::PagarMeObject
+        end
+      end
+
+      def capitalize_name(name)
+        name.gsub(/(\A\w|\_\w)/){ |str| str.gsub('_', '').upcase }
+      end
+
+    end
+  end
 end
-

data/lib/pagarme/request.rb

@@ -1,52 +1,102 @@
 require 'uri'
 require 'rest_client'
 require 'multi_json'
-require File.join(File.dirname(__FILE__), '.', 'util')
-require File.join(File.dirname(__FILE__), '.', 'errors')
 
 module PagarMe
-	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
+  class Request
+    attr_accessor :path, :method, :parameters, :headers, :query
+
+    SSL_CA_FILEPATH = File.join File.dirname(__FILE__), '..', '..', 'certs', 'cabundle.pem'
+    DEFAULT_HEADERS = {
+      'Content-Type' => 'application/json; charset=utf8',
+      'Accept'       => 'application/json',
+      'User-Agent'   => "pagarme-ruby/#{PagarMe::VERSION}"
+    }
+
+    def initialize(path, method, options={})
+      raise PagarMe::RequestError, 'You need to configure a API key before performing requests.' unless PagarMe.api_key
+
+      @path       = path
+      @method     = method
+      @parameters = options[:params]  || Hash.new
+      @query      = options[:query]   || Hash.new
+      @headers    = options[:headers] || Hash.new
+    end
+
+    def run
+      response = RestClient::Request.execute request_params
+      MultiJson.decode response.body
+    rescue RestClient::Exception => error
+      begin
+        parsed_error = MultiJson.decode error.http_body
+
+        if error.is_a? RestClient::ResourceNotFound
+          if parsed_error['errors']
+            raise PagarMe::NotFound.new(parsed_error, request_params, error)
+          else
+            raise PagarMe::NotFound.new(nil, request_params, error)
+          end
+        else
+          if parsed_error['errors']
+            raise PagarMe::ValidationError.new parsed_error
+          else
+            raise PagarMe::ResponseError.new(request_params, error)
+          end
+        end
+      rescue MultiJson::ParseError
+        raise PagarMe::ResponseError.new(request_params, error)
+      end
+    rescue MultiJson::ParseError
+      raise PagarMe::ResponseError.new(request_params, response)
+    rescue SocketError
+      raise PagarMe::ConnectionError.new $!
+    rescue RestClient::ServerBrokeConnection
+      raise PagarMe::ConnectionError.new $!
+    end
+
+    def call
+      PagarMeObject.convert run
+    end
+
+    def self.get(url, options={})
+      self.new url, 'GET', options
+    end
 
+    def self.post(url, options={})
+      self.new url, 'POST', options
+    end
+
+    def self.put(url, options={})
+      self.new url, 'PUT', options
+    end
+
+    def self.delete(url, options={})
+      self.new url, 'DELETE', options
+    end
+
+    protected
+    def request_params
+      {
+        method:       method,
+        user:         PagarMe.api_key,
+        password:     'x',
+        url:          full_api_url,
+        payload:      MultiJson.encode(parameters),
+        open_timeout: PagarMe.open_timeout,
+        timeout:      PagarMe.timeout,
+        ssl_ca_file:  SSL_CA_FILEPATH,
+        headers:      DEFAULT_HEADERS.merge(headers)
+      }
+    end
+
+    def full_api_url
+      url = PagarMe.api_endpoint + path
+
+      if query.present?
+        url += '?' + URI.encode_www_form(query)
+      end
+
+      url
+    end
+  end
+end