mercadopago-custom-checkout 0.1.1

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

@@ -0,0 +1,197 @@
+require "forwardable"
+
+module Faraday
+  module NestedParamsEncoder
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
+    end
+
+    def self.encode(params)
+      return nil if params == nil
+
+      if !params.is_a?(Array)
+        if !params.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{params.class} into Hash."
+        end
+        params = params.to_hash
+        params = params.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        params.sort!
+      end
+
+      # Helper lambda
+      to_query = lambda do |parent, value|
+        if value.is_a?(Hash)
+          value = value.map do |key, val|
+            key = escape(key)
+            [key, val]
+          end
+          value.sort!
+          buffer = ""
+          value.each do |key, val|
+            new_parent = "#{parent}%5B#{key}%5D"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
+        elsif value.is_a?(Array)
+          buffer = ""
+          value.each_with_index do |val, i|
+            new_parent = "#{parent}%5B%5D"
+            buffer << "#{to_query.call(new_parent, val)}&"
+          end
+          return buffer.chop
+        elsif value.nil?
+          return parent
+        else
+          encoded_value = escape(value)
+          return "#{parent}=#{encoded_value}"
+        end
+      end
+
+      # The params have form [['key1', 'value1'], ['key2', 'value2']].
+      buffer = ''
+      params.each do |parent, value|
+        encoded_parent = escape(parent)
+        buffer << "#{to_query.call(encoded_parent, value)}&"
+      end
+      return buffer.chop
+    end
+
+    def self.decode(query)
+      return nil if query == nil
+
+      params = {}
+      query.split("&").each do |pair|
+        next if pair.empty?
+        key, value = pair.split("=", 2)
+        key = unescape(key)
+        value = unescape(value.gsub(/\+/, ' ')) if value
+
+        subkeys = key.scan(/[^\[\]]+(?:\]?\[\])?/)
+        context = params
+        subkeys.each_with_index do |subkey, i|
+          is_array = subkey =~ /[\[\]]+\Z/
+          subkey = $` if is_array
+          last_subkey = i == subkeys.length - 1
+
+          if !last_subkey || is_array
+            value_type = is_array ? Array : Hash
+            if context[subkey] && !context[subkey].is_a?(value_type)
+              raise TypeError, "expected %s (got %s) for param `%s'" % [
+                value_type.name,
+                context[subkey].class.name,
+                subkey
+              ]
+            end
+            context = (context[subkey] ||= value_type.new)
+          end
+
+          if context.is_a?(Array) && !is_array
+            if !context.last.is_a?(Hash) || context.last.has_key?(subkey)
+              context << {}
+            end
+            context = context.last
+          end
+
+          if last_subkey
+            if is_array
+              context << value
+            else
+              context[subkey] = value
+            end
+          end
+        end
+      end
+
+      dehash(params, 0)
+    end
+
+    # Internal: convert a nested hash with purely numeric keys into an array.
+    # FIXME: this is not compatible with Rack::Utils.parse_nested_query
+    def self.dehash(hash, depth)
+      hash.each do |key, value|
+        hash[key] = dehash(value, depth + 1) if value.kind_of?(Hash)
+      end
+
+      if depth > 0 && !hash.empty? && hash.keys.all? { |k| k =~ /^\d+$/ }
+        hash.keys.sort.inject([]) { |all, key| all << hash[key] }
+      else
+        hash
+      end
+    end
+  end
+
+  module FlatParamsEncoder
+    class << self
+      extend Forwardable
+      def_delegators :'Faraday::Utils', :escape, :unescape
+    end
+
+    def self.encode(params)
+      return nil if params == nil
+
+      if !params.is_a?(Array)
+        if !params.respond_to?(:to_hash)
+          raise TypeError,
+            "Can't convert #{params.class} into Hash."
+        end
+        params = params.to_hash
+        params = params.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        params.sort!
+      end
+
+      # The params have form [['key1', 'value1'], ['key2', 'value2']].
+      buffer = ''
+      params.each do |key, value|
+        encoded_key = escape(key)
+        value = value.to_s if value == true || value == false
+        if value == nil
+          buffer << "#{encoded_key}&"
+        elsif value.kind_of?(Array)
+          value.each do |sub_value|
+            encoded_value = escape(sub_value)
+            buffer << "#{encoded_key}=#{encoded_value}&"
+          end
+        else
+          encoded_value = escape(value)
+          buffer << "#{encoded_key}=#{encoded_value}&"
+        end
+      end
+      return buffer.chop
+    end
+
+    def self.decode(query)
+      empty_accumulator = {}
+      return nil if query == nil
+      split_query = (query.split('&').map do |pair|
+        pair.split('=', 2) if pair && !pair.empty?
+      end).compact
+      return split_query.inject(empty_accumulator.dup) do |accu, pair|
+        pair[0] = unescape(pair[0])
+        pair[1] = true if pair[1].nil?
+        if pair[1].respond_to?(:to_str)
+          pair[1] = unescape(pair[1].to_str.gsub(/\+/, " "))
+        end
+        if accu[pair[0]].kind_of?(Array)
+          accu[pair[0]] << pair[1]
+        elsif accu[pair[0]]
+          accu[pair[0]] = [accu[pair[0]], pair[1]]
+        else
+          accu[pair[0]] = pair[1]
+        end
+        accu
+      end
+    end
+  end
+end

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

