Class: Arango::Request

Inherits:

Object

Object
Arango::Request

show all

Defined in:: lib/arango/request.rb

Overview

Arango Request Implements REST API to Arango Used to define accessor classes to run execute Strictly internal. Not user accessible. Used to implement REST API representation classes.

Direct Known Subclasses

Instance Attribute Summary collapse

#args ⇒ Object readonly

Returns the value of attribute args.
#database ⇒ Object readonly

Returns the value of attribute database.
#formatted_body ⇒ Object readonly

Returns the value of attribute formatted_body.
#formatted_headers ⇒ Object readonly

Returns the value of attribute formatted_headers.
#formatted_params ⇒ Object readonly

Returns the value of attribute formatted_params.
#server ⇒ Object readonly

Returns the value of attribute server.

Class Method Summary collapse

.body(name, option = nil, &block) ⇒ Object

define body element.
.body_any ⇒ Object

allow any body content.
.body_any_key_allowed ⇒ Object

allow any body keys.
.body_array ⇒ Object

make body an Array.
.body_is_array? ⇒ Boolean

check if body is an Array.
.body_keys ⇒ Hash

get body keys sets @body_keys to empty Hash (if unset).
.code(number, message) ⇒ Object

define known http code and its meaning.
.codes ⇒ Hash

get known http return codes and their meanings sets codes to empty hash if undefined.
.execute(**args) ⇒ Arango::Result

execute Arango::Request.
.has_body? ⇒ Boolean

check if body exists.
.has_header? ⇒ Boolean

if request has a header defined.
.has_param? ⇒ Boolean

parameters defined ?.
.header(name, option = nil) ⇒ Object

define header element.
.headers ⇒ Hash

get defined headers sets headers to empty Hash if undefined.
.key(name, option = nil) ⇒ Object

define body key.
.param(name, option = nil) ⇒ Object

define parameter element.
.params ⇒ Hash

get defined parameters sets parameters to empty Hash if undefined.
.reqm ⇒ Object

get request method.
.request_method=(name) ⇒ Object

define request method.
.uri_template ⇒ Object

get uri template.
.uri_template=(template) ⇒ Object

define uri template for API call see rubydoc.info/gems/addressable/Addressable/Template.

Instance Method Summary collapse

#execute ⇒ Arango::Result

execute request.
#formatted_uri ⇒ Object

create expanded URI, (from template, including keys) and http:// prefix.
#initialize(body: nil, params: {}, headers: nil, args: nil, server:) ⇒ Request constructor

create Arango::Request instance.

Constructor Details

#initialize(body: nil, params: {}, headers: nil, args: nil, server:) ⇒ `Request`

create Arango::Request instance

# File 'lib/arango/request.rb', line 206

def initialize(body: nil, params: {}, headers: nil, args: nil, server:)
  @server = server
  if args
    @database = args.delete(:db)
    @args = args
  end
  @formatted_headers = validate_and_format_header!(headers) if self.class.has_header?
  @formatted_params = validate_and_format_params!(params) if self.class.has_param?
  @formatted_body = if self.class.body_is_array? || self.class.body_any_key_allowed
                      body
                    elsif self.class.has_body?
                      validate_and_format_body!(body)
                    end
end

Instance Attribute Details

#args ⇒ `Object` (readonly)

Returns the value of attribute args.



185
186
187

# File 'lib/arango/request.rb', line 185

def args
  @args
end

#database ⇒ `Object` (readonly)

Returns the value of attribute database.



186
187
188

# File 'lib/arango/request.rb', line 186

def database
  @database
end

#formatted_body ⇒ `Object` (readonly)

Returns the value of attribute formatted_body.



189
190
191

# File 'lib/arango/request.rb', line 189

def formatted_body
  @formatted_body
end

#formatted_headers ⇒ `Object` (readonly)

Returns the value of attribute formatted_headers.



187
188
189

# File 'lib/arango/request.rb', line 187

def formatted_headers
  @formatted_headers
end

