class Github::ResponseWrapper

A class responsible for proxing to faraday response

def ==(other)

Compare the wrapper with other wrapper for equality

def ==(other)
  self.env == other.env &&
  self.body == other.body
end

def [](key)

Convert any key to string before calling.
Lookup an attribute from the body.

def [](key)
  self.body.send(:"#{key}")
end

def body

Response raw body

def body
  response.body
end

def each

Iterate over each resource inside the body

def each
  body_parts = self.body.respond_to?(:each) ? self.body : [self.body]
  return body_parts.to_enum unless block_given?
  body_parts.each { |part| yield(part) }
end

def has_key?(key)

Check if body has an attribute

def has_key?(key)
  !self.body.is_a?(Array) && self.body.has_key?(key)
end

def headers

Return response headers

def headers
  Github::Response::Header.new(env)
end

def initialize(response, current_api)

def initialize(response, current_api)
  @response    = response
  @current_api = current_api
  @env         = response.env
end

def inspect

Print only response body

def inspect
  "#<#{self.class.name} @body=\"#{self.body}\">"
end

def method_missing(method_name, *args, &block)

Coerce any method calls for body attributes

def method_missing(method_name, *args, &block)
  if self.has_key?(method_name.to_s)
    self.[](method_name, &block)
  else
    super
  end
end

def respond_to?(method_name)

Check if method is defined on the body

def respond_to?(method_name)
  if self.has_key?(method_name.to_s)
    true
  else
    super
  end
end

def status

Response status

def status
  response.status
end

def success?

def success?
  response.success?
end

def to_ary

Convert the ResponseWrapper into an Array

def to_ary
  body.to_ary
end

def to_hash

Convert the ResponseWrapper into a Hash

def to_hash
  body.to_hash
end

def to_s

Return response body as string

def to_s
  body.to_s
end

def url

Request url

def url
  response.env[:url].to_s
end

Modules

Classes