paypal_permissions 0.0.5.1 → 0.0.5.2

data/lib/generators/paypal_permissions/install_generator.rb

@@ -56,7 +56,6 @@ end
       end
 
       def copy_initializer
-        # Nothing in the initializer yet, but once there is, just uncomment the following.
         template "paypal_permissions.rb", "config/initializers/paypal_permissions.rb"
       end
 

data/lib/paypal_permissions.rb

@@ -1,2 +1,3 @@
 require "paypal_permissions/version"
 require "paypal_permissions/paypal_permissions_gateway"
+require "paypal_permissions/parsers"

data/lib/paypal_permissions/parsers.rb

@@ -0,0 +1,5 @@
+require 'paypal_permissions/parsers/common'
+require 'paypal_permissions/parsers/request_permissions'
+require 'paypal_permissions/parsers/get_access_token'
+require 'paypal_permissions/parsers/get_basic_personal_data'
+require 'paypal_permissions/parsers/get_advanced_personal_data'

data/lib/paypal_permissions/parsers/common.rb

@@ -0,0 +1,67 @@
+module ActiveMerchant
+  module Billing
+    module PaypalPermissions
+      module Parsers
+        class CommonNVParser
+          class << self
+            def parse nvp_response
+              @response = {
+                :raw_response => nvp_response,
+                :errors => [
+                ],
+              }
+            end
+
+            def process_envelope_pair n, v
+              case n
+              when "responseEnvelope.timestamp"
+                @response[:timestamp] = v
+              when "responseEnvelope.ack"
+                @response[:ack] = v
+              when "responseEnvelope.correlationId"
+                @response[:correlation_id] = v
+              when "responseEnvelope.build"
+                # do nothing
+              end
+            end
+
+            def process_error_idx error_idx
+              if @response[:errors].length <= error_idx
+                @response[:errors] << { :parameters => [] }
+                raise if @response[:errors].length <= error_idx
+              end
+            end
+
+            def process_error_pair n, v
+              n =~ /^error\((\d+)\)/
+              error_idx = $1
+              process_error_idx error_idx
+
+              case n
+              when /^error\(\d+\)\.errorId$/
+                @response[:errors][error_idx][:error_id] = v
+              when /^error\(\d+\)\.domain$/
+                @response[:errors][error_idx][:domain] = v
+              when /^error\(\d+\)\.subdomain$/
+                @response[:errors][error_idx][:subdomain] = v
+              when /^error\(\d+\)\.severity$/
+                @response[:errors][error_idx][:severity] = v
+              when /^error\(\d+\)\.category$/
+                @response[:errors][error_idx][:category] = v
+              when /^error\(\d+\)\.message$/
+                @response[:errors][error_idx][:message] = v
+              when /^error\(\d+\)\.parameter\((\d+)\)$/
+                parameter_idx = $1.to_i
+                if @response[:errors][error_idx][:parameters].length <= parameter_idx
+                  @response[:errors][error_idx][:parameters] << {}
+                  raise if @response[:errors][error_idx][:parameters].length <= parameter_idx
+                end
+                @response[:errors][error_idx][:parameters][parameter_idx] = v
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paypal_permissions/parsers/get_access_token.rb

@@ -0,0 +1,42 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalPermissions
+      module Parsers
+        class GetAccessTokenNVParser < CommonNVParser
+          class << self
+            def parse nvp_response
+              super
+
+              pairs = nvp_response.split "&"
+              pairs.each do |pair|
+                n,v = pair.split "="
+                n = CGI.unescape n
+                v = CGI.unescape v
+
+                case n
+
+                # envelope
+                when /^responseEnvelope/
+                  process_envelope_pair n, v
+
+                # successful token response
+                when "token"
+                  @response[:token] = v
+                when "tokenSecret"
+                  @response[:token_secret] = v
+
+                # error with index
+                when /^error\((\d+)\)/
+                  process_error_pair n, v
+
+                end
+              end
+              @response
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/paypal_permissions/parsers/get_advanced_personal_data.rb

