Class: Github::API::Arguments

Inherits:
Object
  • Object
show all
Includes:
Normalizer, ParameterFilter, Validations
Defined in:
lib/github_api/api/arguments.rb

Overview

A class responsible for handilng request arguments

Constant Summary collapse

AUTO_PAGINATION = 
'auto_pagination'.freeze

Constants included from Validations

Validations::VALID_API_KEYS

Constants included from Validations::Token

Validations::Token::TOKEN_REQUIRED, Validations::Token::TOKEN_REQUIRED_REGEXP

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Validations::Required

#assert_required_keys

Methods included from Validations::Token

#validates_token_for

Methods included from Validations::Format

#assert_valid_values

Methods included from Validations::Presence

#assert_presence_of

Methods included from ParameterFilter

#filter!

Methods included from Normalizer

#normalize!

Constructor Details

#initialize(options = {}, &block) ⇒ Arguments

Initialize an Arguments

Parameters:

  • (defaults to: {})

Options Hash (options):

  • :required (Array[String]) —

    arguments that must be present before request is fired

  • :api (Github::API) —

    the reference to the current api

API:

  • public



33
34
35
36
37
38
39
40
41
42
 
# File 'lib/github_api/api/arguments.rb', line 33

def initialize(options = {}, &block)
  normalize! options

  @api      = options.fetch('api')
  @required = options.fetch('required', []).map(&:to_s)
  @optional = options.fetch('optional', []).map(&:to_s)
  @assigns  = {}

  yield_or_eval(&block)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object 



74
75
76
77
78
79
80
 
# File 'lib/github_api/api/arguments.rb', line 74

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

Instance Attribute Details

#api ⇒ Object (readonly)

The request api



20
21
22
 
# File 'lib/github_api/api/arguments.rb', line 20

def api
  @api
end

#params ⇒ Object (readonly)

Parameters passed to request



14
15
16
 
# File 'lib/github_api/api/arguments.rb', line 14

def params
  @params
end

#remaining ⇒ Object (readonly)

The remaining unparsed arguments



17
18
19
 
# File 'lib/github_api/api/arguments.rb', line 17

def remaining
  @remaining
end

Instance Method Details

#[](property) ⇒ Object

Hash like access to request arguments

Parameters:

  • the property name

API:

  • public



66
67
68
 
# File 'lib/github_api/api/arguments.rb', line 66

def [](property)
  @assigns[property.to_s]
end

#[]=(property, value) ⇒ Object 



70
71
72
 
# File 'lib/github_api/api/arguments.rb', line 70

def []=(property, value)
  @assigns[property.to_s] = value
end

#assert_required(*required) ⇒ Object

Check if required keys are present inside parameters hash.

API:

  • public



121
122
123
124
 
# File 'lib/github_api/api/arguments.rb', line 121

def assert_required(*required)
  assert_required_keys(required, params)
  self
end

#assert_values(values, key = nil) ⇒ Object

Check if parameters match expected values.

API:

  • public



129
130
131
132
 
# File 'lib/github_api/api/arguments.rb', line 129

def assert_values(values, key=nil)
  assert_valid_values values, (key.nil? ? params : params[key])
  self
end

#optional(*attrs, &block) ⇒ Object

Specify optional attribute(s)

API:

  • public



57
58
 
# File 'lib/github_api/api/arguments.rb', line 57

def optional(*attrs, &block)
end

#parse(*args, &block) ⇒ Object

Parse arguments to allow for flexible api calls

Arguments can be part of parameters hash or be simple string arguments.

API:

  • public



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/github_api/api/arguments.rb', line 91

def parse(*args, &block)
  options = ParamsHash.new(args.extract_options!)
  normalize! options

  if args.size.zero?  # Arguments are inside the parameters hash
    parse_hash(options)
  else
    parse_array(*args)
  end
  @params    = options
  @remaining = args[@required.size..-1]
  extract_pagination(options)

  yield_or_eval(&block)
  self
end

#permit(keys, key = nil, options = {}) ⇒ Object

Remove unknown keys from parameters hash.

Parameters

:recursive - boolean that toggles whether nested filtering should be applied



113
114
115
116
 
# File 'lib/github_api/api/arguments.rb', line 113

def permit(keys, key=nil, options={})
  filter! keys, (key.nil? ? params : params[key]), options if keys.any?
  self
end

#require(*attrs, &block) ⇒ Object Also known as: required

Specify required attribute(s)

API:

  • public



47
48
49
50
51
 
# File 'lib/github_api/api/arguments.rb', line 47

def require(*attrs, &block)
  attrs_clone = attrs.clone
  @required = Array(attrs_clone)
  self
end

#respond_to_missing?(method_name, include_private = false) ⇒ Boolean

Returns:



82
83
84
 
# File 'lib/github_api/api/arguments.rb', line 82

def respond_to_missing?(method_name, include_private = false)
  @assigns.key?(method_name) || super
end