3rdparty/modules/aviator/feature/faraday/parameters.rb

   1 module Faraday
   2   module NestedParamsEncoder
   3     ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
   4
   5     def self.escape(s)
   6       return s.to_s.gsub(ESCAPE_RE) {
   7         '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
   8       }.tr(' ', '+')
   9     end
  10
  11     def self.unescape(s)
  12       CGI.unescape(s.to_s)
  13     end
  14
  15     def self.encode(params)
  16       return nil if params == nil
  17
  18       if !params.is_a?(Array)
  19         if !params.respond_to?(:to_hash)
  20           raise TypeError,
  21             "Can't convert #{params.class} into Hash."
  22         end
  23         params = params.to_hash
  24         params = params.map do |key, value|
  25           key = key.to_s if key.kind_of?(Symbol)
  26           [key, value]
  27         end
  28         # Useful default for OAuth and caching.
  29         # Only to be used for non-Array inputs. Arrays should preserve order.
  30         params.sort!
  31       end
  32
  33       # Helper lambda
  34       to_query = lambda do |parent, value|
  35         if value.is_a?(Hash)
  36           value = value.map do |key, val|
  37             key = escape(key)
  38             [key, val]
  39           end
  40           value.sort!
  41           buffer = ""
  42           value.each do |key, val|
  43             new_parent = "#{parent}%5B#{key}%5D"
  44             buffer << "#{to_query.call(new_parent, val)}&"
  45           end
  46           return buffer.chop
  47         elsif value.is_a?(Array)
  48           buffer = ""
  49           value.each_with_index do |val, i|
  50             new_parent = "#{parent}%5B%5D"
  51             buffer << "#{to_query.call(new_parent, val)}&"
  52           end
  53           return buffer.chop
  54         else
  55           encoded_value = escape(value)
  56           return "#{parent}=#{encoded_value}"
  57         end
  58       end
  59
  60       # The params have form [['key1', 'value1'], ['key2', 'value2']].
  61       buffer = ''
  62       params.each do |parent, value|
  63         encoded_parent = escape(parent)
  64         buffer << "#{to_query.call(encoded_parent, value)}&"
  65       end
  66       return buffer.chop
  67     end
  68
  69     def self.decode(query)
  70       return nil if query == nil
  71       # Recursive helper lambda
  72       dehash = lambda do |hash|
  73         hash.each do |(key, value)|
  74           if value.kind_of?(Hash)
  75             hash[key] = dehash.call(value)
  76           end
  77         end
  78         # Numeric keys implies an array
  79         if hash != {} && hash.keys.all? { |key| key =~ /^\d+$/ }
  80           hash.sort.inject([]) do |accu, (_, value)|
  81             accu << value; accu
  82           end
  83         else
  84           hash
  85         end
  86       end
  87
  88       empty_accumulator = {}
  89       return ((query.split('&').map do |pair|
  90         pair.split('=', 2) if pair && !pair.empty?
  91       end).compact.inject(empty_accumulator.dup) do |accu, (key, value)|
  92         key = unescape(key)
  93         if value.kind_of?(String)
  94           value = unescape(value.gsub(/\+/, ' '))
  95         end
  96
  97         array_notation = !!(key =~ /\[\]$/)
  98         subkeys = key.split(/[\[\]]+/)
  99         current_hash = accu
 100         for i in 0...(subkeys.size - 1)
 101           subkey = subkeys[i]
 102           current_hash[subkey] = {} unless current_hash[subkey]
 103           current_hash = current_hash[subkey]
 104         end
 105         if array_notation
 106           current_hash[subkeys.last] = [] unless current_hash[subkeys.last]
 107           current_hash[subkeys.last] << value
 108         else
 109           current_hash[subkeys.last] = value
 110         end
 111         accu
 112       end).inject(empty_accumulator.dup) do |accu, (key, value)|
 113         accu[key] = value.kind_of?(Hash) ? dehash.call(value) : value
 114         accu
 115       end
 116     end
 117   end
 118
 119   module FlatParamsEncoder
 120     ESCAPE_RE = /[^a-zA-Z0-9 .~_-]/
 121
 122     def self.escape(s)
 123       return s.to_s.gsub(ESCAPE_RE) {
 124         '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
 125       }.tr(' ', '+')
 126     end
 127
 128     def self.unescape(s)
 129       CGI.unescape(s.to_s)
 130     end
 131
 132     def self.encode(params)
 133       return nil if params == nil
 134
 135       if !params.is_a?(Array)
 136         if !params.respond_to?(:to_hash)
 137           raise TypeError,
 138             "Can't convert #{params.class} into Hash."
 139         end
 140         params = params.to_hash
 141         params = params.map do |key, value|
 142           key = key.to_s if key.kind_of?(Symbol)
 143           [key, value]
 144         end
 145         # Useful default for OAuth and caching.
 146         # Only to be used for non-Array inputs. Arrays should preserve order.
 147         params.sort!
 148       end
 149
 150       # The params have form [['key1', 'value1'], ['key2', 'value2']].
 151       buffer = ''
 152       params.each do |key, value|
 153         encoded_key = escape(key)
 154         value = value.to_s if value == true || value == false
 155         if value == nil
 156           buffer << "#{encoded_key}&"
 157         elsif value.kind_of?(Array)
 158           value.each do |sub_value|
 159             encoded_value = escape(sub_value)
 160             buffer << "#{encoded_key}=#{encoded_value}&"
 161           end
 162         else
 163           encoded_value = escape(value)
 164           buffer << "#{encoded_key}=#{encoded_value}&"
 165         end
 166       end
 167       return buffer.chop
 168     end
 169
 170     def self.decode(query)
 171       empty_accumulator = {}
 172       return nil if query == nil
 173       split_query = (query.split('&').map do |pair|
 174         pair.split('=', 2) if pair && !pair.empty?
 175       end).compact
 176       return split_query.inject(empty_accumulator.dup) do |accu, pair|
 177         pair[0] = unescape(pair[0])
 178         pair[1] = true if pair[1].nil?
 179         if pair[1].respond_to?(:to_str)
 180           pair[1] = unescape(pair[1].to_str.gsub(/\+/, " "))
 181         end
 182         if accu[pair[0]].kind_of?(Array)
 183           accu[pair[0]] << pair[1]
 184         elsif accu[pair[0]]
 185           accu[pair[0]] = [accu[pair[0]], pair[1]]
 186         else
 187           accu[pair[0]] = pair[1]
 188         end
 189         accu
 190       end
 191     end
 192   end
 193 end