Class: Signet::OAuth1::Client

Inherits:
Object
  • Object
show all
Defined in:
lib/signet/oauth_1/client.rb

Instance Method Summary collapse

Constructor Details

#initialize(options = {}) ⇒ Client

Creates an OAuth 1.0 client.

Examples:

client = Signet::OAuth1::Client.new(
  :temporary_credential_uri =>
    'https://www.google.com/accounts/OAuthGetRequestToken',
  :authorization_uri =>
    'https://www.google.com/accounts/OAuthAuthorizeToken',
  :token_credential_uri =>
    'https://www.google.com/accounts/OAuthGetAccessToken',
  :client_credential_key => 'anonymous',
  :client_credential_secret => 'anonymous'
)

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the client.

    • :temporary_credential_uri - The OAuth temporary credentials URI.
    • :authorization_uri - The OAuth authorization URI.
    • :token_credential_uri - The OAuth token credentials URI.
    • :client_credential_key - The OAuth client credential key.
    • :client_credential_secret - The OAuth client credential secret.
    • :callback - The OAuth callback. Defaults to 'oob'.


57
58
59
 
# File 'lib/signet/oauth_1/client.rb', line 57

def initialize options = {}
  update! options
end

Instance Method Details

#authorization_uri(options = {}) ⇒ Addressable::URI

Returns the authorization URI that the user should be redirected to.

Returns:

  • (Addressable::URI) —

    The authorization URI.

See Also:



148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/signet/oauth_1/client.rb', line 148

def authorization_uri options = {}
  options = options.merge(
    temporary_credential_key: temporary_credential_key,
    callback:                 callback
  )
  return nil if @authorization_uri.nil?
  Addressable::URI.parse(
    ::Signet::OAuth1.generate_authorization_uri(
      @authorization_uri, options
    )
  )
end

#authorization_uri=(new_authorization_uri) ⇒ Object

Sets the authorization URI for this client.

