paypal-sdk-rest 1.7.6 → 2.0.0.rc1

data/lib/paypal-sdk/core/util/http_helper.rb

@@ -1,171 +0,0 @@
-require 'net/https'
-require 'uri'
-require 'cgi'
-
-module PayPal::SDK::Core
-  module Util
-    module HTTPHelper
-
-      include Configuration
-      include Logging
-      include Authentication
-      include Exceptions
-
-      # Create HTTP connection based on given service name or configured end point
-      def create_http_connection(uri)
-        new_http(uri).tap do |http|
-          if config.http_timeout
-            http.open_timeout = config.http_timeout
-            http.read_timeout = config.http_timeout
-          end
-          configure_ssl(http) if uri.scheme == "https"
-        end
-      end
-
-      # New raw HTTP object
-      def new_http(uri)
-        if config.http_proxy
-          proxy = URI.parse(config.http_proxy)
-          Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port, proxy.user, proxy.password)
-        else
-          Net::HTTP.new(uri.host, uri.port)
-        end
-      end
-
-      # Default ca file
-      def default_ca_file
-        File.expand_path("../../../../../data/paypal.crt", __FILE__)
-      end
-
-      # Apply ssl configuration to http object
-      def configure_ssl(http)
-        http.tap do |https|
-          https.use_ssl = true
-          https.ca_file = default_ca_file
-          https.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          begin
-            https.ssl_version = :TLSv1_2
-          rescue => error
-            logger.warn("WARNING: Your system does not support TLSv1.2. Per PCI Security Council mandate (https://github.com/paypal/TLS-update), you MUST update to latest security library.")
-          end
-          config.ssl_options.each do |key, value|
-            http.send("#{key}=", value)
-          end
-          add_certificate(https)
-        end
-      end
-
-      # Join url
-      def url_join(path, action)
-        path.sub(/\/?$/, "/#{action}")
-      end
-
-      # Make Http call
-      # * payload - Hash(:http, :method, :uri, :body, :header)
-      def http_call(payload)
-        response =
-          log_http_call(payload) do
-            http = payload[:http] || create_http_connection(payload[:uri])
-            http.start do |session|
-              if [ :get, :delete, :head ].include? payload[:method]
-                session.send(payload[:method], payload[:uri].request_uri, payload[:header])
-              else
-                session.send(payload[:method], payload[:uri].request_uri, payload[:body], payload[:header])
-              end
-            end
-          end
-
-        handle_response(response)
-      end
-
-      # Log Http call
-      # * payload - Hash(:http, :method, :uri, :body, :header)
-      def log_http_call(payload)
-        logger.info "Request[#{payload[:method]}]: #{payload[:uri].to_s}"
-
-        logger.debug "Request.body=#{payload[:body]}\trequest.header=#{payload[:header]}"
-
-        start_time = Time.now
-        response = yield
-        logger.info sprintf("Response[%s]: %s, Duration: %.3fs", response.code,
-          response.message, Time.now - start_time)
-
-        logger.add(
-          response_details_log_level(response),
-          "Response.body=#{response.body}\tResponse.header=#{response.to_hash}"
-        )
-
-        response
-      end
-
-      # Generate header based on given header keys and properties
-      # === Arguments
-      # * <tt>header_keys</tt> -- List of Header keys for the properties
-      # * <tt>properties</tt>  -- properties
-      # === Return
-      #  Hash with header as key property as value
-      # === Example
-      # map_header_value( { :username => "X-PAYPAL-USERNAME"}, { :username => "guest" })
-      # # Return: { "X-PAYPAL-USERNAME" => "guest" }
-      def map_header_value(header_keys, properties)
-        header = {}
-        properties.each do |key, value|
-          key = header_keys[key]
-          header[key] = value.to_s if key and value
-        end
-        header
-      end
-
-      def encode_www_form(hash)
-        if defined? URI.encode_www_form
-          URI.encode_www_form(hash)
-        else
-          hash.map{|key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
-        end
-      end
-
-      # Handles response and error codes from the remote service.
-      def handle_response(response)
-        case response.code.to_i
-          when 301, 302, 303, 307
-            raise(Redirection.new(response))
-          when 200...400
-            response
-          when 400
-            raise(BadRequest.new(response))
-          when 401
-            raise(UnauthorizedAccess.new(response))
-          when 403
-            raise(ForbiddenAccess.new(response))
-          when 404
-            raise(ResourceNotFound.new(response))
-          when 405
-            raise(MethodNotAllowed.new(response))
-          when 409
-            raise(ResourceConflict.new(response))
-          when 410
-            raise(ResourceGone.new(response))
-          when 422
-            raise(ResourceInvalid.new(response))
-          when 401...500
-            raise(ClientError.new(response))
-          when 500...600
-            raise(ServerError.new(response))
-          else
-            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
-        end
-      end
-
-      private
-
-      def response_details_log_level(response)
-        if (400...600).cover?(response.code.to_i)
-          Logger::WARN
-        else
-          Logger::DEBUG
-        end
-      end
-
-    end
-  end
-end

data/lib/paypal-sdk/core/util/oauth_signature.rb

@@ -1,64 +0,0 @@
-require 'uri'
-require 'cgi'
-require 'openssl'
-require 'base64'
-
-module PayPal::SDK::Core
-  module Util
-    class OauthSignature
-      attr_accessor :username, :password, :token, :token_secret, :url, :timestamp
-
-      def initialize(username, password, token, token_secret, url, timestamp = nil)
-        @username = username
-        @password = password
-        @token = token
-        @token_secret = token_secret
-        @url = url
-        @timestamp = timestamp || Time.now.to_i.to_s
-      end
-
-      def authorization_string
-        signature = oauth_signature
-        "token=#{token},signature=#{signature},timestamp=#{timestamp}"
-      end
-
-      def oauth_signature
-        key = [
-          paypal_encode(password),
-          paypal_encode(token_secret),
-        ].join("&").gsub(/%[0-9A-F][0-9A-F]/, &:downcase )
-
-        digest = OpenSSL::HMAC.digest('sha1', key, base_string)
-        Base64.encode64(digest).chomp
-      end
-
-      def base_string
-        params = {
-          "oauth_consumer_key" => username,
-          "oauth_version" => "1.0",
-          "oauth_signature_method" => "HMAC-SHA1",
-          "oauth_token" => token,
-          "oauth_timestamp" => timestamp,
-        }
-        sorted_query_string = params.sort.map{|v| v.join("=") }.join("&")
-
-        base = [
-          "POST",
-          paypal_encode(url),
-          paypal_encode(sorted_query_string)
-        ].join("&")
-        base = base.gsub(/%[0-9A-F][0-9A-F]/, &:downcase )
-      end
-
-      # The PayPalURLEncoder java class percent encodes everything other than 'a-zA-Z0-9 _'.
-      # Then it converts ' ' to '+'.
-      # Ruby's CGI.encode takes care of the ' ' and '*' to satisfy PayPal
-      # (but beware, URI.encode percent encodes spaces, and does nothing with '*').
-      # Finally, CGI.encode does not encode '.-', which we need to do here.
-      def paypal_encode str
-        CGI.escape(str.to_s).gsub('.', '%2E').gsub('-', '%2D')
-      end
-    end
-  end
-end
-

data/lib/paypal-sdk/core/util/ordered_hash.rb

@@ -1,165 +0,0 @@
-module PayPal::SDK::Core
-  module Util
-    class OrderedHash < ::Hash #:nodoc:
-
-      def to_yaml_type
-        "!tag:yaml.org,2002:map"
-      end
-
-      # Hash is ordered in Ruby 1.9!
-      if RUBY_VERSION < '1.9'
-
-        # In MRI the Hash class is core and written in C. In particular, methods are
-        # programmed with explicit C function calls and polymorphism is not honored.
-        #
-        # For example, []= is crucial in this implementation to maintain the @keys
-        # array but hash.c invokes rb_hash_aset() originally. This prevents method
-        # reuse through inheritance and forces us to reimplement stuff.
-        #
-        # For instance, we cannot use the inherited #merge! because albeit the algorithm
-        # itself would work, our []= is not being called at all by the C code.
-
-        def initialize(*args, &block)
-          super
-          @keys = []
-        end
-
-        def self.[](*args)
-          ordered_hash = new
-
-          if (args.length == 1 && args.first.is_a?(Array))
-            args.first.each do |key_value_pair|
-              next unless (key_value_pair.is_a?(Array))
-              ordered_hash[key_value_pair[0]] = key_value_pair[1]
-            end
-
-            return ordered_hash
-          end
-
-          unless (args.size % 2 == 0)
-            raise ArgumentError.new("odd number of arguments for Hash")
-          end
-
-          args.each_with_index do |val, ind|
-            next if (ind % 2 != 0)
-            ordered_hash[val] = args[ind + 1]
-          end
-
-          ordered_hash
-        end
-
-        def initialize_copy(other)
-          super
-          # make a deep copy of keys
-          @keys = other.keys
-        end
-
-        def []=(key, value)
-          @keys << key if !has_key?(key)
-          super
-        end
-
-        def delete(key)
-          if has_key? key
-            index = @keys.index(key)
-            @keys.delete_at index
-          end
-          super
-        end
-
-        def delete_if
-          super
-          sync_keys!
-          self
-        end
-
-        def reject!
-          super
-          sync_keys!
-          self
-        end
-
-        def reject(&block)
-          dup.reject!(&block)
-        end
-
-        def keys
-          @keys.dup
-        end
-
-        def values
-          @keys.collect { |key| self[key] }
-        end
-
-        def to_hash
-          self
-        end
-
-        def to_a
-          @keys.map { |key| [ key, self[key] ] }
-        end
-
-        def each_key
-          @keys.each { |key| yield key }
-        end
-
-        def each_value
-          @keys.each { |key| yield self[key]}
-        end
-
-        def each
-          @keys.each {|key| yield [key, self[key]]}
-        end
-
-        alias_method :each_pair, :each
-
-        def clear
-          super
-          @keys.clear
-          self
-        end
-
-        def shift
-          k = @keys.first
-          v = delete(k)
-          [k, v]
-        end
-
-        def merge!(other_hash)
-          if block_given?
-            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
-          else
-            other_hash.each { |k, v| self[k] = v }
-          end
-          self
-        end
-
-        alias_method :update, :merge!
-
-        def merge(other_hash, &block)
-          dup.merge!(other_hash, &block)
-        end
-
-        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
-        def replace(other)
-          super
-          @keys = other.keys
-          self
-        end
-
-        def invert
-          OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
-        end
-
-        def inspect
-          "#<OrderedHash #{super}>"
-        end
-
-        private
-          def sync_keys!
-            @keys.delete_if {|k| !has_key?(k)}
-          end
-      end
-    end
-  end
-end

data/lib/paypal-sdk/core/util.rb

@@ -1,11 +0,0 @@
-module PayPal
-  module SDK
-    module Core
-      module Util
-        autoload :OauthSignature, "paypal-sdk/core/util/oauth_signature"
-        autoload :OrderedHash,    "paypal-sdk/core/util/ordered_hash"
-        autoload :HTTPHelper,     "paypal-sdk/core/util/http_helper"
-      end
-    end
-  end
-end

data/lib/paypal-sdk/rest/api.rb

@@ -1,23 +0,0 @@
-require 'paypal-sdk-core'
-require 'paypal-sdk/rest/version'
-
-module PayPal
-  module SDK
-    module REST
-      class API < Core::API::REST
-#        include Services
-
-        def initialize(environment = nil, options = {})
-          super("", environment, options)
-        end
-
-        class << self
-          def user_agent
-            @user_agent ||= "PayPalSDK/PayPal-Ruby-SDK #{PayPal::SDK::REST::VERSION} (#{sdk_library_details})"
-          end
-        end
-      end
-    end
-  end
-end
-