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

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

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

Inherits:

Object

• Object
• Github::API

show all

Includes:

Authorization, Constants, MimeType, RateLimit, Request::Verbs

Defined in:

lib/github_api/api.rb,
lib/github_api/api/config.rb,
lib/github_api/api/actions.rb,
lib/github_api/api/factory.rb,
lib/github_api/api/arguments.rb,
lib/github_api/api/config/property.rb,
lib/github_api/api/config/property_set.rb

Responsible for providing inspection of api methods

Client, Client::Activity, Client::Activity::Events, Client::Activity::Feeds, Client::Activity::Notifications, Client::Activity::Starring, Client::Activity::Watching, Client::Authorizations, Client::Emojis, Client::Gists, Client::Gists::Comments, Client::GitData, Client::GitData::Blobs, Client::GitData::Commits, Client::GitData::References, Client::GitData::Tags, Client::GitData::Trees, Client::Gitignore, Client::Issues, Client::Issues::Assignees, Client::Issues::Comments, Client::Issues::Events, Client::Issues::Labels, Client::Issues::Milestones, Client::Markdown, Client::Meta, Client::Orgs, Client::Orgs::Hooks, Client::Orgs::Members, Client::Orgs::Memberships, Client::Orgs::Projects, Client::Orgs::Teams, Client::Projects, Client::Projects::Cards, Client::Projects::Columns, Client::PullRequests, Client::PullRequests::Comments, Client::PullRequests::Reviews, Client::Repos, Client::Repos::Branches, Client::Repos::Branches::Protections, Client::Repos::Collaborators, Client::Repos::Comments, Client::Repos::Commits, Client::Repos::Contents, Client::Repos::Deployments, Client::Repos::Downloads, Client::Repos::Forks, Client::Repos::Hooks, Client::Repos::Invitations, Client::Repos::Keys, Client::Repos::Merging, Client::Repos::Pages, Client::Repos::Projects, Client::Repos::PubSubHubbub, Client::Repos::Releases, Client::Repos::Releases::Assets, Client::Repos::Releases::Tags, Client::Repos::Statistics, Client::Repos::Statuses, Client::Say, Client::Scopes, Client::Search, Client::Search::Legacy, Client::Users, Client::Users::Emails, Client::Users::Followers, Client::Users::Keys

Classes: Arguments, Config, Factory

MimeType::MEDIA_LOOKUP

Constants::ACCEPT, Constants::ACCEPTED_OAUTH_SCOPES, Constants::ACCEPT_CHARSET, Constants::CACHE_CONTROL, Constants::CONTENT_LENGTH, Constants::CONTENT_TYPE, Constants::DATE, Constants::ETAG, Constants::HEADER_LAST, Constants::HEADER_LINK, Constants::HEADER_NEXT, Constants::LOCATION, Constants::META_FIRST, Constants::META_LAST, Constants::META_NEXT, Constants::META_PREV, Constants::META_REL, Constants::OAUTH_SCOPES, Constants::PARAM_PAGE, Constants::PARAM_PER_PAGE, Constants::PARAM_START_PAGE, Constants::RATELIMIT_LIMIT, Constants::RATELIMIT_REMAINING, Constants::RATELIMIT_RESET, Constants::SERVER, Constants::USER_AGENT

• .root ⇒ Object (also: root?) readonly

  Returns the value of attribute root.

• #current_options ⇒ Object

  Returns the value of attribute current_options.

• .after_callbacks ⇒ Object

  List of after callbacks.

• .after_request(callback, params = {}) ⇒ Object

  After request filter.

• .before_callbacks ⇒ Object

  List of before callbacks.

• .before_request(callback, params = {}) ⇒ Object

  Before request filter.

• .clear_request_methods! ⇒ Object
• .extend_with_actions(child_class) ⇒ nil

  Returns all API public methods for a given class.

• .extra_methods ⇒ Object
• .extract_class_name(name, options) ⇒ String private

  Extracts class name from options.

• .inherited(child_class) ⇒ Object
• .internal_methods ⇒ Object
• .method_added(method_name) ⇒ Object
• .namespace(*names) ⇒ self

  Defines a namespace.

• .request_methods ⇒ Set private

  Find all the api methods that should be considred by request callbacks.

• .require_all(prefix, *libs) ⇒ self

  Requires internal libraries.

• .root! ⇒ Object

• #api_methods_in(klass) ⇒ Object private

  Finds api methods in a class.

• #arguments(args = (not_set = true), options = {}, &block) ⇒ Object

  Acts as setter and getter for api requests arguments parsing.

• #disable_redirects ⇒ Object

  Disable following redirects inside a block.

• #execute(action, *args, &block) ⇒ Object private

  Execute action.

• #extract_basic_auth(auth) ⇒ Object private

  Extract login and password from basic_auth parameter.

