mbbx6spp-twurl 0.6.1

data/lib/twurl/configuration_controller.rb

@@ -0,0 +1,22 @@
+module Twurl
+  class ConfigurationController < AbstractCommandController
+    UNRECOGNIZED_SETTING_MESSAGE = "Unknown configuration setting: '%s'"
+    def dispatch
+      case options.subcommands.first
+      when 'default'
+        if profile = case options.subcommands.size
+                     when 2
+                       OAuthClient.load_client_for_username(options.subcommands.last)
+                     when 3
+                       OAuthClient.load_client_for_username_and_consumer_key(*options.subcommands[-2, 2])
+                     end
+
+          OAuthClient.rcfile.default_profile = profile
+          OAuthClient.rcfile.save
+        end
+      else
+        CLI.puts(UNRECOGNIZED_SETTING_MESSAGE % options.subcommands.first)
+      end
+    end
+  end
+end

data/lib/twurl/oauth_client.rb

@@ -0,0 +1,170 @@
+module Twurl
+  class OAuthClient
+    class << self
+      def rcfile(reload = false)
+        if reload || @rcfile.nil?
+          @rcfile = RCFile.new
+        end
+        @rcfile
+      end
+
+      def load_from_options(options)
+        if rcfile.has_oauth_profile_for_username_with_consumer_key?(options.username, options.consumer_key)
+          load_client_for_username_and_consumer_key(options.username, options.consumer_key)
+        elsif options.username || (options.command == 'authorize')
+          load_new_client_from_options(options)
+        else
+          load_default_client
+        end
+      end
+
+      def load_client_for_username_and_consumer_key(username, consumer_key)
+        user_profiles = rcfile[username]
+        if user_profiles && attributes = user_profiles[consumer_key]
+          new(attributes)
+        else
+          raise Exception, "No profile for #{username}"
+        end
+      end
+
+      def load_client_for_username(username)
+        if user_profiles = rcfile[username]
+          if user_profiles.values.size == 1
+            new(user_profiles.values.first)
+          else
+            raise Exception, "There is more than one consumer key associated with #{username}. Please specify which consumer key you want as well."
+          end
+        else
+          raise Exception, "No profile for #{username}"
+        end
+      end
+
+      def load_new_client_from_options(options)
+        new(options.oauth_client_options.merge('password' => options.password))
+      end
+
+      def load_default_client
+        raise Exception, "You must authorize first" unless rcfile.default_profile
+        load_client_for_username_and_consumer_key(*rcfile.default_profile)
+      end
+    end
+
+    OAUTH_CLIENT_OPTIONS = %w[username consumer_key consumer_secret token secret]
+    attr_reader *OAUTH_CLIENT_OPTIONS
+    attr_reader :password
+    def initialize(options = {})
+      @username        = options['username']
+      @password        = options['password']
+      @consumer_key    = options['consumer_key']
+      @consumer_secret = options['consumer_secret']
+      @token           = options['token']
+      @secret          = options['secret']
+      configure_http!
+    end
+
+    [:get, :post, :put, :delete, :options, :head, :copy].each do |request_method|
+      class_eval(<<-EVAL, __FILE__, __LINE__)
+        def #{request_method}(url, options = {})
+          # configure_http!
+          access_token.#{request_method}(url, options)
+        end
+      EVAL
+    end
+
+    def perform_request_from_options(options)
+      send(options.request_method, options.path, options.data)
+    end
+
+    def exchange_credentials_for_access_token
+      response = begin
+        consumer.token_request(:post, consumer.access_token_path, nil, {}, client_auth_parameters)
+      rescue OAuth::Unauthorized
+        perform_pin_authorize_workflow
+      end
+      @token   = response[:oauth_token]
+      @secret  = response[:oauth_token_secret]
+    end
+
+    def client_auth_parameters
+      {:x_auth_username => username, :x_auth_password => password, :x_auth_mode => 'client_auth'}
+    end
+
+    def perform_pin_authorize_workflow
+      @request_token = consumer.get_request_token
+      CLI.puts("Go to #{generate_authorize_url} and paste in the supplied PIN")
+      pin = gets
+      access_token = @request_token.get_access_token(:oauth_verifier => pin.chomp)
+      {:oauth_token => access_token.token, :oauth_token_secret => access_token.secret}
+    end
+
+    def generate_authorize_url
+      request = consumer.create_signed_request(:get, consumer.authorize_path, @request_token, pin_auth_parameters)
+      params = request['Authorization'].sub(/^OAuth\s+/, '').split(/,\s+/).map { |p|
+        k, v = p.split('=')
+        v =~ /"(.*?)"/
+        "#{k}=#{CGI::escape($1)}"
+      }.join('&')
+      "#{Twurl.options.base_url}#{request.path}?#{params}"
+    end
+
+    def pin_auth_parameters
+      {:oauth_callback => 'oob'}
+    end
+
+    def fetch_verify_credentials
+      access_token.get('/1/account/verify_credentials.json')
+    end
+
+    def authorized?
+      oauth_response = fetch_verify_credentials
+      oauth_response.class == Net::HTTPOK
+    end
+
+    def needs_to_authorize?
+      token.nil? || secret.nil?
+    end
+
+    def save
+      verify_has_username
+      self.class.rcfile << self
+    end
+
+    def verify_has_username
+      if username.nil? || username == ''
+        oauth_response = fetch_verify_credentials
+        oauth_response.body =~ /"screen_name"\s*:\s*"(.*?)"/
+        @username = $1
+      end
+    end
+
+    def to_hash
+      OAUTH_CLIENT_OPTIONS.inject({}) do |hash, attribute|
+        if value = send(attribute)
+          hash[attribute] = value
+        end
+        hash
+      end
+    end
+
+    def configure_http!
+      consumer.http.set_debug_output(Twurl.options.debug_output_io) if Twurl.options.trace
+      if Twurl.options.ssl?
+        consumer.http.use_ssl     = true
+        consumer.http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    def consumer
+      @consumer ||=
+        OAuth::Consumer.new(
+          consumer_key,
+          consumer_secret,
+          :site => Twurl.options.base_url
+        )
+    end
+
+    def access_token
+      @access_token ||= OAuth::AccessToken.new(consumer, token, secret)
+    end
+  end
+end

