class GdsApi::Response

> “/bank-holidays”<br>r.results.web_url
r = Response.new(response, web_urls_relative_to: “www.gov.uk”)
Example:
See: github.com/alphagov/wiki/wiki/API-conventions for details on the API conventions
This is useful on non-canonical frontends, such as those in staging environments.
By specifying a base URI, this will convert all matching web_urls into relative URLs
GOV.UK context. However on internal systems we want to present relative URLs.
API endpoints should return absolute URLs so that they make sense outside of the
Responses can be configured to use relative URLs for ‘web_url` properties.
an object that has the read behaviour of both a Hash and an OpenStruct
This wraps an HTTP response with a JSON body, and presents this as ↑

def self.build_ostruct_recursively(value) 

def self.build_ostruct_recursively(value)
  case value
  when Hash
    OpenStruct.new(Hash[value.map { |k, v| [k, build_ostruct_recursively(v)] }])
  when Array
    value.map { |v| build_ostruct_recursively(v) }
  else
    value
  end
end

def blank?; false; end 

def blank?; false; end

def code 

def code
  # Return an integer code for consistency with HTTPErrorResponse
  @http_response.code
end

def initialize(http_response, options = {}) 

def initialize(http_response, options = {})
  @http_response = http_response
  @web_urls_relative_to = URI.parse(options[:web_urls_relative_to]) if options[:web_urls_relative_to]
end

def method_missing(method) 

def method_missing(method)
  to_ostruct.send(method)
end

def present?; true; end 

def present?; true; end

def raw_response_body 

def raw_response_body
  @http_response.body
end

def respond_to_missing?(method, include_private) 

def respond_to_missing?(method, include_private)
  to_ostruct.respond_to?(method, include_private)
end

def to_hash 

def to_hash
  @parsed ||= transform_parsed(JSON.parse(@http_response.body))
end

def to_ostruct 

def to_ostruct
  @ostruct ||= self.class.build_ostruct_recursively(to_hash)
end

def transform_parsed(value) 

def transform_parsed(value)
  return value if @web_urls_relative_to.nil?
  case value
  when Hash
    Hash[value.map { |k, v|
      # NOTE: Don't bother transforming if the value is nil
      if 'web_url' == k && v
        # Use relative URLs to route when the web_url value is on the
        # same domain as the site root. Note that we can't just use the
        # `route_to` method, as this would give us technically correct
        # but potentially confusing `//host/path` URLs for URLs with the
        # same scheme but different hosts.
        relative_url = @web_urls_relative_to.route_to(v)
        [k, relative_url.host ? v : relative_url.to_s]
      else
        [k, transform_parsed(v)]
      end
    }]
  when Array
    value.map { |v| transform_parsed(v) }
  else
    value
  end
end