Class: Twurl::OAuthClient

Inherits:
Object
  • Object
show all
Defined in:
lib/twurl/oauth_client.rb

Direct Known Subclasses

AppOnlyOAuthClient

Constant Summary collapse

OAUTH_CLIENT_OPTIONS = 
%w[username consumer_key consumer_secret token secret]
METHODS = 
{
  :post => Net::HTTP::Post,
  :get => Net::HTTP::Get,
  :put => Net::HTTP::Put,
  :delete => Net::HTTP::Delete,
  :options => Net::HTTP::Options,
  :head => Net::HTTP::Head,
  :copy => Net::HTTP::Copy
}

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ OAuthClient

Returns a new instance of OAuthClient.



110
111
112
113
114
115
116
117
 
# File 'lib/twurl/oauth_client.rb', line 110

def initialize(options = {})
  @username        = options['username']
  @consumer_key    = options['consumer_key']
  @consumer_secret = options['consumer_secret']
  @token           = options['token']
  @secret          = options['secret']
  configure_http!
end

Instance Attribute Details

#username ⇒ Object (readonly)

Returns the value of attribute username.



109
110
111
 
# File 'lib/twurl/oauth_client.rb', line 109

def username
  @username
end

Class Method Details

.has_oauth_options?(options) ⇒ Boolean

Returns:

  • (Boolean) 


29
30
31
 
# File 'lib/twurl/oauth_client.rb', line 29

def has_oauth_options?(options)
  (options.consumer_key && options.consumer_secret && options.access_token && options.token_secret) ? true : false
end

.load_client_for_app_only_auth(options, consumer_key) ⇒ Object 



66
67
68
69
70
71
72
73
74
75
76
 
# File 'lib/twurl/oauth_client.rb', line 66

def load_client_for_app_only_auth(options, consumer_key)
  if options.command == 'authorize'
    AppOnlyOAuthClient.new(options)
  else
    AppOnlyOAuthClient.new(
      options.oauth_client_options.merge(
        'bearer_token' => rcfile.bearer_tokens.to_hash[consumer_key]
      )
    )
  end
end

.load_client_for_non_profile_app_only_auth(options) ⇒ Object 



78
79
80
81
82
83
84
 
# File 'lib/twurl/oauth_client.rb', line 78

def load_client_for_non_profile_app_only_auth(options)
  AppOnlyOAuthClient.new(
    options.oauth_client_options.merge(
      'bearer_token' => rcfile.bearer_tokens.to_hash[options.consumer_key]
    )
  )
end

.load_client_for_username(username) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/twurl/oauth_client.rb', line 42

def load_client_for_username(username)
  if user_profiles = rcfile[username]
    if user_profiles.values.size == 1
      new(user_profiles.values.first)
    else
      raise Exception, "There is more than one consumer key associated with #{username}. Please specify which consumer key you want as well."
    end
  else
    raise Exception, "No profile for #{username}"
  end
end

.load_client_for_username_and_consumer_key(username, consumer_key) ⇒ Object 



33
34
35
36
37
38
39
40
 
# File 'lib/twurl/oauth_client.rb', line 33

def load_client_for_username_and_consumer_key(username, consumer_key)
  user_profiles = rcfile[username]
  if user_profiles && attributes = user_profiles[consumer_key]
    new(attributes)
  else
    raise Exception, "No profile for #{username}"
  end
end

.load_default_client(options) ⇒ Object

Raises:



86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/twurl/oauth_client.rb', line 86

def load_default_client(options)
  return if options.command == 'bearer_tokens'

  exception_message = "You must authorize first."
  app_only_exception_message = "To use --bearer option, you need to authorize (OAuth1.0a) and create at least one user profile (~/.twurlrc):\n\n" \
                               "twurl authorize -c key -s secret\n" \
                               "\nor, you can specify issued token's consumer_key directly:\n" \
                               "(to see your issued tokens: 'twurl bearer_tokens')\n\n" \
                               "twurl --bearer -c key '/path/to/api'"

  raise Exception, "#{options.app_only ? app_only_exception_message : exception_message}" unless rcfile.default_profile
  if options.app_only
      raise Exception, "No available bearer token found for consumer_key:#{rcfile.default_profile_consumer_key}" \
        unless rcfile.has_bearer_token_for_consumer_key?(rcfile.default_profile_consumer_key)
      load_client_for_app_only_auth(options, rcfile.default_profile_consumer_key)
  else
    load_client_for_username_and_consumer_key(*rcfile.default_profile)
  end
end

