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'.


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

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:



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

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.



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

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.



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

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.



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

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:



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

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:



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

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.



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

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.



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

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.



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

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.



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

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:



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

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:



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

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:



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

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:



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

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:



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

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.



858
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
 
# File 'lib/signet/oauth_1/client.rb', line 858

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.



583
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
 
# File 'lib/signet/oauth_1/client.rb', line 583

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.



717
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
 
# File 'lib/signet/oauth_1/client.rb', line 717

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:



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

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:



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

def to_json *_args
  MultiJson.dump(
    "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:



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

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:



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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.



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

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:



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

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