data/lib/twurl/rcfile.rb

@@ -0,0 +1,96 @@
+module Twurl
+  class RCFile
+    FILE = '.twurlrc'
+    class << self
+      attr_accessor :directory
+
+      def directory
+        @directory || ENV['HOME']
+      end
+
+      def file_path
+        File.join(directory, FILE)
+      end
+
+      def load
+        YAML.load_file(file_path)
+      rescue Errno::ENOENT
+        default_rcfile_structure
+      end
+
+      def default_rcfile_structure
+        {'profiles' => {}, 'configuration' => {}}
+      end
+    end
+
+    attr_reader :data
+    def initialize
+      @data = self.class.load
+    end
+
+    def empty?
+      data == self.class.default_rcfile_structure
+    end
+
+    def save
+      File.open(self.class.file_path, 'w') do |rcfile|
+        rcfile.write data.to_yaml
+      end
+    end
+
+    def [](username)
+      profiles[username]
+    end
+
+    def profiles
+      data['profiles']
+    end
+
+    def default_profile
+      configuration['default_profile']
+    end
+
+    def default_profile=(profile)
+      configuration['default_profile'] = [profile.username, profile.consumer_key]
+    end
+
+    def configuration
+      data['configuration']
+    end
+
+    def alias(name, path)
+      data['aliases'] ||= {}
+      data['aliases'][name] = path
+      save
+    end
+
+    def aliases
+      data['aliases']
+    end
+
+    def alias_from_options(options)
+      options.subcommands.each do |potential_alias|
+        if path = alias_from_name(potential_alias)
+          break path
+        end
+      end
+    end
+
+    def alias_from_name(name)
+      aliases[name]
+    end
+
+    def has_oauth_profile_for_username_with_consumer_key?(username, consumer_key)
+      user_profiles = self[username]
+      !user_profiles.nil? && !user_profiles[consumer_key].nil?
+    end
+
+    def <<(oauth_client)
+      client_from_file = self[oauth_client.username] || {}
+      client_from_file[oauth_client.consumer_key] = oauth_client.to_hash
+      (profiles[oauth_client.username] ||= {}).update(client_from_file)
+      self.default_profile = oauth_client unless default_profile
+      save
+    end
+  end
+end