@@ -0,0 +1,213 @@
+module Faraday
+  # A Builder that processes requests into responses by passing through an inner
+  # middleware stack (heavily inspired by Rack).
+  #
+  #   Faraday::Connection.new(:url => 'http://sushi.com') do |builder|
+  #     builder.request  :url_encoded  # Faraday::Request::UrlEncoded
+  #     builder.adapter  :net_http     # Faraday::Adapter::NetHttp
+  #   end
+  class RackBuilder
+    attr_accessor :handlers
+
+    # Error raised when trying to modify the stack after calling `lock!`
+    class StackLocked < RuntimeError; end
+
+    # borrowed from ActiveSupport::Dependencies::Reference &
+    # ActionDispatch::MiddlewareStack::Middleware
+    class Handler
+      @@constants_mutex = Mutex.new
+      @@constants = Hash.new { |h, k|
+        value = k.respond_to?(:constantize) ? k.constantize : Object.const_get(k)
+        @@constants_mutex.synchronize { h[k] = value }
+      }
+
+      attr_reader :name
+
+      def initialize(klass, *args, &block)
+        @name = klass.to_s
+        if klass.respond_to?(:name)
+          @@constants_mutex.synchronize { @@constants[@name] = klass }
+        end
+        @args, @block = args, block
+      end
+
+      def klass() @@constants[@name] end
+      def inspect() @name end
+
+      def ==(other)
+        if other.is_a? Handler
+          self.name == other.name
+        elsif other.respond_to? :name
+          klass == other
+        else
+          @name == other.to_s
+        end
+      end
+
+      def build(app)
+        klass.new(app, *@args, &@block)
+      end
+    end
+
+    def initialize(handlers = [])
+      @handlers = handlers
+      if block_given?
+        build(&Proc.new)
+      elsif @handlers.empty?
+        # default stack, if nothing else is configured
+        self.request :url_encoded
+        self.adapter Faraday.default_adapter
+      end
+    end
+
+    def build(options = {})
+      raise_if_locked
+      @handlers.clear unless options[:keep]
+      yield(self) if block_given?
+    end
+
+    def [](idx)
+      @handlers[idx]
+    end
+
+    # Locks the middleware stack to ensure no further modifications are possible.
+    def lock!
+      @handlers.freeze
+    end
+
+    def locked?
+      @handlers.frozen?
+    end
+
+    def use(klass, *args, &block)
+      if klass.is_a? Symbol
+        use_symbol(Faraday::Middleware, klass, *args, &block)
+      else
+        raise_if_locked
+        @handlers << self.class::Handler.new(klass, *args, &block)
+      end
+    end
+
+    def request(key, *args, &block)
+      use_symbol(Faraday::Request, key, *args, &block)
+    end
+
+    def response(key, *args, &block)
+      use_symbol(Faraday::Response, key, *args, &block)
+    end
+
+    def adapter(key, *args, &block)
+      use_symbol(Faraday::Adapter, key, *args, &block)
+    end
+
+    ## methods to push onto the various positions in the stack:
+
+    def insert(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      handler = self.class::Handler.new(*args, &block)
+      @handlers.insert(index, handler)
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index)
+      insert(index + 1, *args, &block)
+    end
+
+    def swap(index, *args, &block)
+      raise_if_locked
+      index = assert_index(index)
+      @handlers.delete_at(index)
+      insert(index, *args, &block)
+    end
+
+    def delete(handler)
+      raise_if_locked
+      @handlers.delete(handler)
+    end
+
+    # Processes a Request into a Response by passing it through this Builder's
+    # middleware stack.
+    #
+    # connection - Faraday::Connection
+    # request    - Faraday::Request
+    #
+    # Returns a Faraday::Response.
+    def build_response(connection, request)
+      app.call(build_env(connection, request))
+    end
+
+    # The "rack app" wrapped in middleware. All requests are sent here.
+    #
+    # The builder is responsible for creating the app object. After this,
+    # the builder gets locked to ensure no further modifications are made
+    # to the middleware stack.
+    #
+    # Returns an object that responds to `call` and returns a Response.
+    def app
+      @app ||= begin
+        lock!
+        to_app(lambda { |env|
+          response = Response.new
+          env.response = response
+          response.finish(env) unless env.parallel?
+          response
+        })
+      end
+    end
+
+    def to_app(inner_app)
+      # last added handler is the deepest and thus closest to the inner app
+      @handlers.reverse.inject(inner_app) { |app, handler| handler.build(app) }
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && @handlers == other.handlers
+    end
+
+    def dup
+      self.class.new(@handlers.dup)
+    end
+
+    # ENV Keys
+    # :method - a symbolized request method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - URI instance for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :response_headers - Hash of HTTP headers from the server
+    # :parallel_manager - sent if the connection is in parallel mode
+    # :request - Hash of options for configuring the request.
+    #   :timeout      - open/read timeout Integer in seconds
+    #   :open_timeout - read timeout Integer in seconds
+    #   :proxy        - Hash of proxy options
+    #     :uri        - Proxy Server URI
+    #     :user       - Proxy server username
+    #     :password   - Proxy server password
+    # :ssl - Hash of options for configuring SSL requests.
+    def build_env(connection, request)
+      Env.new(request.method, request.body,
+        connection.build_exclusive_url(request.path, request.params, request.options.params_encoder),
+        request.options, request.headers, connection.ssl,
+        connection.parallel_manager)
+    end
+
+    private
+
+    def raise_if_locked
+      raise StackLocked, "can't modify middleware stack after making a request" if locked?
+    end
+
+    def use_symbol(mod, key, *args, &block)
+      use(mod.lookup_middleware(key), *args, &block)
+    end
+
+    def assert_index(index)
+      idx = index.is_a?(Integer) ? index : @handlers.index(index)
+      raise "No such handler: #{index.inspect}" unless idx
+      idx
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+module Faraday
+  # Used to setup urls, params, headers, and the request body in a sane manner.
+  #
+  #   @connection.post do |req|
+  #     req.url 'http://localhost', 'a' => '1' # 'http://localhost?a=1'
+  #     req.headers['b'] = '2' # Header
+  #     req.params['c']  = '3' # GET Param
+  #     req['b']         = '2' # also Header
+  #     req.body = 'abc'
+  #   end
+  #
+  class Request < Struct.new(:method, :path, :params, :headers, :body, :options)
+    extend MiddlewareRegistry
+
+    register_middleware File.expand_path('../request', __FILE__),
+      :url_encoded => [:UrlEncoded, 'url_encoded'],
+      :multipart => [:Multipart, 'multipart'],
+      :retry => [:Retry, 'retry'],
+      :authorization => [:Authorization, 'authorization'],
+      :basic_auth => [:BasicAuthentication, 'basic_authentication'],
+      :token_auth => [:TokenAuthentication, 'token_authentication'],
+      :instrumentation => [:Instrumentation, 'instrumentation']
+
+    def self.create(request_method)
+      new(request_method).tap do |request|
+        yield(request) if block_given?
+      end
+    end
+
+    # Public: Replace params, preserving the existing hash type
+    def params=(hash)
+      if params
+        params.replace hash
+      else
+        super
+      end
+    end
+
+    # Public: Replace request headers, preserving the existing hash type
+    def headers=(hash)
+      if headers
+        headers.replace hash
+      else
+        super
+      end
+    end
+
+    def url(path, params = nil)
+      if path.respond_to? :query
+        if query = path.query
+          path = path.dup
+          path.query = nil
+        end
+      else
+        path, query = path.split('?', 2)
+      end
+      self.path = path
+      self.params.merge_query query, options.params_encoder
+      self.params.update(params) if params
+    end
+
+    def [](key)
+      headers[key]
+    end
+
+    def []=(key, value)
+      headers[key] = value
+    end
+
+    # ENV Keys
+    # :method - a symbolized request method (:get, :post)
+    # :body   - the request body that will eventually be converted to a string.
+    # :url    - URI instance for the current request.
+    # :status           - HTTP response status code
+    # :request_headers  - hash of HTTP Headers to be sent to the server
+    # :response_headers - Hash of HTTP headers from the server
+    # :parallel_manager - sent if the connection is in parallel mode
+    # :request - Hash of options for configuring the request.
+    #   :timeout      - open/read timeout Integer in seconds
+    #   :open_timeout - read timeout Integer in seconds
+    #   :proxy        - Hash of proxy options
+    #     :uri        - Proxy Server URI
+    #     :user       - Proxy server username
+    #     :password   - Proxy server password
+    # :ssl - Hash of options for configuring SSL requests.
+    def to_env(connection)
+      Env.new(method, body, connection.build_exclusive_url(path, params),
+        options, headers, connection.ssl, connection.parallel_manager)
+    end
+  end
+end
+