Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://rubydoc.info/github/piotrmurach/github/master/Github/API/Arguments below:

Arguments – Documentation for piotrmurach/github (master) – RubyDoc.info

A class responsible for handling request arguments

'auto_pagination'.freeze

Validations::VALID_API_KEYS

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

• #api ⇒ Object readonly

  The request api.

• #params ⇒ Object readonly

  Parameters passed to request.

• #remaining ⇒ Object readonly

  The remaining unparsed arguments.

• #[](property) ⇒ Object

  Hash like access to request arguments.

• #[]=(property, value) ⇒ Object
• #assert_required(*required) ⇒ Object

  Check if required keys are present inside parameters hash.

• #assert_values(values, key = nil) ⇒ Object

  Check if parameters match expected values.

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

  Initialize an Arguments.

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

  Specify optional attribute(s).

• #parse(*args, &block) ⇒ Object

  Parse arguments to allow for flexible api calls.

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

  Remove unknown keys from parameters hash.

• #require(*attrs, &block) ⇒ Object (also: #required)

  Specify required attribute(s).

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

#assert_required_keys

#validates_token_for

#assert_valid_values

#assert_presence_of

#filter!

#normalize!

38
39
40
41
42
43
44
45
46
47

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

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

This class handles dynamic methods through the method_missing method

79
80
81
82
83
84
85

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

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

25
26
27

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

def api
  @api
end

Parameters passed to request

19
20
21

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

def params
  @params
end

The remaining unparsed arguments

22
23
24

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

def remaining
  @remaining
end

Hash like access to request arguments

71
72
73

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

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

75
76
77

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

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

Check if required keys are present inside parameters hash.

126
127
128
129

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

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

Check if parameters match expected values.

134
135
136
137

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

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

Specify optional attribute(s)

62
63

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

def optional(*attrs, &block)
end

Parse arguments to allow for flexible api calls

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

96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

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

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

  if args.size.zero?      parse_hash(options)
  else
    parse_array(*args)
  end
  @params    = options
  @remaining = args[@required.size..-1]
  (options)

  yield_or_eval(&block)
  self
end

Remove unknown keys from parameters hash.

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

118
119
120
121

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

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

Specify required attribute(s)

52
53
54
55
56

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

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

87
88
89

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

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

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4