mercadopago-custom-checkout 0.1.1

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter.rb

@@ -0,0 +1,46 @@
+module Faraday
+  # Public: This is a base class for all Faraday adapters.  Adapters are
+  # responsible for fulfilling a Faraday request.
+  class Adapter < Middleware
+    CONTENT_LENGTH = 'Content-Length'.freeze
+
+    register_middleware File.expand_path('../adapter', __FILE__),
+      :test => [:Test, 'test'],
+      :net_http => [:NetHttp, 'net_http'],
+      :net_http_persistent => [:NetHttpPersistent, 'net_http_persistent'],
+      :typhoeus => [:Typhoeus, 'typhoeus'],
+      :patron => [:Patron, 'patron'],
+      :em_synchrony => [:EMSynchrony, 'em_synchrony'],
+      :em_http => [:EMHttp, 'em_http'],
+      :excon => [:Excon, 'excon'],
+      :rack => [:Rack, 'rack'],
+      :httpclient => [:HTTPClient, 'httpclient']
+
+    # Public: This module marks an Adapter as supporting parallel requests.
+    module Parallelism
+      attr_writer :supports_parallel
+      def supports_parallel?() @supports_parallel end
+
+      def inherited(subclass)
+        super
+        subclass.supports_parallel = self.supports_parallel?
+      end
+    end
+
+    extend Parallelism
+    self.supports_parallel = false
+
+    def call(env)
+      env.clear_body if env.needs_body?
+    end
+
+    def save_response(env, status, body, headers = nil)
+      env.status = status
+      env.body = body
+      env.response_headers = Utils::Headers.new.tap do |response_headers|
+        response_headers.update headers unless headers.nil?
+        yield(response_headers) if block_given?
+      end
+    end
+  end
+end

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/em_http.rb