data/lib/twurl/request_controller.rb

@@ -0,0 +1,19 @@
+module Twurl
+  class RequestController < AbstractCommandController
+    NO_URI_MESSAGE = "No URI specified"
+    def dispatch
+      if client.needs_to_authorize?
+        raise Exception, "You need to authorize first."
+      end
+      options.path ||= OAuthClient.rcfile.alias_from_options(options)
+      perform_request
+    end
+
+    def perform_request
+      response = client.perform_request_from_options(options)
+      CLI.puts response.body
+    rescue URI::InvalidURIError
+      CLI.puts NO_URI_MESSAGE
+    end
+  end
+end

data/lib/twurl/version.rb

@@ -0,0 +1,10 @@
+module Twurl
+  module VERSION
+    MAJOR  = '0'
+    MINOR  = '6'
+    TINY   = '1'
+    BETA   = nil # Time.now.to_i.to_s
+  end
+
+  Version = [VERSION::MAJOR, VERSION::MINOR, VERSION::TINY, VERSION::BETA].compact * '.'
+end

data/test/account_information_controller_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Twurl::AccountInformationController::DispatchWithNoAuthorizedAccountsTest < Test::Unit::TestCase
+  attr_reader :options, :client, :controller
+  def setup
+    @options    = Twurl::Options.new
+    @client     = Twurl::OAuthClient.load_new_client_from_options(options)
+    @controller = Twurl::AccountInformationController.new(client, options)
+    mock(Twurl::OAuthClient.rcfile).empty? { true }
+  end
+
+  def test_message_indicates_when_no_accounts_are_authorized
+    mock(Twurl::CLI).puts(Twurl::AccountInformationController::NO_AUTHORIZED_ACCOUNTS_MESSAGE).times(1)
+
+    controller.dispatch
+  end
+end
+
+class Twurl::AccountInformationController::DispatchWithOneAuthorizedAccountTest < Test::Unit::TestCase
+  attr_reader :options, :client, :controller
+  def setup
+    @options    = Twurl::Options.test_exemplar
+    @client     = Twurl::OAuthClient.load_new_client_from_options(options)
+    mock(Twurl::OAuthClient.rcfile).save.times(1)
+    Twurl::OAuthClient.rcfile << client
+    @controller = Twurl::AccountInformationController.new(client, options)
+  end
+
+  def test_authorized_account_is_displayed_and_marked_as_the_default
+    mock(Twurl::CLI).puts(client.username).times(1).ordered
+    mock(Twurl::CLI).puts("  #{client.consumer_key} (default)").times(1).ordered
+
+    controller.dispatch
+  end
+end
+
+class Twurl::AccountInformationController::DispatchWithOneUsernameThatHasAuthorizedMultipleAccountsTest < Test::Unit::TestCase
+  attr_reader :default_client_options, :default_client, :other_client_options, :other_client, :controller
+  def setup
+    @default_client_options = Twurl::Options.test_exemplar
+    @default_client         = Twurl::OAuthClient.load_new_client_from_options(default_client_options)
+
+    @other_client_options             = Twurl::Options.test_exemplar
+    other_client_options.consumer_key = default_client_options.consumer_key.reverse
+    @other_client                     = Twurl::OAuthClient.load_new_client_from_options(other_client_options)
+    mock(Twurl::OAuthClient.rcfile).save.times(2)
+
+    Twurl::OAuthClient.rcfile << default_client
+    Twurl::OAuthClient.rcfile << other_client
+
+    @controller = Twurl::AccountInformationController.new(other_client, other_client_options)
+  end
+
+  def test_authorized_account_is_displayed_and_marked_as_the_default
+    mock(Twurl::CLI).puts(default_client.username).times(1)
+    mock(Twurl::CLI).puts("  #{default_client.consumer_key} (default)").times(1)
+    mock(Twurl::CLI).puts("  #{other_client.consumer_key}").times(1)
+
+    controller.dispatch
+  end
+end