• #filter_callbacks(kind, action_name) ⇒ Array[Hash] private

  Filter callbacks based on kind.

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

  Create new API.

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

  Responds to attribute query or attribute clear.

• #module_methods_in(klass) ⇒ Object private

  Finds methods included through class modules.

• #respond_to?(method_name, include_private = false) ⇒ Boolean
• #run_callbacks(action_name, &block) ⇒ Object private

  Run all callbacks associated with this action.

• #set(option, value = (not_set=true), ignore_setter = false, &block) ⇒ self

  Set a configuration option for a given namespace.

• #yield_or_eval(&block) ⇒ Object private

  Call block with argument.

#delete_request, #get_request, #head_request, #options_request, #patch_request, #post_request, #put_request

#ratelimit, #ratelimit_remaining, #ratelimit_reset

#lookup_media, #parse

#auth_code, #authenticated?, #authentication, #authorize_url, #basic_authed?, #client, #get_token

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# File 'lib/github_api/api.rb', line 59

def initialize(options={}, &block)
  opts = Github.configuration.fetch.merge(options)
  @current_options = opts

  Github.configuration.property_names.each do |key|
    send("#{key}=", opts[key])
  end
  if opts.key?(:login) && !opts[:login].nil?
    @login, @password = opts[:login], opts[:password]
  elsif opts.key?(:basic_auth) && !opts[:basic_auth].nil?
    @login, @password = (opts[:basic_auth])
  end

  yield_or_eval(&block) if block_given?
end

This class handles dynamic methods through the method_missing method

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Responds to attribute query or attribute clear

258
259
260
261
262
263
264
265
266
267

# File 'lib/github_api/api.rb', line 258

def method_missing(method_name, *args, &block)   case method_name.to_s
  when /^(.*)\?$/
    return !!send($1.to_s)
  when /^clear_(.*)$/
    send("#{$1.to_s}=", nil)
  else
    super
  end
end

Returns the value of attribute root.

134
135
136

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

def root
  @root
end

Returns the value of attribute current_options.

28
29
30

# File 'lib/github_api/api.rb', line 28

def current_options
  @current_options
end

115
116
117

# File 'lib/github_api/api.rb', line 115

def self.after_callbacks
  @after_callbacks ||= []
end

129
130
131

# File 'lib/github_api/api.rb', line 129

def self.after_request(callback, params = {})
  after_callbacks << params.merge(callback: callback)
end

108
109
110

# File 'lib/github_api/api.rb', line 108

def self.before_callbacks
  @before_callbacks ||= []
end

122
123
124

# File 'lib/github_api/api.rb', line 122

def self.before_request(callback, params = {})
  before_callbacks << params.merge(callback: callback)
end

183
184
185

# File 'lib/github_api/api.rb', line 183

def self.clear_request_methods!
  @request_methods = nil
end

Returns all API public methods for a given class.

11
12
13
14
15
16
17
18
19
20
21
22
23
24

# File 'lib/github_api/api/actions.rb', line 11

