Class: GH::Remote

Inherits:
Wrapper show all
Defined in:
lib/gh/remote.rb

Overview

Public: This class deals with HTTP requests to Github. It is the base Wrapper you always want to use. Note that it is usually used implicitely by other wrapper classes if not specified.

Instance Attribute Summary collapse

Attributes inherited from Wrapper

#backend, #frontend, #options

Instance Method Summary collapse

Methods inherited from Wrapper

#[], [], double_dispatch, #initialize, #prefixed, wraps

Constructor Details

This class inherits a constructor from GH::Wrapper

Instance Attribute Details

#api_host ⇒ Object (readonly)

Returns the value of attribute api_host.



13
14
15
 
# File 'lib/gh/remote.rb', line 13

def api_host
  @api_host
end

#connection ⇒ Object (readonly)

Returns the value of attribute connection.



13
14
15
 
# File 'lib/gh/remote.rb', line 13

def connection
  @connection
end

#headers ⇒ Object (readonly)

Returns the value of attribute headers.



13
14
15
 
# File 'lib/gh/remote.rb', line 13

def headers
  @headers
end

#prefix ⇒ Object (readonly)

Returns the value of attribute prefix.



13
14
15
 
# File 'lib/gh/remote.rb', line 13

def prefix
  @prefix
end

Instance Method Details

#delete(key, body = nil) ⇒ Object

Public: …



106
107
108
 
# File 'lib/gh/remote.rb', line 106

def delete(key, body = nil)
  frontend.request(:delete, key, body)
end

#fetch_resource(key) ⇒ Object

Internal: …



67
68
69
 
# File 'lib/gh/remote.rb', line 67

def fetch_resource(key)
  frontend.http(:get, frontend.path_for(key), headers)
end

#full_url(key) ⇒ Object

Raises:

  • (ArgumentError) 


138
139
140
141
142
143
144
145
 
# File 'lib/gh/remote.rb', line 138

def full_url(key)
  uri = Addressable::URI.parse(key)
  uri.path = File.join(api_host.path, uri.path) unless uri.absolute? || uri.path.start_with?(api_host.path)
  uri = api_host + uri
  raise ArgumentError, "URI out of scope: #{key}" if uri.host != api_host.host

  uri
end

#generate_response(key, response) ⇒ Object

Internal: …



72
73
74
75
76
77
78
79
 
# File 'lib/gh/remote.rb', line 72

def generate_response(key, response)
  body = response.body
  headers = response.headers
  url = response.env[:url] if response.respond_to?(:env) && response.env
  url = response.url if response.respond_to?(:url)
  url = frontend.full_url(key) if url.to_s.empty?
  modify(body, headers, url)
end

#head(key) ⇒ Object

Public: …



111
112
113
 
# File 'lib/gh/remote.rb', line 111

def head(key)
  frontend.request(:head, key)
end

#http(verb, url, headers = {}, &block) ⇒ Object

Internal: …



82
83
84
85
86
87
 
# File 'lib/gh/remote.rb', line 82

def http(verb, url, headers = {}, &block)
  body = headers.delete :body
  connection.run_request(verb, url, body, headers, &block)
rescue StandardError => e
  raise Error.new(e, nil, verb:, url:, headers:)
end

#in_parallel ⇒ Object

Public: …



134
135
136
 
# File 'lib/gh/remote.rb', line 134

def in_parallel
  raise 'use GH::Parallel middleware for #in_parallel support'
end

#inspect ⇒ Object

Public: …



62
63
64
 
# File 'lib/gh/remote.rb', line 62

def inspect
  "#<#{self.class}: #{api_host}>"
end

#load(data) ⇒ Object

Public: …



129
130
131
 
# File 'lib/gh/remote.rb', line 129

def load(data)
  modify(data)
end

#patch(key, body) ⇒ Object

Public: …



116
117
118
 
# File 'lib/gh/remote.rb', line 116

def patch(key, body)
  frontend.request(:patch, key, body)
end

#path_for(key) ⇒ Object 



147
148
149
 
# File 'lib/gh/remote.rb', line 147

def path_for(key)
  frontend.full_url(key).request_uri
end

#post(key, body) ⇒ Object

Public: …



101
102
103
 
# File 'lib/gh/remote.rb', line 101

def post(key, body)
  frontend.request(:post, key, body)
end

#put(key, body) ⇒ Object

Public: …



121
122
123
 
# File 'lib/gh/remote.rb', line 121

def put(key, body)
  frontend.request(:put, key, body)
end

#request(verb, key, body = nil) ⇒ Object

Internal: …



90
91
92
93
94
95
96
97
98
 
# File 'lib/gh/remote.rb', line 90

def request(verb, key, body = nil)
  response = frontend.http(verb, path_for(key), headers) do |req|
    req.body = Response.new(body).to_s if body
  end
  frontend.generate_response(key, response)
rescue GH::Error => e
  e.info[:payload] = Response.new(body).to_s if body
  raise e
end

#reset ⇒ Object

Public: …



126
 
# File 'lib/gh/remote.rb', line 126

def reset; end

#setup(api_host, options) ⇒ Object

Public: Generates a new Remote instance.

api_host - HTTP host to send requests to, has to include schema (https or http) options - Hash with configuration options:

:token    - OAuth token to use (optional).
:username - Github user used for  (optional).
:password - Github password used for  (optional).
:origin   - Value of the origin request header (optional).
:headers  - HTTP headers to be send on every request (optional).

It is highly recommended to set origin, but not to set headers. If you set the username, you should also set the password.



27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
# File 'lib/gh/remote.rb', line 27

def setup(api_host, options)
  token, username, password = options.values_at :token, :username, :password

  api_host = api_host.api_host if api_host.respond_to? :api_host
  @api_host = Addressable::URI.parse(api_host)
  @headers = {
    'User-Agent' => options[:user_agent] || "GH/#{GH::VERSION}",
    'Accept' => options[:accept] || 'application/vnd.github.v3+json',
    'Accept-Charset' => 'utf-8'
  }

  @headers.merge! options[:headers] if options[:headers]
  @headers['Origin'] = options[:origin] if options[:origin]

  @prefix = ''
  @prefix << "#{token}@" if token
  @prefix << "#{username}:#{password}@" if username && password
  @prefix << @api_host.host

  faraday_options = { url: api_host }
  faraday_options[:ssl] = options[:ssl] if options[:ssl]
  faraday_options.merge! options[:faraday_options] if options[:faraday_options]

  @connection = Faraday.new(faraday_options) do |builder|
    builder.request(:authorization, :token, token) if token
    builder.request(:basic_auth, username, password) if username && password
    builder.request(:retry)
    builder.adapter(:typhoeus)
    builder.response(:raise_error)
    builder.use :instrumentation if defined? FaradayMiddleware::Instrumentation
    builder.response(:logger, nil, formatter: GH.const_get(options[:formatter].camelize)) if options[:formatter]
  end
end