@@ -0,0 +1,237 @@
+module Faraday
+  class Adapter
+    # EventMachine adapter is useful for either asynchronous requests
+    # when in EM reactor loop or for making parallel requests in
+    # synchronous code.
+    class EMHttp < Faraday::Adapter
+      module Options
+        def connection_config(env)
+          options = {}
+          configure_proxy(options, env)
+          configure_timeout(options, env)
+          configure_socket(options, env)
+          configure_ssl(options, env)
+          options
+        end
+
+        def request_config(env)
+          options = {
+            :body => read_body(env),
+            :head => env[:request_headers],
+            # :keepalive => true,
+            # :file => 'path/to/file', # stream data off disk
+          }
+          configure_compression(options, env)
+          options
+        end
+
+        def read_body(env)
+          body = env[:body]
+          body.respond_to?(:read) ? body.read : body
+        end
+
+        def configure_proxy(options, env)
+          if proxy = request_options(env)[:proxy]
+            options[:proxy] = {
+              :host => proxy[:uri].host,
+              :port => proxy[:uri].port,
+              :authorization => [proxy[:user], proxy[:password]]
+            }
+          end
+        end
+
+        def configure_socket(options, env)
+          if bind = request_options(env)[:bind]
+            options[:bind] = {
+              :host => bind[:host],
+              :port => bind[:port]
+            }
+          end
+        end
+
+        def configure_ssl(options, env)
+          if env[:url].scheme == 'https' && env[:ssl]
+            options[:ssl] = {
+              :cert_chain_file => env[:ssl][:ca_file],
+              :verify_peer => env[:ssl].fetch(:verify, true)
+            }
+          end
+        end
+
+        def configure_timeout(options, env)
+          timeout, open_timeout = request_options(env).values_at(:timeout, :open_timeout)
+          options[:connect_timeout] = options[:inactivity_timeout] = timeout
+          options[:connect_timeout] = open_timeout if open_timeout
+        end
+
+        def configure_compression(options, env)
+          if env[:method] == :get and not options[:head].key? 'accept-encoding'
+            options[:head]['accept-encoding'] = 'gzip, compressed'
+          end
+        end
+
+        def request_options(env)
+          env[:request]
+        end
+      end
+
+      include Options
+
+      dependency 'em-http'
+
+      self.supports_parallel = true
+
+      def self.setup_parallel_manager(options = nil)
+        Manager.new
+      end
+
+      def call(env)
+        super
+        perform_request env
+        @app.call env
+      end
+
+      def perform_request(env)
+        if parallel?(env)
+          manager = env[:parallel_manager]
+          manager.add {
+            perform_single_request(env).
+              callback { env[:response].finish(env) }
+          }
+        else
+          unless EventMachine.reactor_running?
+            error = nil
+            # start EM, block until request is completed
+            EventMachine.run do
+              perform_single_request(env).
+                callback { EventMachine.stop }.
+                errback { |client|
+                  error = error_message(client)
+                  EventMachine.stop
+                }
+            end
+            raise_error(error) if error
+          else
+            # EM is running: instruct upstream that this is an async request
+            env[:parallel_manager] = true
+            perform_single_request(env).
+              callback { env[:response].finish(env) }.
+              errback {
+                # TODO: no way to communicate the error in async mode
+                raise NotImplementedError
+              }
+          end
+        end
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
+        end
+      end
+
+      # TODO: reuse the connection to support pipelining
+      def perform_single_request(env)
+        req = EventMachine::HttpRequest.new(env[:url], connection_config(env))
+        req.setup_request(env[:method], request_config(env)).callback { |client|
+          save_response(env, client.response_header.status, client.response) do |resp_headers|
+            client.response_header.each do |name, value|
+              resp_headers[name.to_sym] = value
+            end
+          end
+        }
+      end
+
+      def error_message(client)
+        client.error or "request failed"
+      end
+
+      def raise_error(msg)
+        errklass = Faraday::Error::ClientError
+        if msg == Errno::ETIMEDOUT
+          errklass = Faraday::Error::TimeoutError
+          msg = "request timed out"
+        elsif msg == Errno::ECONNREFUSED
+          errklass = Faraday::Error::ConnectionFailed
+          msg = "connection refused"
+        elsif msg == "connection closed by server"
+          errklass = Faraday::Error::ConnectionFailed
+        end
+        raise errklass, msg
+      end
+
+      def parallel?(env)
+        !!env[:parallel_manager]
+      end
+
+      # The parallel manager is designed to start an EventMachine loop
+      # and block until all registered requests have been completed.
+      class Manager
+        def initialize
+          reset
+        end
+
+        def reset
+          @registered_procs = []
+          @num_registered = 0
+          @num_succeeded = 0
+          @errors = []
+          @running = false
+        end
+
+        def running?() @running end
+
+        def add
+          if running?
+            perform_request { yield }
+          else
+            @registered_procs << Proc.new
+          end
+          @num_registered += 1
+        end
+
+        def run
+          if @num_registered > 0
+            @running = true
+            EventMachine.run do
+              @registered_procs.each do |proc|
+                perform_request(&proc)
+              end
+            end
+            if @errors.size > 0
+              raise Faraday::Error::ClientError, @errors.first || "connection failed"
+            end
+          end
+        ensure
+          reset
+        end
+
+        def perform_request
+          client = yield
+          client.callback { @num_succeeded += 1; check_finished }
+          client.errback { @errors << client.error; check_finished }
+        end
+
+        def check_finished
+          if @num_succeeded + @errors.size == @num_registered
+            EventMachine.stop
+          end
+        end
+      end
+    end
+  end
+end
+
+begin
+  require 'openssl'
+rescue LoadError
+  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
+else
+  require 'faraday/adapter/em_http_ssl_patch'
+end if Faraday::Adapter::EMHttp.loaded?

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/em_http_ssl_patch.rb

@@ -0,0 +1,56 @@
+require 'openssl'
+require 'em-http'
+
+module EmHttpSslPatch
+  def ssl_verify_peer(cert_string)
+    cert = nil
+    begin
+      cert = OpenSSL::X509::Certificate.new(cert_string)
+    rescue OpenSSL::X509::CertificateError
+      return false
+    end
+
+    @last_seen_cert = cert
+
+    if certificate_store.verify(@last_seen_cert)
+      begin
+        certificate_store.add_cert(@last_seen_cert)
+      rescue OpenSSL::X509::StoreError => e
+        raise e unless e.message == 'cert already in hash table'
+      end
+      true
+    else
+      raise OpenSSL::SSL::SSLError.new(%(unable to verify the server certificate for "#{host}"))
+    end
+  end
+
+  def ssl_handshake_completed
+    return true unless verify_peer?
+
+    unless OpenSSL::SSL.verify_certificate_identity(@last_seen_cert, host)
+      raise OpenSSL::SSL::SSLError.new(%(host "#{host}" does not match the server certificate))
+    else
+      true
+    end
+  end
+
+  def verify_peer?
+    parent.connopts.tls[:verify_peer]
+  end
+
+  def host
+    parent.connopts.host
+  end
+
+  def certificate_store
+    @certificate_store ||= begin
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      ca_file = parent.connopts.tls[:cert_chain_file]
+      store.add_file(ca_file) if ca_file
+      store
+    end
+  end
+end
+
+EventMachine::HttpStubConnection.send(:include, EmHttpSslPatch)

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/em_synchrony.rb