#formatted_params ⇒ `Object` (readonly)

Returns the value of attribute formatted_params.



188
189
190

# File 'lib/arango/request.rb', line 188

def formatted_params
  @formatted_params
end

#server ⇒ `Object` (readonly)

Returns the value of attribute server.



190
191
192

# File 'lib/arango/request.rb', line 190

def server
  @server
end

Class Method Details

.body(name, option = nil, &block) ⇒ `Object`

define body element

# File 'lib/arango/request.rb', line 39

def body(name, option = nil, &block)
  @has_body = true
  camel_name = name.to_s.camelize(:lower)
  case option
  when :required then body_keys[name] = { camel: camel_name, required: true }
  when :optional then body_keys[name] = { camel: camel_name }
  when nil then body_keys[name] = { camel: camel_name }
  else
    raise Arango::Error.new("Unknown option '#{option}'!")
  end
  if block_given?
    @current_nested_body = Hash.new
    block.call
    body_keys[name][:nested] = @current_nested_body
  end
ensure
  @current_nested_body = nil
end

.body_any ⇒ `Object`

allow any body content

# File 'lib/arango/request.rb', line 65

def body_any
  @has_body = true
  @body_any_key_allowed = true
end

.body_any_key_allowed ⇒ `Object`

allow any body keys



71
72
73

# File 'lib/arango/request.rb', line 71

def body_any_key_allowed
  @body_any_key_allowed
end

.body_array ⇒ `Object`

make body an Array

# File 'lib/arango/request.rb', line 59

def body_array
  body_any
  @body_is_array = true
end

.body_is_array? ⇒ `Boolean`

check if body is an Array



25
26
27

# File 'lib/arango/request.rb', line 25

def body_is_array?
  @body_is_array
end

.body_keys ⇒ `Hash`

get body keys sets @body_keys to empty Hash (if unset)



32
33
34

# File 'lib/arango/request.rb', line 32

def body_keys
  @body_keys ||= Hash.new
end

.code(number, message) ⇒ `Object`

define known http code and its meaning



180
181
182

# File 'lib/arango/request.rb', line 180

def code(number, message)
  codes[number] = message
end

.codes ⇒ `Hash`

get known http return codes and their meanings sets codes to empty hash if undefined



173
174
175

# File 'lib/arango/request.rb', line 173

def codes
  @codes ||= {}
end

.execute(**args) ⇒ `Arango::Result`

execute Arango::Request



13
14
15

# File 'lib/arango/request.rb', line 13

def execute(**args)
  self.new(**args).execute
end

.has_body? ⇒ `Boolean`

check if body exists



19
20
21

# File 'lib/arango/request.rb', line 19

def has_body?
  @has_body
end

.has_header? ⇒ `Boolean`

if request has a header defined



93
94
95

# File 'lib/arango/request.rb', line 93

def has_header?
  @has_header
end

.has_param? ⇒ `Boolean`

parameters defined ?



121
122
123

# File 'lib/arango/request.rb', line 121

def has_param?
  @has_param
end

.header(name, option = nil) ⇒ `Object`

define header element

# File 'lib/arango/request.rb', line 107

def header(name, option = nil)
  @has_header = true
  key = name.underscore.downcase.to_sym
  case option
  when :required then headers[key] = { real: name, required: true }
  when :optional then headers[key] = { real: name }
  when nil then headers[key] = { real: name }
  else
    raise Arango::Error.new("Unknown option #{option}")
  end
end

.headers ⇒ `Hash`

get defined headers sets headers to empty Hash if undefined



100
101
102

# File 'lib/arango/request.rb', line 100

def headers
  @headers ||= Hash.new
end

.key(name, option = nil) ⇒ `Object`

define body key

Raises:

(Arango::Error)

# File 'lib/arango/request.rb', line 78