Parameters:

  • new_authorization_uri (Addressable::URI, String, #to_str) —

    The authorization URI.



166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/signet/oauth_1/client.rb', line 166

def authorization_uri= new_authorization_uri
  if new_authorization_uri.nil?
    @authorization_uri = nil
  else
    new_authorization_uri = Addressable::URI.send(
      new_authorization_uri.is_a?(Hash) ? :new : :parse,
      new_authorization_uri
    )
    @authorization_uri = new_authorization_uri
  end
end

#callback ⇒ String

Returns the callback for this client.

Returns:

  • (String) —

    The OAuth callback.



504
505
506
 
# File 'lib/signet/oauth_1/client.rb', line 504

def callback
  @callback || ::Signet::OAuth1::OUT_OF_BAND
end

#callback=(new_callback) ⇒ Object

Sets the callback for this client.

Parameters:

  • new_callback (String, #to_str) —

    The OAuth callback.



513
514
515
516
517
518
519
520
521
522
523
524
 
# File 'lib/signet/oauth_1/client.rb', line 513

def callback= new_callback
  if new_callback.nil?
    @callback = nil
  else
    unless new_callback.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_callback.class} into String."
    end
    new_callback = new_callback.to_str
    @callback = new_callback
  end
end

#client_credential ⇒ Signet::OAuth1::Credential Also known as: consumer_token

Returns the client credential for this client.

Returns:



212
213
214
215
216
217
218
219
220
221
222
223
 
# File 'lib/signet/oauth_1/client.rb', line 212

def client_credential
  if client_credential_key && client_credential_secret
    ::Signet::OAuth1::Credential.new(
      client_credential_key,
      client_credential_secret
    )
  elsif !client_credential_key && !client_credential_secret
    nil
  else
    raise ArgumentError, "The client credential key and secret must be set."
  end
end

#client_credential=(new_client_credential) ⇒ Object Also known as: consumer_token=

Sets the client credential for this client.

Parameters:



231
232
233
234
235
236
237
238
239
240
241
242
243
244
 
# File 'lib/signet/oauth_1/client.rb', line 231

def client_credential= new_client_credential
  if new_client_credential.nil?
    @client_credential_key = nil
    @client_credential_secret = nil
  else
    unless new_client_credential.is_a? ::Signet::OAuth1::Credential
      raise TypeError,
            "Expected Signet::OAuth1::Credential, " \
            "got #{new_client_credential.class}."
    end
    @client_credential_key = new_client_credential.key
    @client_credential_secret = new_client_credential.secret
  end
end

#client_credential_key ⇒ String Also known as: consumer_key

Returns the client credential key for this client.

Returns:

  • (String) —

    The client credential key.



251
252
253
 
# File 'lib/signet/oauth_1/client.rb', line 251

def client_credential_key
  @client_credential_key
end

#client_credential_key=(new_client_credential_key) ⇒ Object Also known as: consumer_key=

Sets the client credential key for this client.

Parameters:

  • new_client_credential_key (String, #to_str) —

    The client credential key.



261
262
263
264
265
266
267
268
269
270
271
272
 
# File 'lib/signet/oauth_1/client.rb', line 261

def client_credential_key= new_client_credential_key
  if new_client_credential_key.nil?
    @client_credential_key = nil
  else
    unless new_client_credential_key.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_client_credential_key.class} into String."
    end
    new_client_credential_key = new_client_credential_key.to_str
    @client_credential_key = new_client_credential_key
  end
end

#client_credential_secret ⇒ String Also known as: consumer_secret

Returns the client credential secret for this client.

Returns:

  • (String) —

    The client credential secret.



279
280
281
 
# File 'lib/signet/oauth_1/client.rb', line 279

def client_credential_secret
  @client_credential_secret
end

#client_credential_secret=(new_client_credential_secret) ⇒ Object Also known as: consumer_secret=

Sets the client credential secret for this client.

Parameters:

  • new_client_credential_secret (String, #to_str) —

    The client credential secret.



289
290
291
292
293
294
295
296
297
298
299
300
301
 
# File 'lib/signet/oauth_1/client.rb', line 289

def client_credential_secret= new_client_credential_secret
  if new_client_credential_secret.nil?
    @client_credential_secret = nil
  else
    unless new_client_credential_secret.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_client_credential_secret.class} " \
            "into String."
    end
    new_client_credential_secret = new_client_credential_secret.to_str
    @client_credential_secret = new_client_credential_secret
  end
end

#fetch_protected_resource(options = {}) ⇒ Array

Transmits a request for a protected resource.

Examples:

# Using Net::HTTP
response = client.fetch_protected_resource(
  :uri => 'http://www.example.com/protected/resource'
)
# Using Typhoeus
response = client.fetch_protected_resource(
  :request => Typhoeus::Request.new(
    'http://www.example.com/protected/resource'
  ),
  :connection => connection
)

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :request - A pre-constructed request to sign.
    • :method - The HTTP method for the request. Defaults to :get.
    • :uri - The URI for the request.
    • :headers - The HTTP headers for the request.
    • :body - The HTTP body for the request.
    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :realm - The Authorization realm. See RFC 2617.
    • :connection - The HTTP connection to use. Must be of type Faraday::Connection.

Returns:

  • (Array) —

    The response object.

Raises:



997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
 
# File 'lib/signet/oauth_1/client.rb', line 997

def fetch_protected_resource options = {}
  options[:connection] ||= Faraday.default_connection
  request = generate_authenticated_request options
  request_env = request.to_env options[:connection]
  request_env[:request] ||= request
  response = options[:connection].app.call request_env
  return response unless response.status.to_i == 401
  # When accessing a protected resource, we only want to raise an
  # error for 401 responses.
  message = "Authorization failed."
  message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
  raise ::Signet::AuthorizationError.new(
    message, request: request, response: response
  )
end

#fetch_temporary_credential(options = {}) ⇒ Signet::OAuth1::Credential Also known as: fetch_request_token

Transmits a request for a temporary credential. This method does not have side-effects within the client.

Examples:

temporary_credential = client.fetch_temporary_credential(
  :additional_parameters => {
    :scope => 'https://mail.google.com/mail/feed/atom'
  }
)

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :additional_parameters - Non-standard additional parameters.
    • :realm - The Authorization realm. See RFC 2617.
    • :connection - The HTTP connection to use. Must be of type Faraday::Connection.

Returns:

Raises:



658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
 
# File 'lib/signet/oauth_1/client.rb', line 658

def fetch_temporary_credential options = {}
  options[:connection] ||= Faraday.default_connection
  request = generate_temporary_credential_request options
  request_env = request.to_env options[:connection]
  request_env[:request] ||= request
  response = options[:connection].app.call request_env
  return ::Signet::OAuth1.parse_form_encoded_credentials response.body if response.status.to_i == 200
  message = if [400, 401, 403].include? response.status.to_i
              "Authorization failed."
            else
              "Unexpected status code: #{response.status}."
            end
  message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
  raise ::Signet::AuthorizationError.new(
    message, request: request, response: response
  )
end

#fetch_temporary_credential!(options = {}) ⇒ Signet::OAuth1::Credential Also known as: fetch_request_token!

Transmits a request for a temporary credential. This method updates the client with the new temporary credential.

Examples:

client.fetch_temporary_credential!(:additional_parameters => {
  :scope => 'https://mail.google.com/mail/feed/atom'
})

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :additional_parameters - Non-standard additional parameters.
    • :realm - The Authorization realm. See RFC 2617.
    • :connection - The HTTP connection to use. Must be of type Faraday::Connection.

Returns:



699
700
701
702
 
# File 'lib/signet/oauth_1/client.rb', line 699

def fetch_temporary_credential! options = {}
  credential = fetch_temporary_credential options
  self.temporary_credential = credential
end

#fetch_token_credential(options = {}) ⇒ Signet::OAuth1::Credential Also known as: fetch_access_token

Transmits a request for a token credential. This method does not have side-effects within the client.

Examples:

token_credential = client.fetch_token_credential(
  :verifier => '12345'
)

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :verifier - The OAuth verifier provided by the server. Required.
    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :realm - The Authorization realm. See RFC 2617.
    • :connection - The HTTP connection to use. Must be of type Faraday::Connection.

Returns:

Raises:



793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
 
# File 'lib/signet/oauth_1/client.rb', line 793

def fetch_token_credential options = {}
  options[:connection] ||= Faraday.default_connection
  request = generate_token_credential_request options
  request_env = request.to_env options[:connection]
  request_env[:request] ||= request
  response = options[:connection].app.call request_env
  return ::Signet::OAuth1.parse_form_encoded_credentials response.body if response.status.to_i == 200
  message = if [400, 401, 403].include? response.status.to_i
              "Authorization failed."
            else
              "Unexpected status code: #{response.status}."
            end
  message += "  Server message:\n#{response.body.to_s.strip}" unless response.body.to_s.strip.empty?
  raise ::Signet::AuthorizationError.new(
    message, request: request, response: response
  )
end

#fetch_token_credential!(options = {}) ⇒ Signet::OAuth1::Credential Also known as: fetch_access_token!

Transmits a request for a token credential. This method updates the client with the new token credential.

Examples:

client.fetch_token_credential!(:verifier => '12345')

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :additional_parameters - Non-standard additional parameters.
    • :realm - The Authorization realm. See RFC 2617.
    • :connection - The HTTP connection to use. Must be of type Faraday::Connection.

Returns:



832
833
834
835
 
# File 'lib/signet/oauth_1/client.rb', line 832

def fetch_token_credential! options = {}
  credential = fetch_token_credential options
  self.token_credential = credential
end

#generate_authenticated_request(options = {}) ⇒ Array

Generates an authenticated request for protected resources.

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :request - A pre-constructed request to sign.
    • :method - The HTTP method for the request. Defaults to :get.
    • :uri - The URI for the request.
    • :headers - The HTTP headers for the request.
    • :body - The HTTP body for the request.
    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :realm - The Authorization realm. See RFC 2617.

Returns:

  • (Array) —

    The request object.



859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
 
# File 'lib/signet/oauth_1/client.rb', line 859

def generate_authenticated_request options = {}
  verifications = {
    client_credential_key:    "Client credential key",
    client_credential_secret: "Client credential secret"
  }
  unless two_legged
    verifications.update(
      token_credential_key:    "Token credential key",
      token_credential_secret: "Token credential secret"
    )
  end
  # Make sure all required state is set
  verifications.each do |(key, _value)|
    raise ArgumentError, "#{key} was not set." unless send key
  end
  options = {
    signature_method: "HMAC-SHA1",
    realm:            nil,
    connection:       Faraday.default_connection
  }.merge(options)

  if options[:request].is_a? Faraday::Request
    request = options[:request]
  else
    if options[:request].is_a? Array
      method, uri, headers, body = options[:request]
    else
      method = options[:method] || :get
      uri = options[:uri]
      headers = options[:headers] || []
      body = options[:body] || ""
    end
    headers = headers.to_a if headers.is_a? Hash
    request_components = {
      method:  method,
      uri:     uri,
      headers: headers,
      body:    body
    }
    # Verify that we have all pieces required to return an HTTP request
    request_components.each do |(key, value)|
      raise ArgumentError, "Missing :#{key} parameter." unless value
    end
    if !body.is_a?(String) && body.respond_to?(:each)
      # Just in case we get a chunked body
      merged_body = StringIO.new
      body.each do |chunk|
        merged_body.write chunk
      end
      body = merged_body.string
    end
    raise TypeError, "Expected String, got #{body.class}." unless body.is_a? String
    method = method.to_s.downcase.to_sym
    request = options[:connection].build_request method do |req|
      req.url Addressable::URI.parse(uri).normalize.to_s
      req.headers = Faraday::Utils::Headers.new headers
      req.body = body
    end
  end

  parameters = ::Signet::OAuth1.unsigned_resource_parameters(
    client_credential_key: client_credential_key,
    token_credential_key:  token_credential_key,
    signature_method:      options[:signature_method],
    two_legged:            two_legged
  )

  env = request.to_env options[:connection]

  content_type = request["Content-Type"].to_s
  content_type = content_type.split(";", 2).first if content_type.index ";"
  if request.http_method == :post && content_type == "application/x-www-form-urlencoded"
    # Serializes the body in case a hash/array was passed. Noop if already string like
    encoder = Faraday::Request::UrlEncoded.new(->(_env) {})
    encoder.call env
    request.body = env[:body]

    post_parameters = Addressable::URI.form_unencode env[:body]
    parameters.concat post_parameters
  end

  # No need to attach URI query parameters, the .sign_parameters
  # method takes care of that automatically.
  signature = ::Signet::OAuth1.sign_parameters(
    env[:method],
    env[:url],
    parameters,
    client_credential_secret,
    token_credential_secret
  )

  parameters << ["oauth_signature", signature]
  request["Authorization"] = ::Signet::OAuth1.generate_authorization_header(
    parameters, options[:realm]
  )
  request["Cache-Control"] = "no-store"
  request
end

#generate_temporary_credential_request(options = {}) ⇒ Array Also known as: generate_request_token_request

Generates a request for temporary credentials.

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :additional_parameters - Non-standard additional parameters.
    • :realm - The Authorization realm. See RFC 2617.

Returns:

  • (Array) —

    The request object.



584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
 
# File 'lib/signet/oauth_1/client.rb', line 584

def generate_temporary_credential_request options = {}
  verifications = {
    temporary_credential_uri: "Temporary credentials URI",
    client_credential_key:    "Client credential key",
    client_credential_secret: "Client credential secret"
  }
  # Make sure all required state is set
  verifications.each do |(key, _value)|
    raise ArgumentError, "#{key} was not set." unless send key
  end
  options = {
    signature_method:      "HMAC-SHA1",
    additional_parameters: [],
    realm:                 nil,
    connection:            Faraday.default_connection
  }.merge(options)
  method = :post
  parameters = ::Signet::OAuth1.unsigned_temporary_credential_parameters(
    client_credential_key: client_credential_key,
    callback:              callback,
    signature_method:      options[:signature_method],
    additional_parameters: options[:additional_parameters]
  )
  signature = ::Signet::OAuth1.sign_parameters(
    method,
    temporary_credential_uri,
    parameters,
    client_credential_secret
  )
  parameters << ["oauth_signature", signature]
  authorization_header = [
    "Authorization",
    ::Signet::OAuth1.generate_authorization_header(
      parameters, options[:realm]
    )
  ]
  headers = [authorization_header]
  if method == :post
    headers << ["Content-Type", "application/x-www-form-urlencoded"]
    headers << ["Content-Length", "0"]
  end
  options[:connection].build_request method.to_s.downcase.to_sym do |req|
    req.url(Addressable::URI.parse(
      temporary_credential_uri.to_str
    ).normalize.to_s)
    req.headers = Faraday::Utils::Headers.new headers
  end
end

#generate_token_credential_request(options = {}) ⇒ Array Also known as: generate_access_token_request

Generates a request for token credentials.

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the request.

    • :verifier - The OAuth verifier provided by the server. Required.
    • :signature_method - The signature method. Defaults to 'HMAC-SHA1'.
    • :realm - The Authorization realm. See RFC 2617.

Returns:

  • (Array) —

    The request object.



718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
 
# File 'lib/signet/oauth_1/client.rb', line 718

def generate_token_credential_request options = {}
  verifications = {
    token_credential_uri:        "Token credentials URI",
    client_credential_key:       "Client credential key",
    client_credential_secret:    "Client credential secret",
    temporary_credential_key:    "Temporary credential key",
    temporary_credential_secret: "Temporary credential secret"
  }
  # Make sure all required state is set
  verifications.each do |(key, _value)|
    raise ArgumentError, "#{key} was not set." unless send key
  end
  options = {
    signature_method: "HMAC-SHA1",
    realm:            nil,
    connection:       Faraday.default_connection
  }.merge(options)
  method = :post
  parameters = ::Signet::OAuth1.unsigned_token_credential_parameters(
    client_credential_key:    client_credential_key,
    temporary_credential_key: temporary_credential_key,
    signature_method:         options[:signature_method],
    verifier:                 options[:verifier]
  )
  signature = ::Signet::OAuth1.sign_parameters(
    method,
    token_credential_uri,
    parameters,
    client_credential_secret,
    temporary_credential_secret
  )
  parameters << ["oauth_signature", signature]
  authorization_header = [
    "Authorization",
    ::Signet::OAuth1.generate_authorization_header(
      parameters, options[:realm]
    )
  ]
  headers = [authorization_header]
  headers << ["Cache-Control", "no-store"]
  if method == :post
    headers << ["Content-Type", "application/x-www-form-urlencoded"]
    headers << ["Content-Length", "0"]
  end
  options[:connection].build_request method.to_s.downcase.to_sym do |req|
    req.url(Addressable::URI.parse(
      token_credential_uri.to_str
    ).normalize.to_s)
    req.headers = Faraday::Utils::Headers.new headers
  end
end

#temporary_credential ⇒ Signet::OAuth1::Credential Also known as: request_token

Returns the temporary credential for this client.

Returns:



308
309
310
311
312
313
314
315
316
317
318
319
 
# File 'lib/signet/oauth_1/client.rb', line 308

def temporary_credential
  if temporary_credential_key && temporary_credential_secret
    ::Signet::OAuth1::Credential.new(
      temporary_credential_key,
      temporary_credential_secret
    )
  elsif !temporary_credential_key && !temporary_credential_secret
    nil
  else
    raise ArgumentError, "The temporary credential key and secret must be set."
  end
end

#temporary_credential=(new_temporary_credential) ⇒ Object Also known as: request_token=

Sets the temporary credential for this client.

Parameters:



327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/signet/oauth_1/client.rb', line 327

def temporary_credential= new_temporary_credential
  if new_temporary_credential.nil?
    @temporary_credential_key = nil
    @temporary_credential_secret = nil
  else
    unless new_temporary_credential.is_a? ::Signet::OAuth1::Credential
      raise TypeError,
            "Expected Signet::OAuth1::Credential, " \
            "got #{new_temporary_credential.class}."
    end
    @temporary_credential_key = new_temporary_credential.key
    @temporary_credential_secret = new_temporary_credential.secret
  end
end

#temporary_credential_key ⇒ String Also known as: request_token_key

Returns the temporary credential key for this client.

Returns:

  • (String) —

    The temporary credential key.



347
348
349
 
# File 'lib/signet/oauth_1/client.rb', line 347

def temporary_credential_key
  @temporary_credential_key
end

#temporary_credential_key=(new_temporary_credential_key) ⇒ Object Also known as: request_token_key=

Sets the temporary credential key for this client.

Parameters:

  • new_temporary_credential_key (String, #to_str) —

    The temporary credential key.



357
358
359
360
361
362
363
364
365
366
367
368
369
 
# File 'lib/signet/oauth_1/client.rb', line 357

def temporary_credential_key= new_temporary_credential_key
  if new_temporary_credential_key.nil?
    @temporary_credential_key = nil
  else
    unless new_temporary_credential_key.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_temporary_credential_key.class} " \
            "into String."
    end
    new_temporary_credential_key = new_temporary_credential_key.to_str
    @temporary_credential_key = new_temporary_credential_key
  end
end

#temporary_credential_secret ⇒ String Also known as: request_token_secret

Returns the temporary credential secret for this client.

Returns:

  • (String) —

    The temporary credential secret.



376
377
378
 
# File 'lib/signet/oauth_1/client.rb', line 376

def temporary_credential_secret
  @temporary_credential_secret
end

#temporary_credential_secret=(new_temporary_credential_secret) ⇒ Object Also known as: request_token_secret=

Sets the temporary credential secret for this client.

Parameters:

  • new_temporary_credential_secret (String, #to_str) —

    The temporary credential secret.



386
387
388
389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/signet/oauth_1/client.rb', line 386

def temporary_credential_secret= new_temporary_credential_secret
  if new_temporary_credential_secret.nil?
    @temporary_credential_secret = nil
  else
    unless new_temporary_credential_secret.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_temporary_credential_secret.class} " \
            "into String."
    end
    new_temporary_credential_secret =
      new_temporary_credential_secret.to_str
    @temporary_credential_secret = new_temporary_credential_secret
  end
end

#temporary_credential_uri ⇒ Addressable::URI Also known as: request_token_uri

Returns the temporary credentials URI for this client.

Returns:

  • (Addressable::URI) —

    The temporary credentials URI.



120
121
122
 
# File 'lib/signet/oauth_1/client.rb', line 120

def temporary_credential_uri
  @temporary_credential_uri
end

#temporary_credential_uri=(new_temporary_credential_uri) ⇒ Object Also known as: request_token_uri=

Sets the temporary credentials URI for this client.

Parameters:

  • new_temporary_credential_uri (Addressable::URI, String, #to_str) —

    The temporary credentials URI.



131
132
133
134
135
136
137
138
139
 
# File 'lib/signet/oauth_1/client.rb', line 131

def temporary_credential_uri= new_temporary_credential_uri
  if new_temporary_credential_uri.nil?
    @temporary_credential_uri = nil
  else
    new_temporary_credential_uri =
      Addressable::URI.parse new_temporary_credential_uri
    @temporary_credential_uri = new_temporary_credential_uri
  end
end

#to_json(*_args) ⇒ String

Note:

A serialized client contains sensitive information. Persist or transmit with care.

Serialize the client object to JSON.

Returns:

  • (String) —

    A serialized JSON representation of the client.



555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
 
# File 'lib/signet/oauth_1/client.rb', line 555

def to_json *_args
  JSON.generate(
    "temporary_credential_uri"    => temporary_credential_uri,
    "authorization_uri"           => authorization_uri,
    "token_credential_uri"        => token_credential_uri,
    "callback"                    => callback,
    "two_legged"                  => two_legged,
    "client_credential_key"       => client_credential_key,
    "client_credential_secret"    => client_credential_secret,
    "temporary_credential_key"    => temporary_credential_key,
    "temporary_credential_secret" => temporary_credential_secret,
    "token_credential_key"        => token_credential_key,
    "token_credential_secret"     => token_credential_secret
  )
end

#token_credential ⇒ Signet::OAuth1::Credential Also known as: access_token

Returns the token credential for this client.

Returns:



406
407
408
409
410
411
412
413
414
415
416
417
 
# File 'lib/signet/oauth_1/client.rb', line 406

def token_credential
  if token_credential_key && token_credential_secret
    ::Signet::OAuth1::Credential.new(
      token_credential_key,
      token_credential_secret
    )
  elsif !token_credential_key && !token_credential_secret
    nil
  else
    raise ArgumentError, "The token credential key and secret must be set."
  end
end

#token_credential=(new_token_credential) ⇒ Object Also known as: access_token=

Sets the token credential for this client.

Parameters:



425
426
427
428
429
430
431
432
433
434
435
436
437
438
 
# File 'lib/signet/oauth_1/client.rb', line 425

def token_credential= new_token_credential
  if new_token_credential.nil?
    @token_credential_key = nil
    @token_credential_secret = nil
  else
    unless new_token_credential.is_a? ::Signet::OAuth1::Credential
      raise TypeError,
            "Expected Signet::OAuth1::Credential, " \
            "got #{new_token_credential.class}."
    end
    @token_credential_key = new_token_credential.key
    @token_credential_secret = new_token_credential.secret
  end
end

#token_credential_key ⇒ String Also known as: access_token_key

Returns the token credential key for this client.

Returns:

  • (String) —

    The token credential key.



445
446
447
 
# File 'lib/signet/oauth_1/client.rb', line 445

def token_credential_key
  @token_credential_key
end

#token_credential_key=(new_token_credential_key) ⇒ Object Also known as: access_token_key=

Sets the token credential key for this client.

Parameters:

  • new_token_credential_key (String, #to_str) —

    The token credential key.



455
456
457
458
459
460
461
462
463
464
465
466
467
 
# File 'lib/signet/oauth_1/client.rb', line 455

def token_credential_key= new_token_credential_key
  if new_token_credential_key.nil?
    @token_credential_key = nil
  else
    unless new_token_credential_key.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_token_credential_key.class} " \
            "into String."
    end
    new_token_credential_key = new_token_credential_key.to_str
    @token_credential_key = new_token_credential_key
  end
end

#token_credential_secret ⇒ String Also known as: access_token_secret

Returns the token credential secret for this client.

Returns:

  • (String) —

    The token credential secret.



474
475
476
 
# File 'lib/signet/oauth_1/client.rb', line 474

def token_credential_secret
  @token_credential_secret
end

#token_credential_secret=(new_token_credential_secret) ⇒ Object Also known as: access_token_secret=

Sets the token credential secret for this client.

Parameters:

  • new_token_credential_secret (String, #to_str) —

    The token credential secret.



484
485
486
487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/signet/oauth_1/client.rb', line 484

def token_credential_secret= new_token_credential_secret
  if new_token_credential_secret.nil?
    @token_credential_secret = nil
  else
    unless new_token_credential_secret.respond_to? :to_str
      raise TypeError,
            "Can't convert #{new_token_credential_secret.class} " \
            "into String."
    end
    new_token_credential_secret =
      new_token_credential_secret.to_str
    @token_credential_secret = new_token_credential_secret
  end
end

#token_credential_uri ⇒ Addressable::URI Also known as: access_token_uri

Returns the token credential URI for this client.

Returns:

  • (Addressable::URI) —

    The token credential URI.



182
183
184
 
# File 'lib/signet/oauth_1/client.rb', line 182

def token_credential_uri
  @token_credential_uri
end

#token_credential_uri=(new_token_credential_uri) ⇒ Object Also known as: access_token_uri=

Sets the token credential URI for this client.

Parameters:

  • new_token_credential_uri (Addressable::URI, Hash, String, #to_str) —

    The token credential URI.



192
193
194
195
196
197
198
199
200
201
202
 
# File 'lib/signet/oauth_1/client.rb', line 192

def token_credential_uri= new_token_credential_uri
  if new_token_credential_uri.nil?
    @token_credential_uri = nil
  else
    new_token_credential_uri = Addressable::URI.send(
      new_token_credential_uri.is_a?(Hash) ? :new : :parse,
      new_token_credential_uri
    )
    @token_credential_uri = new_token_credential_uri
  end
end

#two_legged ⇒ TrueClass, FalseClass

Returns whether the client is in two-legged mode.

Returns:

  • (TrueClass, FalseClass) —

    true for two-legged mode, false otherwise.



531
532
533
 
# File 'lib/signet/oauth_1/client.rb', line 531

def two_legged
  @two_legged ||= false
end

#two_legged=(new_two_legged) ⇒ Object

Sets the client for two-legged mode.

Parameters:

  • new_two_legged (TrueClass, FalseClass) —

    true for two-legged mode, false otherwise.



540
541
542
543
544
545
546
547
 
# File 'lib/signet/oauth_1/client.rb', line 540

def two_legged= new_two_legged
  if new_two_legged != true && new_two_legged != false
    raise TypeError,
          "Expected true or false, got #{new_two_legged.class}."
  else
    @two_legged = new_two_legged
  end
end

#update!(options = {}) ⇒ Object

Updates an OAuth 1.0 client.

Examples:

client.update!(
  :temporary_credential_uri =>
    'https://www.google.com/accounts/OAuthGetRequestToken',
  :authorization_uri =>
    'https://www.google.com/accounts/OAuthAuthorizeToken',
  :token_credential_uri =>
    'https://www.google.com/accounts/OAuthGetAccessToken',
  :client_credential_key => 'anonymous',
  :client_credential_secret => 'anonymous'
)

Parameters:

  • options (Hash) (defaults to: {}) —

    The configuration parameters for the client.

    • :temporary_credential_uri - The OAuth temporary credentials URI.
    • :authorization_uri - The OAuth authorization URI.
    • :token_credential_uri - The OAuth token credentials URI.
    • :client_credential_key - The OAuth client credential key.
    • :client_credential_secret - The OAuth client credential secret.
    • :callback - The OAuth callback. Defaults to 'oob'.

See Also:



91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/signet/oauth_1/client.rb', line 91

def update! options = {}
  # Normalize key to String to allow indifferent access.
  options = options.to_h.transform_keys(&:to_s)
  self.temporary_credential_uri = options["temporary_credential_uri"]
  self.authorization_uri = options["authorization_uri"]
  self.token_credential_uri = options["token_credential_uri"]
  # Technically... this would allow you to pass in a :client key...
  # But that would be weird.  Don't do that.
  self.client_credential_key =
    Signet::OAuth1.extract_credential_key_option "client", options
  self.client_credential_secret =
    Signet::OAuth1.extract_credential_secret_option "client", options
  self.temporary_credential_key =
    Signet::OAuth1.extract_credential_key_option "temporary", options
  self.temporary_credential_secret =
    Signet::OAuth1.extract_credential_secret_option "temporary", options
  self.token_credential_key =
    Signet::OAuth1.extract_credential_key_option "token", options
  self.token_credential_secret =
    Signet::OAuth1.extract_credential_secret_option "token", options
  self.callback = options["callback"]
  self.two_legged = options["two_legged"] || false
  self
end