def self.extend_with_actions(child_class)
  return unless child_class.is_a?(Class)
  return if child_class.name.nil? 
  child_class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
    def self.actions
      self.new.actions
    end

    def actions
      api_methods_in(#{child_class}) + module_methods_in(#{child_class})
    end
  RUBY_EVAL
end

164
165
166

# File 'lib/github_api/api.rb', line 164

def self.
  ['actions']
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Extracts class name from options

353
354
355
356
357
358
359

# File 'lib/github_api/api.rb', line 353

def self.(name, options)
  converted  = options.fetch(:full_name, name).to_s
  converted  = converted.split('_').map(&:capitalize).join
  class_name = options.fetch(:root, false) ? '': "#{self.name}::"
  class_name += converted
  class_name
end

142
143
144
145
146
147
148
149
150
151
152
153
154

# File 'lib/github_api/api.rb', line 142

def self.inherited(child_class)
  before_callbacks.reverse_each { |callback|
    child_class.before_callbacks.unshift(callback)
  }
  after_callbacks.reverse_each { |callback|
    child_class.after_callbacks.unshift(callback)
  }
  extend_with_actions(child_class)
  unless child_class.instance_variable_defined?(:@root)
    child_class.instance_variable_set(:@root, false)
  end
  super
end

158
159
160
161
162

# File 'lib/github_api/api.rb', line 158

def self.internal_methods
  api = self
  api = api.superclass until api.root?
  api.public_instance_methods(true)
end

187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214

# File 'lib/github_api/api.rb', line 187

def self.method_added(method_name)
  method_name = method_name.to_s.gsub(/_with(out)?_callback_.*$/, '')
    return if self.root?
  return if .include?(method_name)
    return unless request_methods.include?(method_name)
    return if (@__methods_added ||= []).include?(method_name)

  class_name     = self.name.to_s.split('::').last.downcase
  with_method    = "#{method_name}_with_callback_#{class_name}"
  without_method = "#{method_name}_without_callback_#{class_name}"

  return if public_method_defined?(with_method)

  [method_name, with_method, without_method].each do |met|
    @__methods_added << met
  end
  return if public_method_defined?(with_method)

  define_method(with_method) do |*args, &block|
    send(:execute, without_method, *args, &block)
  end
  alias_method without_method, method_name
  alias_method method_name, with_method
  clear_request_methods!
end

322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337

# File 'lib/github_api/api.rb', line 322

def self.namespace(*names)
  options = names.last.is_a?(Hash) ? names.pop : {}
  names   = names.map(&:to_sym)
  name    = names.pop

  if public_method_defined?(name)
    raise ArgumentError, "namespace '#{name}' is already defined"
  end

  class_name = (name, options)

  define_method(name) do |*args, &block|
    options = args.last.is_a?(Hash) ? args.pop : {}
    API::Factory.new(class_name, current_options.merge(options), &block)
  end
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Find all the api methods that should be considred by request callbacks.

174
175
176
177
178
179
180
181

# File 'lib/github_api/api.rb', line 174

def self.request_methods
  @request_methods ||= begin
    methods = (public_instance_methods(true) -
               internal_methods +
               public_instance_methods(false)).uniq.map(&:to_s)
    Set.new(methods - )
  end
end

Requires internal libraries

50
51
52
53
54

# File 'lib/github_api/api.rb', line 50

def self.require_all(prefix, *libs)
  libs.each do |lib|
    require "#{File.join(prefix, lib)}"
  end
end

138
139
140

# File 'lib/github_api/api.rb', line 138

def self.root!
  @root = true
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Finds api methods in a class

32
33
34
35
36
37
38
39
40
41

# File 'lib/github_api/api/actions.rb', line 32

def api_methods_in(klass)
  methods = klass.send(:instance_methods, false) - [:actions]
  methods.sort.each_with_object([]) do |method_name, accumulator|
    unless method_name.to_s.include?('with') ||
           method_name.to_s.include?('without')
      accumulator << method_name
    end
    accumulator
  end
end

Acts as setter and getter for api requests arguments parsing.

Returns Arguments instance.

277
278
279
280
281
282
283

# File 'lib/github_api/api.rb', line 277

def arguments(args=(not_set = true), options={}, &block)
  if not_set
    @arguments
  else
    @arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block)
  end
end

Disable following redirects inside a block

98
99
100
101
102
103

# File 'lib/github_api/api.rb', line 98

def disable_redirects
  self.follow_redirects = false
  yield
ensure
  self.follow_redirects = true
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Execute action

246
247
248
249
250
251
252
253

# File 'lib/github_api/api.rb', line 246

def execute(action, *args, &block)
  action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '')
  result = nil
  run_callbacks(action_name) do
    result = send(action, *args, &block)
  end
  result
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Extract login and password from basic_auth parameter

86
87
88
89
90
91
92
93

# File 'lib/github_api/api.rb', line 86

def (auth)
  case auth
  when String
    auth.split(':', 2)
  when Hash
    [auth[:login], auth[:password]]
  end
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Filter callbacks based on kind

224
225
226
227
228

# File 'lib/github_api/api.rb', line 224

def filter_callbacks(kind, action_name)
  self.class.send("#{kind}_callbacks").select do |callback|
    callback[:only].nil? || callback[:only].include?(action_name)
  end
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Finds methods included through class modules

49
50
51
52
53
54
55
56
57
58

# File 'lib/github_api/api/actions.rb', line 49

def module_methods_in(klass)
  klass.included_modules.each_with_object([]) do |mod, accumulator|
    if mod.to_s =~ /#{klass}/
      mod.instance_methods(false).each do |method|
        accumulator << method
      end
    end
    accumulator
  end
end

269
270
271

# File 'lib/github_api/api.rb', line 269

def respond_to?(method_name, include_private = false)
  method_name.to_s.start_with?('clear_') || super
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Run all callbacks associated with this action

235
236
237
238
239

# File 'lib/github_api/api.rb', line 235

def run_callbacks(action_name, &block)
  filter_callbacks(:before, action_name).each { |hook| send hook[:callback] }
  yield if block_given?
  filter_callbacks(:after, action_name).each { |hook| send hook[:callback] }
end

Set a configuration option for a given namespace

294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309

# File 'lib/github_api/api.rb', line 294

def set(option, value=(not_set=true), ignore_setter=false, &block)
  raise ArgumentError, 'value not set' if block and !not_set
  return self if !not_set and value.nil?

  if not_set
    set_options option
    return self
  end

  if respond_to?("#{option}=") and not ignore_setter
    return __send__("#{option}=", value)
  end

  define_accessors option, value
  self
end

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Call block with argument

78
79
80
81

# File 'lib/github_api/api.rb', line 78

def yield_or_eval(&block)
  return unless block
  block.arity > 0 ? yield(self) : self.instance_eval(&block)
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