.load_from_options(options) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/twurl/oauth_client.rb', line 11

def load_from_options(options)
  if options.command == 'request' && has_oauth_options?(options)
    load_new_client_from_oauth_options(options)
  elsif options.command == 'request' && options.app_only && options.consumer_key
    load_client_for_non_profile_app_only_auth(options)
  elsif rcfile.has_oauth_profile_for_username_with_consumer_key?(options.username, options.consumer_key)
    load_client_for_username_and_consumer_key(options.username, options.consumer_key)
  elsif options.username
    load_client_for_username(options.username)
  elsif options.command == 'authorize' && options.app_only
    load_client_for_app_only_auth(options, options.consumer_key)
  elsif options.command == 'authorize'
    load_new_client_from_options(options)
  else
    load_default_client(options)
  end
end

.load_new_client_from_oauth_options(options) ⇒ Object 



58
59
60
61
62
63
64
 
# File 'lib/twurl/oauth_client.rb', line 58

def load_new_client_from_oauth_options(options)
  new(options.oauth_client_options.merge(
      'token' => options.access_token,
      'secret' => options.token_secret
    )
  )
end

.load_new_client_from_options(options) ⇒ Object 



54
55
56
 
# File 'lib/twurl/oauth_client.rb', line 54

def load_new_client_from_options(options)
  new(options.oauth_client_options)
end

.rcfile(reload = false) ⇒ Object 



4
5
6
7
8
9
 
# File 'lib/twurl/oauth_client.rb', line 4

def rcfile(reload = false)
  if reload || @rcfile.nil?
    @rcfile = RCFile.new
  end
  @rcfile
end

Instance Method Details

#access_token ⇒ Object 



281
282
283
 
# File 'lib/twurl/oauth_client.rb', line 281

def access_token
  @access_token ||= OAuth::AccessToken.new(consumer, token, secret)
end

#authorized? ⇒ Boolean

Returns:

  • (Boolean) 


228
229
230
231
 
# File 'lib/twurl/oauth_client.rb', line 228

def authorized?
  oauth_response = fetch_verify_credentials
  oauth_response.class == Net::HTTPOK
end

#build_request_from_options(options, &block) ⇒ Object 



129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/twurl/oauth_client.rb', line 129

def build_request_from_options(options, &block)
  request_class = METHODS.fetch(options.request_method.to_sym)
  request = request_class.new(options.path, options.headers)

  if options.upload && options.upload['file'].count > 0
    boundary = "00Twurl" + rand(1000000000000000000).to_s + "lruwT99"
    multipart_body = []
    file_field = options.upload['filefield'] ? options.upload['filefield'] : 'media[]'

    options.data.each {|key, value|
      multipart_body << "--#{boundary}\r\n"
      multipart_body << "Content-Disposition: form-data; name=\"#{key}\"\r\n"
      multipart_body << "\r\n"
      multipart_body << value
      multipart_body << "\r\n"
    }

    options.upload['file'].each {|filename|
      multipart_body << "--#{boundary}\r\n"
      multipart_body << "Content-Disposition: form-data; name=\"#{file_field}\"; filename=\"#{File.basename(filename)}\"\r\n"
      multipart_body << "Content-Type: application/octet-stream\r\n"
      multipart_body << "Content-Transfer-Encoding: base64\r\n" if options.upload['base64']
      multipart_body << "\r\n"

      if options.upload['base64']
        enc = Base64.encode64(File.binread(filename))
        multipart_body << enc
      else
        multipart_body << File.binread(filename)
      end
    }

    multipart_body << "\r\n--#{boundary}--\r\n"

    request.body = multipart_body.join
    request.content_type = "multipart/form-data, boundary=\"#{boundary}\""
  elsif request.content_type && options.data
    request.body = options.data.keys.first
  elsif options.data
    request.content_type = "application/x-www-form-urlencoded"
    if options.data.length == 1 && options.data.values.first == nil
      request.body = options.data.keys.first
    else
      request.body = options.data.map do |key, value|
        "#{key}=#{CGI.escape value}"
      end.join("&")
    end
  end
  request
end

#configure_http! ⇒ Object 



259
260
261
262
263
264
265
266
267
268
269
 
# File 'lib/twurl/oauth_client.rb', line 259