def key(name, option = nil)
  raise Arango::Error.new("No body context!") unless @current_nested_body
  camel_name = name.to_s.camelize(:lower)
  value = case option
          when :required then { camel: camel_name, required: true }
          when :optional then { camel: camel_name }
          when nil then { camel: camel_name }
          else
            raise Arango::Error.new("Unknown option '#{option}'!")
          end
  @current_nested_body[name] = value
end

.param(name, option = nil) ⇒ `Object`

define parameter element

# File 'lib/arango/request.rb', line 135

def param(name, option = nil)
  @has_param = true
  camel_name = name.to_s.camelize(:lower)
  case option
  when :required then params[name] = { camel: camel_name, required: true }
  when :optional then params[name] = { camel: camel_name }
  when nil then params[name] = { camel: camel_name }
  else
    raise Arango::Error.new("Unknown option #{option}")
  end
end

.params ⇒ `Hash`

get defined parameters sets parameters to empty Hash if undefined



128
129
130

# File 'lib/arango/request.rb', line 128

def params
  @params ||= Hash.new
end

.reqm ⇒ `Object`

get request method



154
155
156

# File 'lib/arango/request.rb', line 154

def reqm
  @request_method
end

.request_method=(name) ⇒ `Object`

define request method



149
150
151

# File 'lib/arango/request.rb', line 149

def request_method= name
  @request_method = name
end

.uri_template ⇒ `Object`

get uri template



166
167
168

# File 'lib/arango/request.rb', line 166

def uri_template
  @uri_template
end

.uri_template=(template) ⇒ `Object`

define uri template for API call see rubydoc.info/gems/addressable/Addressable/Template



161
162
163

# File 'lib/arango/request.rb', line 161

def uri_template= template
  @uri_template = Addressable::Template.new(template)
end

Instance Method Details

#execute ⇒ `Arango::Result`

execute request

Raises:

(Arango::Error)

# File 'lib/arango/request.rb', line 224

def execute
  response, response_code = server.driver_instance.execute_request(self.class.reqm, formatted_uri, formatted_headers, formatted_params, formatted_body)

  if self.class.codes.key?(response_code)
    raise Arango::Error.new(self.class.codes[response_code]) unless self.class.codes[response_code] == :success
  else
    raise Arango::Error.new("Unknown response code #{response_code}")
  end

  begin
    response[:code] = response_code
  rescue TypeError
    # response might be an Array
  end

  result = Arango::Result.new(response)

  # block ? block.call(result) : result
  result
end

#formatted_uri ⇒ `Object`

create expanded URI, (from template, including keys) and http:// prefix

# File 'lib/arango/request.rb', line 193

def formatted_uri
  hash = {}
  hash['db_context'] = ['_db', database] if database
  hash.merge!(args.transform_keys(&:to_s)) if args
  server.driver_instance.base_uri + self.class.uri_template.expand(hash)
end

Class: Arango::Request

Overview

Direct Known Subclasses

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(body: nil, params: {}, headers: nil, args: nil, server:) ⇒ Request

Instance Attribute Details

#args ⇒ Object (readonly)

#database ⇒ Object (readonly)

#formatted_body ⇒ Object (readonly)

#formatted_headers ⇒ Object (readonly)

#formatted_params ⇒ Object (readonly)

#server ⇒ Object (readonly)

Class Method Details

.body(name, option = nil, &block) ⇒ Object

.body_any ⇒ Object

.body_any_key_allowed ⇒ Object

.body_array ⇒ Object

.body_is_array? ⇒ Boolean

.body_keys ⇒ Hash

.code(number, message) ⇒ Object

.codes ⇒ Hash

.execute(**args) ⇒ Arango::Result

.has_body? ⇒ Boolean

.has_header? ⇒ Boolean

.has_param? ⇒ Boolean

.header(name, option = nil) ⇒ Object

.headers ⇒ Hash

.key(name, option = nil) ⇒ Object

.param(name, option = nil) ⇒ Object

.params ⇒ Hash

.reqm ⇒ Object

.request_method=(name) ⇒ Object

.uri_template ⇒ Object

.uri_template=(template) ⇒ Object