+++ /dev/null
-require 'thread'
-Faraday.require_libs 'parameters'
-
-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
-
- # 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
- 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
- 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
projects / dsa-puppet.git / blobdiff