@@ -0,0 +1,26 @@
+require 'paypal_permissions/parsers/personal_data'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalPermissions
+      module Parsers
+        class GetAdvancedPersonalDataNVParser < PersonalDataNVParser
+          class << self
+            def personal_data_mappings
+              {
+                "http://axschema.org/birthDate" => :birthdate,
+                "http://schema.openid.net/contact/street1" => :street1,
+                "http://schema.openid.net/contact/street2" => :street2,
+                "http://axschema.org/contact/city/home" => :city,
+                "http://axschema.org/contact/state/home" => :state,
+                "http://axschema.org/contact/postalCode/home" => :postal_code,
+                "http://axschema.org/contact/phone/default" => :phone,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/paypal_permissions/parsers/get_basic_personal_data.rb

@@ -0,0 +1,25 @@
+require 'paypal_permissions/parsers/personal_data'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalPermissions
+      module Parsers
+        class GetBasicPersonalDataNVParser < PersonalDataNVParser
+          class << self
+            def personal_data_mappings
+              {
+                "http://axschema.org/contact/country/home" => :country,
+                "http://axschema.org/contact/email" => :email,
+                "http://axschema.org/namePerson/first" => :first_name,
+                "http://axschema.org/namePerson/last" => :last_name,
+                "http://schema.openid.net/contact/fullname" => :full_name,
+                "https://www.paypal.com/webapps/auth/schema/payerID" => :payer_id,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/paypal_permissions/parsers/personal_data.rb

@@ -0,0 +1,46 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalPermissions
+      module Parsers
+        class PersonalDataNVParser < CommonNVParser
+          class << self
+            def parse nvp_response
+              super
+
+              @response[:personal_data] = {}
+
+              pairs = nvp_response.split "&"
+              pairs.each do |pair|
+                n,v = pair.split "="
+                n = CGI.unescape n
+                v = CGI.unescape v
+
+                case n
+
+                # envelope
+                when /^responseEnvelope/
+                  process_envelope_pair n, v
+
+                # successful personal data response
+                when /response\.personalData\((\d+)\)\.personalDataKey/
+                  key_idx = $1.to_i
+                  key = personal_data_mappings[v]
+
+                when /response\.personalData\((\d+)\)\.personalDataValue/
+                  val_idx = $1.to_i
+                  raise unless key && val_idx != key_idx
+                  @response[:personal_data][key] = v
+
+                # error with index
+                when /^error\((\d+)\)/
+                  process_error_pair n, v
+
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paypal_permissions/parsers/request_permissions.rb

@@ -0,0 +1,40 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module PaypalPermissions
+      module Parsers
+        class RequestPermissionsNVParser < CommonNVParser
+          class << self
+            def parse nvp_response
+              super
+
+              pairs = nvp_response.split "&"
+              pairs.each do |pair|
+                n,v = pair.split "="
+                n = CGI.unescape n
+                v = CGI.unescape v
+
+                case n
+
+                # envelope
+                when /^responseEnvelope/
+                  process_envelope_pair n, v
+
+                # successful token response
+                when "token"
+                  @response[:token] = v
+
+                # error with index
+                when /^error\((\d+)\)/
+                  process_error_pair n, v
+
+                end
+              end
+              @response
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/paypal_permissions/paypal_permissions_gateway.rb

@@ -1,6 +1,7 @@
 require 'active_merchant'
 require 'active_merchant/billing'
 require 'active_merchant/billing/gateway'
+require 'paypal_permissions/parsers'
 require 'paypal_permissions/x_pp_authorization'
 require 'uri'
 require 'cgi'
@@ -10,6 +11,7 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     class PaypalPermissionsGateway < ActiveMerchant::Billing::Gateway # :nodoc
       include XPPAuthorization
+      include PaypalPermissions::Parsers
 
       public
       def self.setup
@@ -40,7 +42,7 @@ module ActiveMerchant #:nodoc:
             'X-PAYPAL-APPLICATION-ID' => @app_id,
             'X-PAYPAL-REQUEST-DATA-FORMAT' => 'NV',
             'X-PAYPAL-RESPONSE-DATA-FORMAT' => 'NV',
-          }.update(x_pp_authorization_header(get_basic_personal_data_url, access_token, access_token_verifier))
+          }.update(x_pp_authorization_header(get_basic_personal_data_url, @login, @password, access_token, access_token_verifier))
         }
         get_advanced_personal_data_headers = lambda { |access_token, access_token_verifier|
           {
@@ -50,7 +52,7 @@ module ActiveMerchant #:nodoc:
             'X-PAYPAL-APPLICATION-ID' => @app_id,
             'X-PAYPAL-REQUEST-DATA-FORMAT' => 'NV',
             'X-PAYPAL-RESPONSE-DATA-FORMAT' => 'NV',
-          }.update(x_pp_authorization_header(get_advanced_personal_data_url, access_token, access_token_verifier))
+          }.update(x_pp_authorization_header(get_advanced_personal_data_url, @login, @password, access_token, access_token_verifier))
         }
         @options = {
           :request_permissions_headers => request_permissions_headers,
@@ -69,7 +71,7 @@ module ActiveMerchant #:nodoc:
           # puts "request: #{request_permissions_url}?#{query_string}\n"
           # puts "nvp_response: #{nvp_response}\n"
         end
-        response = parse_request_permissions_nvp(nvp_response)
+        response = RequestPermissionsNVParser.parse nvp_response
       end
 
       public
@@ -85,7 +87,7 @@ module ActiveMerchant #:nodoc:
           # puts "request: #{get_access_token_url}?#{query_string}\n"
           # puts "nvp_response: #{nvp_response}\n"
         end
-        response = parse_get_access_token_nvp(nvp_response)
+        response = GetAccessTokenNVParser.parse nvp_response
       end
 
       public
@@ -94,51 +96,28 @@ module ActiveMerchant #:nodoc:
         template % token
       end
 
-      def basic_personal_data_mappings
-        {
-          "http://axschema.org/contact/country/home" => :country,
-          "http://axschema.org/contact/email" => :email,
-          "http://axschema.org/namePerson/first" => :first_name,
-          "http://axschema.org/namePerson/last" => :last_name,
-          "http://schema.openid.net/contact/fullname" => :full_name,
-          "https://www.paypal.com/webapps/auth/schema/payerID" => :payer_id,
-        }
-      end
-
-      def advanced_personal_data_mappings
-        {
-          "http://axschema.org/birthDate" => :birthdate,
-          "http://schema.openid.net/contact/street1" => :street1,
-          "http://schema.openid.net/contact/street2" => :street2,
-          "http://axschema.org/contact/city/home" => :city,
-          "http://axschema.org/contact/state/home" => :state,
-          "http://axschema.org/contact/postalCode/home" => :postal_code,
-          "http://axschema.org/contact/phone/default" => :phone,
-        }
-      end
-
       public
       def get_basic_personal_data(access_token, access_token_verifier)
-        body = personal_data_post_body(basic_personal_data_mappings)
+        body = personal_data_post_body(GetBasicPersonalDataNVParser.personal_data_mappings)
         opts = @options[:get_basic_personal_data_headers].call(access_token, access_token_verifier)
         nvp_response = ssl_post(get_basic_personal_data_url, body, opts)
         if nvp_response =~ /error\(\d+\)/
           # puts "request: #{get_basic_personal_data_url} post_body:#{body}\n"
           # puts "nvp_response: #{nvp_response}\n"
         end
-        response = parse_personal_data_nvp(nvp_response, basic_personal_data_mappings)
+        response = GetBasicPersonalDataNVParser.parse nvp_response
       end
 
       public
       def get_advanced_personal_data(access_token, access_token_verifier)
-        body = personal_data_post_body(advanced_personal_data_mappings)
+        body = personal_data_post_body(GetAdvancedPersonalDataNVParser.personal_data_mappings)
         opts = @options[:get_advanced_personal_data_headers].call(access_token, access_token_verifier)
         nvp_response = ssl_post(get_advanced_personal_data_url, body, opts)
         if nvp_response =~ /error\(\d+\)/
           # puts "request: #{get_advanced_personal_data_url} post_body:#{body}\n"
           # puts "nvp_response: #{nvp_response}\n"
         end
-        response = parse_personal_data_nvp(nvp_response, advanced_personal_data_mappings)
+        response = GetAdvancedPersonalDataNVParser.parse nvp_response
       end
 
       public
@@ -213,252 +192,6 @@ module ActiveMerchant #:nodoc:
         body += "requestEnvelope.errorLanguage=en_US"
       end
 
-      private
-      def parse_request_permissions_nvp(nvp)
-        response = {
-          :errors => [
-          ],
-        }
-        pairs = nvp.split "&"
-        pairs.each do |pair|
-          n,v = pair.split "="
-          n = CGI.unescape n
-          v = CGI.unescape v
-          case n
-          when "responseEnvelope.timestamp"
-            response[:timestamp] = v
-          when "responseEnvelope.ack"
-            response[:ack] = v
-=begin
-# Client should implement these with logging...
-            case v
-            when "Success"
-            when "Failure"
-            when "Warning"
-            when "SuccessWithWarning"
-            when "FailureWithWarning"
-            end
-=end
-          when "responseEnvelope.correlationId"
-            response[:correlation_id] = v
-          when "responseEnvelope.build"
-            # do nothing
-          when "token"
-            response[:token] = v
-          when /^error\((\d+)\)/
-            error_idx = $1.to_i
-            if response[:errors].length <= error_idx
-              response[:errors] << { :parameters => [] }
-              raise if response[:errors].length <= error_idx
-            end
-            case n
-            when /^error\(\d+\)\.errorId$/
-              response[:errors][error_idx][:error_id] = v
-=begin
-# Client should implement these with logging. PayPal doesn't distinguish
-# between errors which can be corrected by the user and errors which need
-# to be corrected by a developer or merchant, say, in configuration.
-#             case v
-#             when "520002"
-#             when
-=end            
-            when /^error\(\d+\)\.domain$/
-              response[:errors][error_idx][:domain] = v
-            when /^error\(\d+\)\.subdomain$/
-              response[:errors][error_idx][:subdomain] = v
-            when /^error\(\d+\)\.severity$/
-              response[:errors][error_idx][:severity] = v
-            when /^error\(\d+\)\.category$/
-              response[:errors][error_idx][:category] = v
-            when /^error\(\d+\)\.message$/
-              response[:errors][error_idx][:message] = v
-            when /^error\(\d+\)\.parameter\((\d+)\)$/
-              parameter_idx = $1.to_i
-              if response[:errors][error_idx][:parameters].length <= parameter_idx
-                response[:errors][error_idx][:parameters] << {}
-                raise if response[:errors][error_idx][:parameters].length <= parameter_idx
-              end
-              response[:errors][error_idx][:parameters][parameter_idx] = v
-            end
-          end
-        end
-        response
-      end
-
-      private
-      def parse_get_access_token_nvp(nvp)
-        response = {
-          :errors => [
-          ],
-        }
-        pairs = nvp.split "&"
-        pairs.each do |pair|
-          n,v = pair.split "="
-          n = CGI.unescape n
-          v = CGI.unescape v
-          case n
-          when "responseEnvelope.timestamp"
-            response[:timestamp] = v
-          when "responseEnvelope.ack"
-            response[:ack] = v
-=begin
-# Client should implement these with logging...
-            case v
-            when "Success"
-            when "Failure"
-            when "Warning"
-            when "SuccessWithWarning"
-            when "FailureWithWarning"
-            end
-=end
-          when "responseEnvelope.correlationId"
-            response[:correlation_id] = v
-          when "responseEnvelope.build"
-            # do nothing
-          when "token"
-            response[:token] = v
-          when "tokenSecret"
-            response[:tokenSecret] = v
-          when /^error\((\d+)\)/
-            error_idx = $1.to_i
-            if response[:errors].length <= error_idx
-              response[:errors] << { :parameters => [] }
-              raise if response[:errors].length <= error_idx
-            end
-            case n
-            when /^error\(\d+\)\.errorId$/
-              response[:errors][error_idx][:error_id] = v
-=begin
-# Client should implement these with logging. PayPal doesn't distinguish
-# between errors which can be corrected by the user and errors which need
-# to be corrected by a developer or merchant, say, in configuration.
-#             case v
-#             when "520002"
-#             when
-=end            
-            when /^error\(\d+\)\.domain$/
-              response[:errors][error_idx][:domain] = v
-            when /^error\(\d+\)\.subdomain$/
-              response[:errors][error_idx][:subdomain] = v
-            when /^error\(\d+\)\.severity$/
-              response[:errors][error_idx][:severity] = v
-            when /^error\(\d+\)\.category$/
-              response[:errors][error_idx][:category] = v
-            when /^error\(\d+\)\.message$/
-              response[:errors][error_idx][:message] = v
-            when /^error\(\d+\)\.parameter\((\d+)\)$/
-              parameter_idx = $1.to_i
-              if response[:errors][error_idx][:parameters].length <= parameter_idx
-                response[:errors][error_idx][:parameters] << {}
-                raise if response[:errors][error_idx][:parameters].length <= parameter_idx
-              end
-              response[:errors][error_idx][:parameters][parameter_idx] = v
-            end
-          end
-        end
-        response
-      end
-
-      private
-      def parse_personal_data_nvp(nvp, personal_data_mappings)
-        response = {
-          :raw_response => nvp,
-          :errors => [
-          ],
-          :personal_data => {
-          }
-        }
-begin
-        key = nil
-        key_idx = nil
-        pairs = nvp.split "&"
-        pairs.each do |pair|
-          n,v = pair.split "="
-          v = "" if v.nil?
-          n = CGI.unescape n
-          v = CGI.unescape v
-          case n
-          when "responseEnvelope.timestamp"
-            response[:timestamp] = v
-          when "responseEnvelope.ack"
-            response[:ack] = v
-          when "responseEnvelope.correlationId"
-            response[:correlation_id] = v
-          when "responseEnvelope.build"
-            # do nothing
-
-          when /response\.personalData\((\d+)\)\.personalDataKey/
-            key_idx = $1.to_i
-            key = personal_data_mappings[v]
-=begin
-            case v
-            when "http://axschema.org/contact/country/home"
-              key = :country
-            when "http://axschema.org/contact/email"
-              key = :email
-            when "http://axschema.org/namePerson/first"
-              key = :first_name
-            when "http://axschema.org/namePerson/last"
-              key = :last_name
-            when "http://schema.openid.net/contact/fullname"
-              key = :full_name
-            when "https://www.paypal.com/webapps/auth/schema/payerID"
-              key = :payer_id
-            end
-=end
-
-          when /response\.personalData\((\d+)\)\.personalDataValue/
-            val_idx = $1.to_i
-            if !key
-              # puts "key:#{key} is nil for v:#{v}"
-            elsif val_idx != key_idx
-              # puts "key_idx:#{key_idx} is out of sync with val_idx:#{val_idx} for key:#{key}"
-            else
-              response[:personal_data][key] = v
-            end
-
-          when /^error\((\d+)\)/
-            error_idx = $1.to_i
-            if response[:errors].length <= error_idx
-              response[:errors] << { :parameters => [] }
-              raise if response[:errors].length <= error_idx
-            end
-            case n
-            when /^error\(\d+\)\.errorId$/
-              response[:errors][error_idx][:error_id] = v
-=begin
-# Client should implement these with logging. PayPal doesn't distinguish
-# between errors which can be corrected by the user and errors which need
-# to be corrected by a developer or merchant, say, in configuration.
-#             case v
-#             when "520002"
-#             when
-=end            
-            when /^error\(\d+\)\.domain$/
-              response[:errors][error_idx][:domain] = v
-            when /^error\(\d+\)\.subdomain$/
-              response[:errors][error_idx][:subdomain] = v
-            when /^error\(\d+\)\.severity$/
-              response[:errors][error_idx][:severity] = v
-            when /^error\(\d+\)\.category$/
-              response[:errors][error_idx][:category] = v
-            when /^error\(\d+\)\.message$/
-              response[:errors][error_idx][:message] = v
-            when /^error\(\d+\)\.parameter\((\d+)\)$/
-              parameter_idx = $1.to_i
-              if response[:errors][error_idx][:parameters].length <= parameter_idx
-                response[:errors][error_idx][:parameters] << {}
-                raise if response[:errors][error_idx][:parameters].length <= parameter_idx
-              end
-              response[:errors][error_idx][:parameters][parameter_idx] = v
-            end
-          end
-        end
-rescue
-  response[:errors][:unknown_error] << nvp.inspect
-end
-        response
-      end
 
 =begin
       private

data/lib/paypal_permissions/version.rb

@@ -1,3 +1,3 @@
 module PaypalPermissions
-  VERSION = "0.0.5.1"
+  VERSION = "0.0.5.2"
 end

data/lib/paypal_permissions/x_pp_authorization.rb

@@ -5,23 +5,23 @@ module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
     module XPPAuthorization
       public
-      def x_pp_authorization_header url, access_token, access_token_verifier
+      def x_pp_authorization_header url, api_user_id, api_password, access_token, access_token_verifier
         timestamp = Time.now.to_i.to_s
-        signature = x_pp_authorization_signature url, timestamp, access_token, access_token_verifier
+        signature = x_pp_authorization_signature url, api_user_id, api_password, timestamp, access_token, access_token_verifier
         { 'X-PP-AUTHORIZATION' => "token=#{access_token},signature=#{signature},timestamp=#{timestamp}" }
       end
 
       public
-      def x_pp_authorization_signature url, timestamp, access_token, access_token_verifier
+      def x_pp_authorization_signature url, api_user_id, api_password, timestamp, access_token, access_token_verifier
         # no query params, but if there were, this is where they'd go
         query_params = {}
         key = [
-          URI.encode(@password),
+          URI.encode(api_password),
           URI.encode(access_token_verifier),
         ].join("&")
 
         params = query_params.dup.merge({
-          "oauth_consumer_key" => @login,
+          "oauth_consumer_key" => api_user_id,
           "oauth_version" => "1.0",
           "oauth_signature_method" => "HMAC-SHA1",
           "oauth_token" => access_token,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paypal_permissions
 version: !ruby/object:Gem::Version
-  version: 0.0.5.1
+  version: 0.0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-17 00:00:00.000000000Z
+date: 2012-04-18 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2156611040 !ruby/object:Gem::Requirement
+  requirement: &2156381840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156611040
+  version_requirements: *2156381840
 - !ruby/object:Gem::Dependency
   name: vcr
-  requirement: &2156559340 !ruby/object:Gem::Requirement
+  requirement: &2156319520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.11'
   type: :development
   prerelease: false
-  version_requirements: *2156559340
+  version_requirements: *2156319520
 - !ruby/object:Gem::Dependency
   name: railties
-  requirement: &2156534720 !ruby/object:Gem::Requirement
+  requirement: &2156308800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156534720
+  version_requirements: *2156308800
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2156532620 !ruby/object:Gem::Requirement
+  requirement: &2156304120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156532620
+  version_requirements: *2156304120
 - !ruby/object:Gem::Dependency
   name: activemerchant
-  requirement: &2156524200 !ruby/object:Gem::Requirement
+  requirement: &2156301480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156524200
+  version_requirements: *2156301480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156520400 !ruby/object:Gem::Requirement
+  requirement: &2156299260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,7 +76,7 @@ dependencies:
         version: '2.6'
   type: :runtime
   prerelease: false
-  version_requirements: *2156520400
+  version_requirements: *2156299260
 description: ! '"A gem to support PayPal Permissions API for Rails applications using
   ActiveMerchant."'
 email:
@@ -160,6 +160,13 @@ files:
 - lib/generators/templates/README.rdoc
 - lib/generators/templates/paypal_permissions.rb
 - lib/paypal_permissions.rb
+- lib/paypal_permissions/parsers.rb
+- lib/paypal_permissions/parsers/common.rb
+- lib/paypal_permissions/parsers/get_access_token.rb
+- lib/paypal_permissions/parsers/get_advanced_personal_data.rb
+- lib/paypal_permissions/parsers/get_basic_personal_data.rb
+- lib/paypal_permissions/parsers/personal_data.rb
+- lib/paypal_permissions/parsers/request_permissions.rb
 - lib/paypal_permissions/paypal_permissions_gateway.rb
 - lib/paypal_permissions/version.rb
 - lib/paypal_permissions/x_pp_authorization.rb
@@ -181,7 +188,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -736704987918879819
+      hash: 4118521118431286841
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -190,7 +197,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -736704987918879819
+      hash: 4118521118431286841
 requirements: []
 rubyforge_project: paypal_permissions
 rubygems_version: 1.8.10