mercadopago-custom-checkout 0.1.2 → 0.2.0

data/.gs/gems/faraday-0.9.2/lib/faraday/response/logger.rb

@@ -1,59 +0,0 @@
-require 'forwardable'
-
-module Faraday
-  class Response::Logger < Response::Middleware
-    extend Forwardable
-
-    DEFAULT_OPTIONS = { :bodies => false }
-
-    def initialize(app, logger = nil, options = {})
-      super(app)
-      @logger = logger || begin
-        require 'logger'
-        ::Logger.new(STDOUT)
-      end
-      @options = DEFAULT_OPTIONS.merge(options)
-    end
-
-    def_delegators :@logger, :debug, :info, :warn, :error, :fatal
-
-    def call(env)
-      info "#{env.method} #{env.url.to_s}"
-      debug('request') { dump_headers env.request_headers }
-      debug('request') { dump_body(env[:body]) } if env[:body] && log_body?(:request)
-      super
-    end
-
-    def on_complete(env)
-      info('Status') { env.status.to_s }
-      debug('response') { dump_headers env.response_headers }
-      debug('response') { dump_body env[:body] } if env[:body] && log_body?(:response)
-    end
-
-    private
-
-    def dump_headers(headers)
-      headers.map { |k, v| "#{k}: #{v.inspect}" }.join("\n")
-    end
-
-    def dump_body(body)
-      if body.respond_to?(:to_str)
-        body.to_str
-      else
-        pretty_inspect(body)
-      end
-    end
-
-    def pretty_inspect(body)
-      require 'pp' unless body.respond_to?(:pretty_inspect)
-      body.pretty_inspect
-    end
-
-    def log_body?(type)
-      case @options[:bodies]
-      when Hash then @options[:bodies][type]
-      else @options[:bodies]
-      end
-    end
-  end
-end

data/.gs/gems/faraday-0.9.2/lib/faraday/response/raise_error.rb

@@ -1,21 +0,0 @@
-module Faraday
-  class Response::RaiseError < Response::Middleware
-    ClientErrorStatuses = 400...600
-
-    def on_complete(env)
-      case env[:status]
-      when 404
-        raise Faraday::Error::ResourceNotFound, response_values(env)
-      when 407
-        # mimic the behavior that we get with proxy requests with HTTPS
-        raise Faraday::Error::ConnectionFailed, %{407 "Proxy Authentication Required "}
-      when ClientErrorStatuses
-        raise Faraday::Error::ClientError, response_values(env)
-      end
-    end
-
-    def response_values(env)
-      {:status => env.status, :headers => env.response_headers, :body => env.body}
-    end
-  end
-end

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

@@ -1,93 +0,0 @@
-require 'forwardable'
-
-module Faraday
-  class Response
-    # Used for simple response middleware.
-    class Middleware < Faraday::Middleware
-      def call(env)
-        @app.call(env).on_complete do |environment|
-          on_complete(environment)
-        end
-      end
-
-      # Override this to modify the environment after the response has finished.
-      # Calls the `parse` method if defined
-      def on_complete(env)
-        env.body = parse(env.body) if respond_to?(:parse) && env.parse_body?
-      end
-    end
-
-    extend Forwardable
-    extend MiddlewareRegistry
-
-    register_middleware File.expand_path('../response', __FILE__),
-      :raise_error => [:RaiseError, 'raise_error'],
-      :logger => [:Logger, 'logger']
-
-    def initialize(env = nil)
-      @env = Env.from(env) if env
-      @on_complete_callbacks = []
-    end
-
-    attr_reader :env
-
-    def_delegators :env, :to_hash
-
-    def status
-      finished? ? env.status : nil
-    end
-
-    def headers
-      finished? ? env.response_headers : {}
-    end
-    def_delegator :headers, :[]
-
-    def body
-      finished? ? env.body : nil
-    end
-
-    def finished?
-      !!env
-    end
-
-    def on_complete
-      if not finished?
-        @on_complete_callbacks << Proc.new
-      else
-        yield(env)
-      end
-      return self
-    end
-
-    def finish(env)
-      raise "response already finished" if finished?
-      @env = env.is_a?(Env) ? env : Env.from(env)
-      @on_complete_callbacks.each { |callback| callback.call(@env) }
-      return self
-    end
-
-    def success?
-      finished? && env.success?
-    end
-
-    # because @on_complete_callbacks cannot be marshalled
-    def marshal_dump
-      !finished? ? nil : {
-        :status => @env.status, :body => @env.body,
-        :response_headers => @env.response_headers
-      }
-    end
-
-    def marshal_load(env)
-      @env = Env.from(env)
-    end
-
-    # Expand the env with more properties, without overriding existing ones.
-    # Useful for applying request params after restoring a marshalled Response.
-    def apply_request(request_env)
-      raise "response didn't finish yet" unless finished?
-      @env = Env.from(request_env).update(@env)
-      return self
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-begin
-  require 'composite_io'
-  require 'parts'
-  require 'stringio'
-rescue LoadError
-  $stderr.puts "Install the multipart-post gem."
-  raise
-end
-
-module Faraday
-  # Similar but not compatible with ::CompositeReadIO provided by multipart-post.
-  class CompositeReadIO
-    def initialize(*parts)
-      @parts = parts.flatten
-      @ios = @parts.map { |part| part.to_io }
-      @index = 0
-    end
-
-    def length
-      @parts.inject(0) { |sum, part| sum + part.length }
-    end
-
-    def rewind
-      @ios.each { |io| io.rewind }
-      @index = 0
-    end
-
-    # Read from IOs in order until `length` bytes have been received.
-    def read(length = nil, outbuf = nil)
-      got_result = false
-      outbuf = outbuf ? outbuf.replace("") : ""
-
-      while io = current_io
-        if result = io.read(length)
-          got_result ||= !result.nil?
-          result.force_encoding("BINARY") if result.respond_to?(:force_encoding)
-          outbuf << result
-          length -= result.length if length
-          break if length == 0
-        end
-        advance_io
-      end
-      (!got_result && length) ? nil : outbuf
-    end
-
-    def close
-      @ios.each { |io| io.close }
-    end
-
-    def ensure_open_and_readable
-      # Rubinius compatibility
-    end
-
-    private
-
-    def current_io
-      @ios[@index]
-    end
-
-    def advance_io
-      @index += 1
-    end
-  end
-
-  UploadIO = ::UploadIO
-  Parts = ::Parts
-end

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

