Parent

Signet::OAuth1::Client

Public Class Methods

new(options={}) click to toggle source

Creates an OAuth 1.0 client.

@param [Hash] options

The configuration parameters for the client.
- <code>:temporary_credential_uri</code> -
  The OAuth temporary credentials URI.
- <code>:authorization_uri</code> -
  The OAuth authorization URI.
- <code>:token_credential_uri</code> -
  The OAuth token credentials URI.
- <code>:client_credential_key</code> -
  The OAuth client credential key.
- <code>:client_credential_secret</code> -
  The OAuth client credential secret.
- <code>:callback</code> -  The OAuth callback.  Defaults to 'oob'.

@example

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'
)
# File lib/signet/oauth_1/client.rb, line 57
def initialize(options={})
  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
end

Public Instance Methods

access_token() click to toggle source
Alias for: token_credential
access_token=(new_token_credential) click to toggle source
Alias for: token_credential=
access_token_key() click to toggle source
access_token_key=(new_token_credential_key) click to toggle source
access_token_secret() click to toggle source
access_token_secret=(new_token_credential_secret) click to toggle source
access_token_uri() click to toggle source
access_token_uri=(new_token_credential_uri) click to toggle source
authorization_uri(options={}) click to toggle source

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

@return [Addressable::URI] The authorization URI.

@see Signet::OAuth1.generate_authorization_uri

# File lib/signet/oauth_1/client.rb, line 111
def authorization_uri(options={})
  options = options.merge(
    :temporary_credential_key => self.temporary_credential_key,
    :callback => self.callback
  )
  return nil if @authorization_uri == nil
  return Addressable::URI.parse(
    ::Signet::OAuth1.generate_authorization_uri(
      @authorization_uri, options
    )
  )
end
authorization_uri=(new_authorization_uri) click to toggle source

Sets the authorization URI for this client.

@param [Addressable::URI, String, to_str] new_authorization_uri

The authorization URI.
# File lib/signet/oauth_1/client.rb, line 129
def authorization_uri=(new_authorization_uri)
  if new_authorization_uri != nil
    new_authorization_uri =
      Addressable::URI.parse(new_authorization_uri)
    @authorization_uri = new_authorization_uri
  else
    @authorization_uri = nil
  end
end
callback() click to toggle source

Returns the callback for this client.

@return [String] The OAuth callback.

# File lib/signet/oauth_1/client.rb, line 468
def callback
  return @callback || ::Signet::OAuth1::OUT_OF_BAND
end
callback=(new_callback) click to toggle source

Sets the callback for this client.

@param [String, to_str] new_callback

The OAuth callback.
# File lib/signet/oauth_1/client.rb, line 477
def callback=(new_callback)
  if new_callback != nil
    if !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
  else
    @callback = nil
  end
end
client_credential() click to toggle source

Returns the client credential for this client.

@return [Signet::OAuth1::Credential] The client credentials.

# File lib/signet/oauth_1/client.rb, line 171
def client_credential
  if self.client_credential_key && self.client_credential_secret
    return ::Signet::OAuth1::Credential.new(
      self.client_credential_key,
      self.client_credential_secret
    )
  elsif !self.client_credential_key && !self.client_credential_secret
    return nil
  else
    raise ArgumentError,
      "The client credential key and secret must be set."
  end
end
Also aliased as: consumer_token
client_credential=(new_client_credential) click to toggle source

Sets the client credential for this client.

@param [Signet::OAuth1::Credential] new_client_credential

