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 



286
287
288
 
# File 'lib/twurl/oauth_client.rb', line 286

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

#authorized? ⇒ Boolean

Returns:

  • (Boolean) 


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

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
179
180
181
182
 
# 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 options.json_data
    request.body = options.data
  elsif options.data
    request.content_type = "application/x-www-form-urlencoded" unless request.content_type
    if options.raw_data
      request.body = options.data
    else
      begin
        request.body = options.data.map do |key, value|
          "#{key}" + (value.nil? ? "" : "=#{CGI.escape(value)}")
        end.join("&")
      rescue
        raise Exception, "ERROR: failed to parse POST request body"
      end
    end
  end
  request
end

#configure_http! ⇒ Object 



267
268
269
270
271
272
273
274
 
# File 'lib/twurl/oauth_client.rb', line 267

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
  consumer.http.max_retries = 0
  consumer.http.use_ssl     = true
  consumer.http.verify_mode = OpenSSL::SSL::VERIFY_NONE
end

#consumer ⇒ Object 



276
277
278
279
280
281
282
283
284
 
# File 'lib/twurl/oauth_client.rb', line 276

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 



196
197
198
199
200
201
202
203
204
 
# File 'lib/twurl/oauth_client.rb', line 196

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 



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

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

#generate_authorize_url ⇒ Object 



218
219
220
221
222
223
224
225
226
 
# File 'lib/twurl/oauth_client.rb', line 218

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) 


241
242
243
 
# File 'lib/twurl/oauth_client.rb', line 241

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

#perform_pin_authorize_workflow ⇒ Object 



206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/twurl/oauth_client.rb', line 206

def perform_pin_authorize_workflow
  @request_token = consumer.get_request_token
  CLI.puts("Go to #{generate_authorize_url} and paste in the supplied PIN")
  begin
    pin = STDIN.gets.chomp
  rescue SystemExit, Interrupt
    raise Exception, "Operation cancelled"
  end
  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 



184
185
186
187
188
189
 
# File 'lib/twurl/oauth_client.rb', line 184

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 



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

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

#save ⇒ Object 



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

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

#to_hash ⇒ Object 



258
259
260
261
262
263
264
265
 
# File 'lib/twurl/oauth_client.rb', line 258

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

#user_agent ⇒ Object 



191
192
193
194
 
# File 'lib/twurl/oauth_client.rb', line 191

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

#verify_has_username ⇒ Object 



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

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