data/test/alias_controller_test.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Twurl::AliasesController::DispatchTest < Test::Unit::TestCase
+  attr_reader :options, :client
+  def setup
+    @options = Twurl::Options.test_exemplar
+    @client  = Twurl::OAuthClient.test_exemplar
+
+    # Clean slate
+    if Twurl::OAuthClient.rcfile.aliases
+      Twurl::OAuthClient.rcfile.aliases.clear
+    end
+
+    stub(Twurl::OAuthClient.rcfile).save
+  end
+
+  def test_when_no_subcommands_are_provided_and_no_aliases_exist_nothing_is_displayed
+    assert options.subcommands.empty?
+    mock(Twurl::CLI).puts(Twurl::AliasesController::NO_ALIASES_MESSAGE).times(1)
+
+    controller = Twurl::AliasesController.new(client, options)
+    controller.dispatch
+  end
+
+  def test_when_no_subcommands_are_provided_and_aliases_exist_they_are_displayed
+    assert options.subcommands.empty?
+
+    Twurl::OAuthClient.rcfile.alias('h', '/1/statuses/home_timeline.xml')
+    mock(Twurl::CLI).puts("h: /1/statuses/home_timeline.xml").times(1)
+
+    controller = Twurl::AliasesController.new(client, options)
+    controller.dispatch
+  end
+
+  def test_when_alias_and_value_are_provided_they_are_added
+    options.subcommands = ['h']
+    options.path        = '/1/statuses/home_timeline.xml'
+    mock(Twurl::OAuthClient.rcfile).alias('h', '/1/statuses/home_timeline.xml').times(1)
+
+    controller = Twurl::AliasesController.new(client, options)
+    controller.dispatch
+  end
+
+  def test_when_no_path_is_provided_nothing_happens
+    options.subcommands = ['a']
+    assert_nil options.path
+
+    mock(Twurl::CLI).puts(Twurl::AliasesController::NO_PATH_PROVIDED_MESSAGE).times(1)
+
+    controller = Twurl::AliasesController.new(client, options)
+    controller.dispatch
+  end
+end

data/test/authorization_controller_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class Twurl::AuthorizationController::DispatchTest < Test::Unit::TestCase
+  attr_reader :options, :client, :controller
+  def setup
+    @options    = Twurl::Options.new
+    @client     = Twurl::OAuthClient.load_new_client_from_options(options)
+    @controller = Twurl::AuthorizationController.new(client, options)
+  end
+
+  def test_successful_authentication_saves_retrieved_access_token
+    mock(client).exchange_credentials_for_access_token.times(1)
+    mock(client).save.times(1)
+    mock(controller).raise(Twurl::Exception, Twurl::AuthorizationController::AUTHORIZATION_FAILED_MESSAGE).never
+    mock(Twurl::CLI).puts(Twurl::AuthorizationController::AUTHORIZATION_SUCCEEDED_MESSAGE).times(1)
+
+    controller.dispatch
+  end
+
+  module ErrorCases
+    def test_failed_authorization_does_not_save_client
+      mock(client).exchange_credentials_for_access_token { raise OAuth::Unauthorized }
+      mock(client).save.never
+      mock(controller).raise(Twurl::Exception, Twurl::AuthorizationController::AUTHORIZATION_FAILED_MESSAGE).times(1)
+
+      controller.dispatch
+    end
+  end
+  include ErrorCases
+end