@@ -1,309 +0,0 @@
-require 'thread'
-
-module Faraday
-  module Utils
-    extend self
-
-    # Adapted from Rack::Utils::HeaderHash
-    class Headers < ::Hash
-      def self.from(value)
-        new(value)
-      end
-
-      def initialize(hash = nil)
-        super()
-        @names = {}
-        self.update(hash || {})
-      end
-
-      # on dup/clone, we need to duplicate @names hash
-      def initialize_copy(other)
-        super
-        @names = other.names.dup
-      end
-
-      # need to synchronize concurrent writes to the shared KeyMap
-      keymap_mutex = Mutex.new
-
-      # symbol -> string mapper + cache
-      KeyMap = Hash.new do |map, key|
-        value = if key.respond_to?(:to_str)
-          key
-        else
-          key.to_s.split('_').            # :user_agent => %w(user agent)
-            each { |w| w.capitalize! }.   # => %w(User Agent)
-            join('-')                     # => "User-Agent"
-        end
-        keymap_mutex.synchronize { map[key] = value }
-      end
-      KeyMap[:etag] = "ETag"
-
-      def [](k)
-        k = KeyMap[k]
-        super(k) || super(@names[k.downcase])
-      end
-
-      def []=(k, v)
-        k = KeyMap[k]
-        k = (@names[k.downcase] ||= k)
-        # join multiple values with a comma
-        v = v.to_ary.join(', ') if v.respond_to? :to_ary
-        super(k, v)
-      end
-
-      def fetch(k, *args, &block)
-        k = KeyMap[k]
-        key = @names.fetch(k.downcase, k)
-        super(key, *args, &block)
-      end
-
-      def delete(k)
-        k = KeyMap[k]
-        if k = @names[k.downcase]
-          @names.delete k.downcase
-          super(k)
-        end
-      end
-
-      def include?(k)
-        @names.include? k.downcase
-      end
-
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
-
-      def merge!(other)
-        other.each { |k, v| self[k] = v }
-        self
-      end
-      alias_method :update, :merge!
-
-      def merge(other)
-        hash = dup
-        hash.merge! other
-      end
-
-      def replace(other)
-        clear
-        @names.clear
-        self.update other
-        self
-      end
-
-      def to_hash() ::Hash.new.update(self) end
-
-      def parse(header_string)
-        return unless header_string && !header_string.empty?
-        header_string.split(/\r\n/).
-          tap  { |a| a.shift if a.first.index('HTTP/') == 0 }. # drop the HTTP status line
-          map  { |h| h.split(/:\s+/, 2) }.reject { |p| p[0].nil? }. # split key and value, ignore blank lines
-          each { |key, value|
-            # join multiple values with a comma
-            if self[key]
-              self[key] << ', ' << value
-            else
-              self[key] = value
-            end
-          }
-      end
-
-      protected
-
-      def names
-        @names
-      end
-    end
-
-    # hash with stringified keys
-    class ParamsHash < Hash
-      def [](key)
-        super(convert_key(key))
-      end
-
-      def []=(key, value)
-        super(convert_key(key), value)
-      end
-
-      def delete(key)
-        super(convert_key(key))
-      end
-
-      def include?(key)
-        super(convert_key(key))
-      end
-
-      alias_method :has_key?, :include?
-      alias_method :member?, :include?
-      alias_method :key?, :include?
-
-      def update(params)
-        params.each do |key, value|
-          self[key] = value
-        end
-        self
-      end
-      alias_method :merge!, :update
-
-      def merge(params)
-        dup.update(params)
-      end
-
-      def replace(other)
-        clear
-        update(other)
-      end
-
-      def merge_query(query, encoder = nil)
-        if query && !query.empty?
-          update((encoder || Utils.default_params_encoder).decode(query))
-        end
-        self
-      end
-
-      def to_query(encoder = nil)
-        (encoder || Utils.default_params_encoder).encode(self)
-      end
-
-      private
-
-      def convert_key(key)
-        key.to_s
-      end
-    end
-
-    def build_query(params)
-      FlatParamsEncoder.encode(params)
-    end
-
-    def build_nested_query(params)
-      NestedParamsEncoder.encode(params)
-    end
-
-    ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
-
-    def escape(s)
-      s.to_s.gsub(ESCAPE_RE) {|match|
-        '%' + match.unpack('H2' * match.bytesize).join('%').upcase
-      }.tr(' ', '+')
-    end
-
-    def unescape(s) CGI.unescape s.to_s end
-
-    DEFAULT_SEP = /[&;] */n
-
-    # Adapted from Rack
-    def parse_query(query)
-      FlatParamsEncoder.decode(query)
-    end
-
-    def parse_nested_query(query)
-      NestedParamsEncoder.decode(query)
-    end
-
-    def default_params_encoder
-      @default_params_encoder ||= NestedParamsEncoder
-    end
-
-    class << self
-      attr_writer :default_params_encoder
-    end
-
-    # Stolen from Rack
-    def normalize_params(params, name, v = nil)
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''
-      after = $' || ''
-
-      return if k.empty?
-
-      if after == ""
-        if params[k]
-          params[k] = Array[params[k]] unless params[k].kind_of?(Array)
-          params[k] << v
-        else
-          params[k] = v
-        end
-      elsif after == "[]"
-        params[k] ||= []
-        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        params[k] << v
-      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
-        child_key = $1
-        params[k] ||= []
-        raise TypeError, "expected Array (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Array)
-        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
-          normalize_params(params[k].last, child_key, v)
-        else
-          params[k] << normalize_params({}, child_key, v)
-        end
-      else
-        params[k] ||= {}
-        raise TypeError, "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless params[k].is_a?(Hash)
-        params[k] = normalize_params(params[k], after, v)
-      end
-
-      return params
-    end
-
-    # Normalize URI() behavior across Ruby versions
-    #
-    # url - A String or URI.
-    #
-    # Returns a parsed URI.
-    def URI(url)
-      if url.respond_to?(:host)
-        url
-      elsif url.respond_to?(:to_str)
-        default_uri_parser.call(url)
-      else
-        raise ArgumentError, "bad argument (expected URI object or URI string)"
-      end
-    end
-
-    def default_uri_parser
-      @default_uri_parser ||= begin
-        require 'uri'
-        Kernel.method(:URI)
-      end
-    end
-
-    def default_uri_parser=(parser)
-      @default_uri_parser = if parser.respond_to?(:call) || parser.nil?
-        parser
-      else
-        parser.method(:parse)
-      end
-    end
-
-    # Receives a String or URI and returns just the path with the query string sorted.
-    def normalize_path(url)
-      url = URI(url)
-      (url.path.start_with?('/') ? url.path : '/' + url.path) +
-      (url.query ? "?#{sort_query_params(url.query)}" : "")
-    end
-
-    # Recursive hash update
-    def deep_merge!(target, hash)
-      hash.each do |key, value|
-        if Hash === value and Hash === target[key]
-          target[key] = deep_merge(target[key], value)
-        else
-          target[key] = value
-        end
-      end
-      target
-    end
-
-    # Recursive hash merge
-    def deep_merge(source, hash)
-      deep_merge!(source.dup, hash)
-    end
-
-    protected
-
-    def sort_query_params(query)
-      query.split('&').sort.join('&')
-    end
-  end
-end