The client credentials.
# File lib/signet/oauth_1/client.rb, line 191
def client_credential=(new_client_credential)
  if new_client_credential != nil
    if !new_client_credential.kind_of?(::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
  else
    @client_credential_key = nil
    @client_credential_secret = nil
  end
end
Also aliased as: consumer_token=
client_credential_key() click to toggle source

Returns the client credential key for this client.

@return [String] The client credential key.

# File lib/signet/oauth_1/client.rb, line 211
def client_credential_key
  return @client_credential_key
end
Also aliased as: consumer_key
client_credential_key=(new_client_credential_key) click to toggle source

Sets the client credential key for this client.

@param [String, to_str] new_client_credential_key

The client credential key.
# File lib/signet/oauth_1/client.rb, line 221
def client_credential_key=(new_client_credential_key)
  if new_client_credential_key != nil
    if !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
  else
    @client_credential_key = nil
  end
end
Also aliased as: consumer_key=
client_credential_secret() click to toggle source

Returns the client credential secret for this client.

@return [String] The client credential secret.

# File lib/signet/oauth_1/client.rb, line 239
def client_credential_secret
  return @client_credential_secret
end
Also aliased as: consumer_secret
client_credential_secret=(new_client_credential_secret) click to toggle source

Sets the client credential secret for this client.

@param [String, to_str] new_client_credential_secret

The client credential secret.
# File lib/signet/oauth_1/client.rb, line 249
def client_credential_secret=(new_client_credential_secret)
  if new_client_credential_secret != nil
    if !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
  else
    @client_credential_secret = nil
  end
end
Also aliased as: consumer_secret=
consumer_key() click to toggle source
consumer_key=(new_client_credential_key) click to toggle source
consumer_secret() click to toggle source
consumer_secret=(new_client_credential_secret) click to toggle source
consumer_token() click to toggle source
Alias for: client_credential
consumer_token=(new_client_credential) click to toggle source
Alias for: client_credential=
fetch_access_token(options={}) click to toggle source
fetch_access_token!(options={}) click to toggle source
fetch_protected_resource(options={}) click to toggle source

Transmits a request for a protected resource.

@param [Hash] options

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

@example

# Using Net::HTTP
response = client.fetch_protected_resource(
  :uri => 'http://www.example.com/protected/resource'
)

@example

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

@return [Array] The response object.

# File lib/signet/oauth_1/client.rb, line 984
def fetch_protected_resource(options={})
  options[:connection] ||= Faraday.default_connection
  request = self.generate_authenticated_request(options)
  request_env = request.to_env(options[:connection])
  request_env[:request] ||= request
  response = options[:connection].app.call(request_env)
  if response.status.to_i == 401
    # When accessing a protected resource, we only want to raise an
    # error for 401 responses.
    message = 'Authorization failed.'
    if response.body.to_s.strip.length > 0
      message += "  Server message:\n#{response.body.to_s.strip}"
    end
    raise ::Signet::AuthorizationError.new(
      message, :request => request, :response => response
    )
  else
    return response
  end
end
fetch_request_token(options={}) click to toggle source
fetch_request_token!(options={}) click to toggle source
fetch_temporary_credential(options={}) click to toggle source

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

@param [Hash] options

The configuration parameters for the request.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:additional_parameters</code> -
  Non-standard additional parameters.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.
- <code>:connection</code> -
  The HTTP connection to use.
  Must be of type <code>Faraday::Connection</code>.

@return [Signet::OAuth1::Credential] The temporary credential.

@example

temporary_credential = client.fetch_temporary_credential(
  :additional_parameters => {
    :scope => 'https://mail.google.com/mail/feed/atom'
  }
)
# File lib/signet/oauth_1/client.rb, line 605
def fetch_temporary_credential(options={})
  options[:connection] ||= Faraday.default_connection
  request = self.generate_temporary_credential_request(options)
  request_env = request.to_env(options[:connection])
  request_env[:request] ||= request
  response = options[:connection].app.call(request_env)
  if response.status.to_i == 200
    return ::Signet::OAuth1.parse_form_encoded_credentials(response.body)
  elsif [400, 401, 403].include?(response.status.to_i)
    message = 'Authorization failed.'
    if response.body.to_s.strip.length > 0
      message += "  Server message:\n#{response.body.to_s.strip}"
    end
    raise ::Signet::AuthorizationError.new(
      message, :request => request, :response => response
    )
  else
    message = "Unexpected status code: #{response.status}."
    if response.body.to_s.strip.length > 0
      message += "  Server message:\n#{response.body.to_s.strip}"
    end
    raise ::Signet::AuthorizationError.new(
      message, :request => request, :response => response
    )
  end
end
Also aliased as: fetch_request_token
fetch_temporary_credential!(options={}) click to toggle source

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

@param [Hash] options

The configuration parameters for the request.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:additional_parameters</code> -
  Non-standard additional parameters.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.
- <code>:connection</code> -
  The HTTP connection to use.
  Must be of type <code>Faraday::Connection</code>.

@return [Signet::OAuth1::Credential] The temporary credential.

@example

client.fetch_temporary_credential!(:additional_parameters => {
  :scope => 'https://mail.google.com/mail/feed/atom'
})
# File lib/signet/oauth_1/client.rb, line 658
def fetch_temporary_credential!(options={})
  credential = self.fetch_temporary_credential(options)
  self.temporary_credential = credential
end
Also aliased as: fetch_request_token!
fetch_token_credential(options={}) click to toggle source

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

@param [Hash] options

The configuration parameters for the request.
- <code>:verifier</code> -
  The OAuth verifier provided by the server.  Required.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.
- <code>:connection</code> -
  The HTTP connection to use.
  Must be of type <code>Faraday::Connection</code>.

@return [Signet::OAuth1::Credential] The token credential.

@example

token_credential = client.fetch_token_credential(
  :verifier => '12345'
)
# File lib/signet/oauth_1/client.rb, line 760
def fetch_token_credential(options={})
  options[:connection] ||= Faraday.default_connection
  request = self.generate_token_credential_request(options)
  request_env = request.to_env(options[:connection])
  request_env[:request] ||= request
  response = options[:connection].app.call(request_env)
  if response.status.to_i == 200
    return ::Signet::OAuth1.parse_form_encoded_credentials(response.body)
  elsif [400, 401, 403].include?(response.status.to_i)
    message = 'Authorization failed.'
    if response.body.to_s.strip.length > 0
      message += "  Server message:\n#{response.body.to_s.strip}"
    end
    raise ::Signet::AuthorizationError.new(
      message, :request => request, :response => response
    )
  else
    message = "Unexpected status code: #{response.status}."
    if response.body.to_s.strip.length > 0
      message += "  Server message:\n#{response.body.to_s.strip}"
    end
    raise ::Signet::AuthorizationError.new(
      message, :request => request, :response => response
    )
  end
end
Also aliased as: fetch_access_token
fetch_token_credential!(options={}) click to toggle source

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

@param [Hash] options

The configuration parameters for the request.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:additional_parameters</code> -
  Non-standard additional parameters.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.
- <code>:connection</code> -
  The HTTP connection to use.
  Must be of type <code>Faraday::Connection</code>.

@return [Signet::OAuth1::Credential] The token credential.

@example

client.fetch_token_credential!(:verifier => '12345')
# File lib/signet/oauth_1/client.rb, line 811
def fetch_token_credential!(options={})
  credential = self.fetch_token_credential(options)
  self.token_credential = credential
end
Also aliased as: fetch_access_token!
generate_access_token_request(options={}) click to toggle source
generate_authenticated_request(options={}) click to toggle source

Generates an authenticated request for protected resources.

@param [Hash] options

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

@return [Array] The request object.

# File lib/signet/oauth_1/client.rb, line 841
def generate_authenticated_request(options={})
  verifications = {
    :client_credential_key => 'Client credential key',
    :client_credential_secret => 'Client credential secret'
  }
  unless self.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)|
    unless self.send(key)
      raise ArgumentError, "#{key} was not set."
    end
  end
  options = {
    :signature_method => 'HMAC-SHA1',
    :realm => nil,
    :connection => Faraday.default_connection
  }.merge(options)
  
  if options[:request].kind_of?(Faraday::Request)
    request = options[:request]
  else
    if options[:request].kind_of?(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.kind_of?(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)|
      unless value
        raise ArgumentError, "Missing :#{key} parameter."
      end
    end
    if !body.kind_of?(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
    if !body.kind_of?(String)
      raise TypeError, "Expected String, got #{body.class}."
    end
    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 => self.client_credential_key,
    :token_credential_key => self.token_credential_key,
    :signature_method => options[:signature_method],
    :two_legged => self.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.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(lambda { |env| })
    encoder.call(env)
    request.body = env[:body]

    post_parameters = Addressable::URI.form_unencode(env[:body])
    parameters = 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,
    self.client_credential_secret,
    self.token_credential_secret
  )
  
  parameters << ['oauth_signature', signature]
  request['Authorization'] =  ::Signet::OAuth1.generate_authorization_header(
      parameters, options[:realm])
  request['Cache-Control'] = 'no-store'
  return request
end
generate_request_token_request(options={}) click to toggle source
generate_temporary_credential_request(options={}) click to toggle source

Generates a request for temporary credentials.

@param [Hash] options

The configuration parameters for the request.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:additional_parameters</code> -
  Non-standard additional parameters.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.

@return [Array] The request object.

# File lib/signet/oauth_1/client.rb, line 526
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)|
    unless self.send(key)
      raise ArgumentError, "#{key} was not set."
    end
  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 => self.client_credential_key,
    :callback => self.callback,
    :signature_method => options[:signature_method],
    :additional_parameters => options[:additional_parameters]
  )
  signature = ::Signet::OAuth1.sign_parameters(
    method,
    self.temporary_credential_uri,
    parameters,
    self.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
  return options[:connection].build_request(method.to_s.downcase.to_sym) do |req|
    req.url(Addressable::URI.parse(
      self.temporary_credential_uri.to_str
    ).normalize.to_s)
    req.headers = Faraday::Utils::Headers.new(headers)
  end
end
generate_token_credential_request(options={}) click to toggle source

Generates a request for token credentials.

@param [Hash] options

The configuration parameters for the request.
- <code>:verifier</code> -
  The OAuth verifier provided by the server.  Required.
- <code>:signature_method</code> -
  The signature method.  Defaults to <code>'HMAC-SHA1'</code>.
- <code>:realm</code> -
  The Authorization realm.  See RFC 2617.

@return [Array] The request object.

# File lib/signet/oauth_1/client.rb, line 680
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)|
    unless self.send(key)
      raise ArgumentError, "#{key} was not set."
    end
  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 => self.client_credential_key,
    :temporary_credential_key => self.temporary_credential_key,
    :signature_method => options[:signature_method],
    :verifier => options[:verifier]
  )
  signature = ::Signet::OAuth1.sign_parameters(
    method,
    self.token_credential_uri,
    parameters,
    self.client_credential_secret,
    self.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
  return options[:connection].build_request(method.to_s.downcase.to_sym) do |req|
    req.url(Addressable::URI.parse(
      self.token_credential_uri.to_str
    ).normalize.to_s)
    req.headers = Faraday::Utils::Headers.new(headers)
  end
end
request_token() click to toggle source
request_token=(new_temporary_credential) click to toggle source
request_token_key() click to toggle source
request_token_key=(new_temporary_credential_key) click to toggle source
request_token_secret() click to toggle source
request_token_secret=(new_temporary_credential_secret) click to toggle source
request_token_uri() click to toggle source
request_token_uri=(new_temporary_credential_uri) click to toggle source
temporary_credential() click to toggle source

Returns the temporary credential for this client.

@return [Signet::OAuth1::Credential] The temporary credentials.

# File lib/signet/oauth_1/client.rb, line 268
def temporary_credential
  if self.temporary_credential_key && self.temporary_credential_secret
    return ::Signet::OAuth1::Credential.new(
      self.temporary_credential_key,
      self.temporary_credential_secret
    )
  elsif !self.temporary_credential_key &&
      !self.temporary_credential_secret
    return nil
  else
    raise ArgumentError,
      "The temporary credential key and secret must be set."
  end
end
Also aliased as: request_token
temporary_credential=(new_temporary_credential) click to toggle source

Sets the temporary credential for this client.

@param [Signet::OAuth1::Credential] new_temporary_credential

The temporary credentials.
# File lib/signet/oauth_1/client.rb, line 289
def temporary_credential=(new_temporary_credential)
  if new_temporary_credential != nil
    if !new_temporary_credential.kind_of?(::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
  else
    @temporary_credential_key = nil
    @temporary_credential_secret = nil
  end
end
Also aliased as: request_token=
temporary_credential_key() click to toggle source

Returns the temporary credential key for this client.

@return [String] The temporary credential key.

# File lib/signet/oauth_1/client.rb, line 309
def temporary_credential_key
  return @temporary_credential_key
end
Also aliased as: request_token_key
temporary_credential_key=(new_temporary_credential_key) click to toggle source

Sets the temporary credential key for this client.

@param [String, to_str] new_temporary_credential_key

The temporary credential key.
# File lib/signet/oauth_1/client.rb, line 319
def temporary_credential_key=(new_temporary_credential_key)
  if new_temporary_credential_key != nil
    if !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
  else
    @temporary_credential_key = nil
  end
end
Also aliased as: request_token_key=
temporary_credential_secret() click to toggle source

Returns the temporary credential secret for this client.

@return [String] The temporary credential secret.

# File lib/signet/oauth_1/client.rb, line 338
def temporary_credential_secret
  return @temporary_credential_secret
end
Also aliased as: request_token_secret
temporary_credential_secret=(new_temporary_credential_secret) click to toggle source

Sets the temporary credential secret for this client.

@param [String, to_str] new_temporary_credential_secret

The temporary credential secret.
# File lib/signet/oauth_1/client.rb, line 348
def temporary_credential_secret=(new_temporary_credential_secret)
  if new_temporary_credential_secret != nil
    if !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
  else
    @temporary_credential_secret = nil
  end
end
Also aliased as: request_token_secret=
temporary_credential_uri() click to toggle source

Returns the temporary credentials URI for this client.

@return [Addressable::URI] The temporary credentials URI.

# File lib/signet/oauth_1/client.rb, line 83
def temporary_credential_uri
  return @temporary_credential_uri
end
Also aliased as: request_token_uri
temporary_credential_uri=(new_temporary_credential_uri) click to toggle source

Sets the temporary credentials URI for this client.

@param [Addressable::URI, String, to_str]

new_temporary_credential_uri
The temporary credentials URI.
# File lib/signet/oauth_1/client.rb, line 94
def temporary_credential_uri=(new_temporary_credential_uri)
  if new_temporary_credential_uri != nil
    new_temporary_credential_uri =
      Addressable::URI.parse(new_temporary_credential_uri)
    @temporary_credential_uri = new_temporary_credential_uri
  else
    @temporary_credential_uri = nil
  end
end
Also aliased as: request_token_uri=
token_credential() click to toggle source

Returns the token credential for this client.

@return [Signet::OAuth1::Credential] The token credentials.

# File lib/signet/oauth_1/client.rb, line 368
def token_credential
  if self.token_credential_key && self.token_credential_secret
    return ::Signet::OAuth1::Credential.new(
      self.token_credential_key,
      self.token_credential_secret
    )
  elsif !self.token_credential_key &&
      !self.token_credential_secret
    return nil
  else
    raise ArgumentError,
      "The token credential key and secret must be set."
  end
end
Also aliased as: access_token
token_credential=(new_token_credential) click to toggle source

Sets the token credential for this client.

@param [Signet::OAuth1::Credential] new_token_credential

The token credentials.
# File lib/signet/oauth_1/client.rb, line 389
def token_credential=(new_token_credential)
  if new_token_credential != nil
    if !new_token_credential.kind_of?(::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
  else
    @token_credential_key = nil
    @token_credential_secret = nil
  end
end
Also aliased as: access_token=
token_credential_key() click to toggle source

Returns the token credential key for this client.

@return [String] The token credential key.

# File lib/signet/oauth_1/client.rb, line 409
def token_credential_key
  return @token_credential_key
end
Also aliased as: access_token_key
token_credential_key=(new_token_credential_key) click to toggle source

Sets the token credential key for this client.

@param [String, to_str] new_token_credential_key

The token credential key.
# File lib/signet/oauth_1/client.rb, line 419
def token_credential_key=(new_token_credential_key)
  if new_token_credential_key != nil
    if !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
  else
    @token_credential_key = nil
  end
end
Also aliased as: access_token_key=
token_credential_secret() click to toggle source

Returns the token credential secret for this client.

@return [String] The token credential secret.

# File lib/signet/oauth_1/client.rb, line 438
def token_credential_secret
  return @token_credential_secret
end
Also aliased as: access_token_secret
token_credential_secret=(new_token_credential_secret) click to toggle source

Sets the token credential secret for this client.

@param [String, to_str] new_token_credential_secret

The token credential secret.
# File lib/signet/oauth_1/client.rb, line 448
def token_credential_secret=(new_token_credential_secret)
  if new_token_credential_secret != nil
    if !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
  else
    @token_credential_secret = nil
  end
end
Also aliased as: access_token_secret=
token_credential_uri() click to toggle source

Returns the token credential URI for this client.

@return [Addressable::URI] The token credential URI.

# File lib/signet/oauth_1/client.rb, line 143
def token_credential_uri
  return @token_credential_uri
end
Also aliased as: access_token_uri
token_credential_uri=(new_token_credential_uri) click to toggle source

Sets the token credential URI for this client.

@param [Addressable::URI, String, to_str] new_token_credential_uri

The token credential URI.
# File lib/signet/oauth_1/client.rb, line 153
def token_credential_uri=(new_token_credential_uri)
  if new_token_credential_uri != nil
    new_token_credential_uri =
      Addressable::URI.parse(new_token_credential_uri)
    @token_credential_uri = new_token_credential_uri
  else
    @token_credential_uri = nil
  end
end
Also aliased as: access_token_uri=
two_legged() click to toggle source

Returns whether the client is in two-legged mode.

@return [TrueClass, FalseClass]

<code>true</code> for two-legged mode, <code>false</code> otherwise.
# File lib/signet/oauth_1/client.rb, line 495
def two_legged
  return @two_legged ||= false
end
two_legged=(new_two_legged) click to toggle source

Sets the client for two-legged mode.

@param [TrueClass, FalseClass] new_two_legged

<code>true</code> for two-legged mode, <code>false</code> otherwise.
# File lib/signet/oauth_1/client.rb, line 504
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

[Validate]

Generated with the Darkfish Rdoc Generator 2.