@@ -0,0 +1,100 @@
+require 'uri'
+
+module Faraday
+  class Adapter
+    class EMSynchrony < Faraday::Adapter
+      include EMHttp::Options
+
+      dependency do
+        require 'em-synchrony/em-http'
+        require 'em-synchrony/em-multi'
+        require 'fiber'
+      end
+
+      self.supports_parallel = true
+
+      def self.setup_parallel_manager(options = {})
+        ParallelManager.new
+      end
+
+      def call(env)
+        super
+        request = EventMachine::HttpRequest.new(Utils::URI(env[:url].to_s), connection_config(env))
+
+        http_method = env[:method].to_s.downcase.to_sym
+
+        # Queue requests for parallel execution.
+        if env[:parallel_manager]
+          env[:parallel_manager].add(request, http_method, request_config(env)) do |resp|
+            save_response(env, resp.response_header.status, resp.response) do |resp_headers|
+              resp.response_header.each do |name, value|
+                resp_headers[name.to_sym] = value
+              end
+            end
+
+            # Finalize the response object with values from `env`.
+            env[:response].finish(env)
+          end
+
+        # Execute single request.
+        else
+          client = nil
+          block = lambda { request.send(http_method, request_config(env)) }
+
+          if !EM.reactor_running?
+            EM.run do
+              Fiber.new {
+                client = block.call
+                EM.stop
+              }.resume
+            end
+          else
+            client = block.call
+          end
+
+          raise client.error if client.error
+
+          save_response(env, client.response_header.status, client.response) do |resp_headers|
+            client.response_header.each do |name, value|
+              resp_headers[name.to_sym] = value
+            end
+          end
+        end
+
+        @app.call env
+      rescue Errno::ECONNREFUSED
+        raise Error::ConnectionFailed, $!
+      rescue EventMachine::Connectify::CONNECTError => err
+        if err.message.include?("Proxy Authentication Required")
+          raise Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
+        else
+          raise Error::ConnectionFailed, err
+        end
+      rescue Errno::ETIMEDOUT => err
+        raise Error::TimeoutError, err
+      rescue RuntimeError => err
+        if err.message == "connection closed by server"
+          raise Error::ConnectionFailed, err
+        else
+          raise
+        end
+      rescue => err
+        if defined?(OpenSSL) && OpenSSL::SSL::SSLError === err
+          raise Faraday::SSLError, err
+        else
+          raise
+        end
+      end
+    end
+  end
+end
+
+require 'faraday/adapter/em_synchrony/parallel_manager'
+
+begin
+  require 'openssl'
+rescue LoadError
+  warn "Warning: no such file to load -- openssl. Make sure it is installed if you want HTTPS support"
+else
+  require 'faraday/adapter/em_http_ssl_patch'
+end if Faraday::Adapter::EMSynchrony.loaded?

data/.gs/gems/faraday-0.9.2/lib/faraday/adapter/em_synchrony/parallel_manager.rb

@@ -0,0 +1,66 @@
+module Faraday
+  class Adapter
+    class EMSynchrony < Faraday::Adapter
+      class ParallelManager
+
+        # Add requests to queue. The `request` argument should be a
+        # `EM::HttpRequest` object.
+        def add(request, method, *args, &block)
+          queue << {
+            :request => request,
+            :method => method,
+            :args => args,
+            :block => block
+          }
+        end
+
+        # Run all requests on queue with `EM::Synchrony::Multi`, wrapping
+        # it in a reactor and fiber if needed.
+        def run
+          result = nil
+          if !EM.reactor_running?
+            EM.run {
+              Fiber.new do
+                result = perform
+                EM.stop
+              end.resume
+            }
+          else
+            result = perform
+          end
+          result
+        end
+
+
+        private
+
+        # The request queue.
+        def queue
+          @queue ||= []
+        end
+
+        # Main `EM::Synchrony::Multi` performer.
+        def perform
+          multi = ::EM::Synchrony::Multi.new
+
+          queue.each do |item|
+            method = "a#{item[:method]}".to_sym
+
+            req = item[:request].send(method, *item[:args])
+            req.callback(&item[:block])
+
+            req_name = "req_#{multi.requests.size}".to_sym
+            multi.add(req_name, req)
+          end
+
+          # Clear the queue, so parallel manager objects can be reused.
+          @queue = []
+
+          # Block fiber until all requests have returned.
+          multi.perform
+        end
+
+      end # ParallelManager
+    end # EMSynchrony
+  end # Adapter
+end # Faraday