def configure_http!
  consumer.http.set_debug_output(Twurl.options.debug_output_io) if Twurl.options.trace
  consumer.http.read_timeout = consumer.http.open_timeout = Twurl.options.timeout || 60
  consumer.http.open_timeout = Twurl.options.connection_timeout if Twurl.options.connection_timeout
  # Only override if Net::HTTP support max_retries (since Ruby >= 2.5)
  consumer.http.max_retries = 0 if consumer.http.respond_to?(:max_retries=)
  if Twurl.options.ssl?
    consumer.http.use_ssl     = true
    consumer.http.verify_mode = OpenSSL::SSL::VERIFY_NONE
  end
end

#consumer ⇒ Object 



271
272
273
274
275
276
277
278
279
 
# File 'lib/twurl/oauth_client.rb', line 271

def consumer
  @consumer ||=
    OAuth::Consumer.new(
      consumer_key,
      consumer_secret,
      :site => Twurl.options.base_url,
      :proxy => Twurl.options.proxy
    )
end

#exchange_credentials_for_access_token ⇒ Object 



192
193
194
195
196
197
198
199
200
 
# File 'lib/twurl/oauth_client.rb', line 192

def exchange_credentials_for_access_token
  response = begin
    consumer.token_request(:post, consumer.access_token_path, nil, {})
  rescue OAuth::Unauthorized
    perform_pin_authorize_workflow
  end
  @token   = response[:oauth_token]
  @secret  = response[:oauth_token_secret]
end

#fetch_verify_credentials ⇒ Object 



224
225
226
 
# File 'lib/twurl/oauth_client.rb', line 224

def fetch_verify_credentials
  access_token.get('/1.1/account/verify_credentials.json?include_entities=false&skip_status=true')
end

#generate_authorize_url ⇒ Object 



210
211
212
213
214
215
216
217
218
 
# File 'lib/twurl/oauth_client.rb', line 210

def generate_authorize_url
  request = consumer.create_signed_request(:get, consumer.authorize_path, @request_token, pin_auth_parameters)
  params = request['Authorization'].sub(/^OAuth\s+/, '').split(/,\s+/).map { |p|
    k, v = p.split('=')
    v =~ /"(.*?)"/
    "#{k}=#{CGI::escape($1)}"
  }.join('&')
  "#{Twurl.options.base_url}#{request.path}?#{params}"
end

#needs_to_authorize? ⇒ Boolean

Returns:

  • (Boolean) 


233
234
235
 
# File 'lib/twurl/oauth_client.rb', line 233

def needs_to_authorize?
  token.nil? || secret.nil?
end

#perform_pin_authorize_workflow ⇒ Object 



202
203
204
205
206
207
208
 
# File 'lib/twurl/oauth_client.rb', line 202

def perform_pin_authorize_workflow
  @request_token = consumer.get_request_token
  CLI.puts("Go to #{generate_authorize_url} and paste in the supplied PIN")
  pin = STDIN.gets
  access_token = @request_token.get_access_token(:oauth_verifier => pin.chomp)
  {:oauth_token => access_token.token, :oauth_token_secret => access_token.secret}
end

#perform_request_from_options(options, &block) ⇒ Object 



180
181
182
183
184
185
 
# File 'lib/twurl/oauth_client.rb', line 180

def perform_request_from_options(options, &block)
  request = build_request_from_options(options)
  request.oauth!(consumer.http, consumer, access_token)
  request['user-agent'] = user_agent
  consumer.http.request(request, &block)
end

#pin_auth_parameters ⇒ Object 



220
221
222
 
# File 'lib/twurl/oauth_client.rb', line 220

def pin_auth_parameters
  {'oauth_callback' => 'oob'}
end

#save ⇒ Object 



237
238
239
240
 
# File 'lib/twurl/oauth_client.rb', line 237

def save
  verify_has_username
  self.class.rcfile << self
end

#to_hash ⇒ Object 



250
251
252
253
254
255
256
257
 
# File 'lib/twurl/oauth_client.rb', line 250

def to_hash
  OAUTH_CLIENT_OPTIONS.inject({}) do |hash, attribute|
    if value = send(attribute)
      hash[attribute] = value
    end
    hash
  end
end

#user_agent ⇒ Object 



187
188
189
190
 
# File 'lib/twurl/oauth_client.rb', line 187

def user_agent
  "twurl version: #{Version} " \
  "platform: #{RUBY_ENGINE} #{RUBY_VERSION} (#{RUBY_PLATFORM})"
end

#verify_has_username ⇒ Object 



242
243
244
245
246
247
248
 
# File 'lib/twurl/oauth_client.rb', line 242

def verify_has_username
  if username.nil? || username == ''
    oauth_response = fetch_verify_credentials
    oauth_response.body =~ /"screen_name"\s*:\s*"(.*?)"/
    @username = $1
  end
end