Module: HTTPX::Transcoder

Defined in:
lib/httpx/transcoder.rb,
lib/httpx/transcoder/body.rb,
lib/httpx/transcoder/form.rb,
lib/httpx/transcoder/gzip.rb,
lib/httpx/transcoder/json.rb,
lib/httpx/transcoder/chunker.rb,
lib/httpx/transcoder/deflate.rb,
lib/httpx/transcoder/multipart.rb,
lib/httpx/transcoder/utils/deflater.rb,
lib/httpx/transcoder/utils/inflater.rb,
lib/httpx/plugins/grpc/grpc_encoding.rb,
lib/httpx/transcoder/multipart/decoder.rb,
lib/httpx/transcoder/utils/body_reader.rb

Defined Under Namespace

Modules: Body, Chunker, Deflate, Form, GRPCEncoding, GZIP, JSON, Multipart Classes: BodyReader, Deflater, Inflater

Class Method Summary collapse

Class Method Details

.normalize_keys(key, value, cond = nil, &block) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/httpx/transcoder.rb', line 7

def normalize_keys(key, value, cond = nil, &block)
  if cond && cond.call(value)
    block.call(key.to_s, value)
  elsif value.respond_to?(:to_ary)
    if value.empty?
      block.call("#{key}[]")
    else
      value.to_ary.each do |element|
        normalize_keys("#{key}[]", element, cond, &block)
      end
    end
  elsif value.respond_to?(:to_hash)
    value.to_hash.each do |child_key, child_value|
      normalize_keys("#{key}[#{child_key}]", child_value, cond, &block)
    end
  else
    block.call(key.to_s, value)
  end
end

.normalize_query(params, name, v, depth) ⇒ Object

based on github.com/rack/rack/blob/d15dd728440710cfc35ed155d66a98dc2c07ae42/lib/rack/query_parser.rb#L82

Raises:



28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/httpx/transcoder.rb', line 28

def normalize_query(params, name, v, depth)
  raise Error, "params depth surpasses what's supported" if depth <= 0

  name =~ /\A[\[\]]*([^\[\]]+)\]*/
  k = Regexp.last_match(1) || ""
  after = Regexp.last_match ? Regexp.last_match.post_match : ""

  if k.empty?
    return Array(v) if !v.empty? && name == "[]"

    return
  end

  case after
  when ""
    params[k] = v
  when "["
    params[name] = v
  when "[]"
    params[k] ||= []
    raise Error, "expected Array (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Array)

    params[k] << v
  when /^\[\]\[([^\[\]]+)\]$/, /^\[\](.+)$/
    child_key = Regexp.last_match(1)
    params[k] ||= []
    raise Error, "expected Array (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Array)

    if params[k].last.is_a?(Hash) && !params_hash_has_key?(params[k].last, child_key)
      normalize_query(params[k].last, child_key, v, depth - 1)
    else
      params[k] << normalize_query({}, child_key, v, depth - 1)
    end
  else
    params[k] ||= {}
    raise Error, "expected Hash (got #{params[k].class}) for param '#{k}'" unless params[k].is_a?(Hash)

    params[k] = normalize_query(params[k], after, v, depth - 1)
  end

  params
end

.params_hash_has_key?(hash, key) ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/httpx/transcoder.rb', line 71

def params_hash_has_key?(hash, key)
  return false if key.include?("[]")

  key.split(/[\[\]]+/).inject(hash) do |h, part|
    next h if part == ""
    return false unless h.is_a?(Hash) && h.key?(part)

    h[part]
  end

  true
end