authoritarian 0.1.0

data/README.md

@@ -0,0 +1,83 @@
+Authoritarian - Twitter OAuth Manager
+=====================================
+
+## DESCRIPTION
+
+Authoritarian is a command line interface for managing Twitter authorizations to
+your application. God forbid Twitter give us a simple way to manually add
+test accounts to our application.
+
+Authoritarian follows the rules of [Semantic Versioning](http://semver.org/).
+
+
+## INSTALL
+
+To install Authoritarian, simply install the gem:
+
+	$ [sudo] gem install authoritarian
+
+
+## TWITTER
+
+### APPLICATIONS
+
+To authorize using Twitter's API, start by registering your application in
+authoritarian:
+
+	$ authoritarian add application
+	Name: My Cool App
+	Consumer Key: HJvxyS06ykAA5AxYruY2p
+	Consumer Secret: 4wftaMYXpylkveupjQ4YDDZlarS35UJHR1ZHHSfjto
+
+You can find your Consumer Key and Consumer Secret for your application by
+going to the [Twitter Developer Applications](https://dev.twitter.com/apps) site
+and clicking on the application you'd like to add. The key and secret are listed
+under `OAuth 1.0a Settings`.
+
+You can view your registered applications:
+
+	$ authoritarian show applications
+	$ authoritarian show applications --all
+
+The `--all` option shows the consumer key and secret for each application.
+
+Finally, you can remove your application by running:
+
+	$ authoritarian show applications
+
+You'll be presented with prompts to select the application you wish to remove.
+
+### USERS
+
+Once you've registered a Twitter application with Authoritarian, you can 
+authorize individual Twitter users to your application from the command line.
+
+To authorize a user, simply type:
+
+	$ authoritarian add user
+
+And to show a list of all users, type:
+
+	$ authoritarian show users
+	$ authoritarian show users --all
+
+The `--all` option will append the OAuth token and OAuth token secret for each
+user registered to Authoritarian.
+
+To remove a user from Authoritarian (but not deauthorize), type:
+
+	$ authoritarian remove user
+
+
+## CONTRIBUTE
+
+Contributions to Authoritarian are welcome! There is no mailing list currently
+but you can add a feature you're interested in building to the GitHub Issues
+page to discuss it.
+
+If you do submit a pull request, please make sure you add test coverage and
+send your request from a git topic branch.
+
+You can find the repository here:
+
+http://github.com/benbjohnson/authoritarian

data/bin/authoritarian

@@ -0,0 +1,273 @@
+#!/usr/bin/ruby
+
+dir = File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib')
+$:.unshift(dir)
+
+require 'rubygems'
+require 'authoritarian'
+require 'commander/import'
+require 'terminal-table/import'
+
+program :name, 'Authoritarian'
+program :version, Authoritarian::VERSION
+program :description, 'An OAuth command line authorization tool.'
+
+
+################################################################################
+# Initialization
+################################################################################
+
+# Setup DataMapper
+DataMapper.setup(:default, "sqlite://#{File.expand_path('~/authoritarian.db')}")
+DataMapper.auto_upgrade!
+
+# Catch CTRL-C and exit cleanly
+trap("INT") do
+  puts
+  exit()
+end
+
+################################################################################
+# Helper Methods
+################################################################################
+
+def ask_application(explicit=false, message='Please choose an application')
+  applications = Application.all
+  if applications.length == 0
+    puts "There are no applications. Please run 'authoritarian add application'."
+    exit()
+  elsif applications.length == 1 && !explicit
+    return applications[0].id
+  else
+    puts ""
+    puts "Applications"
+    applications.each_index do |index|
+      puts "#{index+1}. #{applications[index].name}"
+    end
+    index = ask("#{message} [1-#{applications.length}]: ", Integer) do
+      |q| q.in = 1..applications.length
+    end
+    puts ""
+    return applications[index-1].id
+  end
+end
+
+def ask_user(application, explicit=false, message='Please choose a user')
+  users = application.users
+  if users.length == 0
+    puts "There are no users. Please run 'authoritarian add user'."
+    exit()
+  elsif users.length == 1 && !explicit
+    return users[0].id
+  else
+    puts "Users"
+    users.each_index do |index|
+      puts "#{index+1}. #{users[index].username}"
+    end
+    index = ask("#{message} [1-#{users.length}]: ", Integer) do
+      |q| q.in = 1..users.length
+    end
+    puts ""
+    return users[index-1].id
+  end
+end
+
+
+################################################################################
+# Application Commands
+################################################################################
+
+# Add application
+command :'add application' do |c|
+  c.syntax = 'authoritarian add application'
+  c.description = 'Adds an application to the database.'
+  c.when_called do|args, options|
+    application = Application.new(:type => 'twitter')
+    application.name = ask("Name: ")
+    application.consumer_key = ask("Consumer Key: ")
+    application.consumer_secret = ask("Consumer Secret: ")
+    application.save()
+  end
+end
+
+# Remove Application
+command :'remove application' do |c|
+  c.syntax = 'authoritarian remove application [options]'
+  c.description = 'Removes a registered application.'
+  c.option '--app-id ID', String, 'The identifier for the authorizing application.'
+  c.when_called do|args, options|
+    # Retrieve the application
+    options.app_id ||= ask_application(true, 'Please choose an application to delete')
+    application = Application.get(options.app_id)
+    raise "Cannot find application #{options.app_id}" if application.nil?
+    
+    # Delete application
+    application.destroy
+  end
+end
+
+# Show applications
+command :'show applications' do |c|
+  c.syntax = 'authoritarian show applications'
+  c.description = 'Displays all registered applications registered.'
+  c.option '--all', 'Shows all application data.'
+  c.when_called do|args, options|
+    applications = Application.all
+    
+    if applications.length == 0
+      say "There are no registered applications."
+    else
+      application_table = table do |t|
+        t.headings = 'ID', 'Name'
+
+        # Optionally add consumer info
+        if options.all
+          t.headings << 'Consumer Key'
+          t.headings << 'Consumer Secret'
+        end
+
+        applications.each do |application|
+          row = [
+            application.id,
+            application.name[0..20],
+          ]
+
+          # Optionally add consumer info
+          if options.all
+            row << application.consumer_key
+            row << application.consumer_secret
+          end
+          
+          t << row
+        end
+      end
+      
+      puts application_table
+    end
+  end
+end
+
+# Show application
+command :'show application' do |c|
+  c.syntax = 'authoritarian show application [options]'
+  c.description = 'Displays details of a single application.'
+  c.option '--id NUM', String, 'The application identifier.'
+  c.when_called do|args, options|
+    id = options.id || ask("ID: ")
+    application = Application.get(id)
+    
+    if application.nil?
+      say "The specified application does not exist."
+    else
+      puts "Name:            #{application.name}"
+      puts "Consumer Key:    #{application.consumer_key}"
+      puts "Consumer Secret: #{application.consumer_secret}"
+      puts ""
+    end
+  end
+end
+
+
+################################################################################
+# User Commands
+################################################################################
+
+# Add User
+command :'add user' do |c|
+  c.syntax = 'authoritarian authorize user [options]'
+  c.description = 'Authorizes a user to an application.'
+  c.option '--app-id ID', String, 'The identifier for the authorizing application.'
+  c.option '--username STRING', String, 'The username of the authorizing user.'
+  c.option '--password STRING', String, 'The password of the authorizing user.'
+  c.when_called do|args, options|
+    options.app_id ||= ask_application()
+
+    # Retrieve the application
+    application = Application.get(options.app_id)
+    raise "Cannot find application #{options.app_id}" if application.nil?
+    
+    # Retrieve authorization token
+    options.username ||= ask("Username: ")
+    options.password ||= ask("Password: ") {|q| q.echo = '*'}
+    authorizer = Authoritarian::Twitter.new(
+      application.consumer_key,
+      application.consumer_secret
+    )
+    auth = authorizer.authorize(options.username, options.password)
+    
+    # Create a user
+    user = User.new(:application => application)
+    user.username           = options.username
+    user.oauth_token        = auth[:token]
+    user.oauth_token_secret = auth[:secret]
+    user.save
+  end
+end
+
+# Remove User
+command :'remove user' do |c|
+  c.syntax = 'authoritarian remove user [options]'
+  c.description = 'Removes a user from a registered application.'
+  c.option '--app-id ID', String, 'The identifier for the authorizing application.'
+  c.when_called do|args, options|
+    # Retrieve the application
+    options.app_id ||= ask_application()
+    application = Application.get(options.app_id)
+    raise "Cannot find application #{options.app_id}" if application.nil?
+    
+    # Retrieve the user to remove
+    options.user_id ||= ask_user(application, true, 'Please choose a user to remove')
+    user = User.get(options.user_id)
+    raise "Cannot find user #{options.user_id}" if user.nil?
+    
+    # Delete user
+    user.destroy
+  end
+end
+
+# Show authorized users
+command :'show users' do |c|
+  c.syntax = 'authoritarian show users'
+  c.description = 'Displays all users authorized to registered applications.'
+  c.option '--app-id ID', String, 'The identifier for the authorizing application.'
+  c.option '--all', 'Shows all user data.'
+  c.when_called do|args, options|
+    options.app_id ||= ask_application()
+
+    # Retrieve the application
+    application = Application.get(options.app_id)
+    raise "Cannot find application #{options.app_id}" if application.nil?
+    users = application.users
+    
+    if users.length == 0
+      say "There are no users authorized to use #{application.name}."
+    else
+      user_table = table do |t|
+        t.headings = 'ID', 'Username'
+
+        # Optionally add oauth info
+        if options.all
+          t.headings << 'OAuth Token'
+          t.headings << 'OAuth Token Secret'
+        end
+
+        users.each do |user|
+          row = [
+            user.id,
+            user.username,
+          ]
+          
+          # Optionally add oauth info
+          if options.all
+            row << user.oauth_token
+            row << user.oauth_token_secret
+          end
+          
+          t << row
+        end
+      end
+      
+      puts user_table
+    end
+  end
+end

data/lib/authoritarian.rb

@@ -0,0 +1,16 @@
+dir = File.dirname(File.expand_path(__FILE__))
+$:.unshift(dir)
+
+require 'oauth'
+require 'mechanize'
+require 'dm-core'
+require 'dm-migrations'
+require 'dm-timestamps'
+require 'dm-validations'
+require 'authoritarian/model'
+require 'authoritarian/twitter'
+require 'authoritarian/version'
+
+module Authoritarian
+  class InvalidLoginError < StandardError; end
+end

data/lib/authoritarian/model.rb

@@ -0,0 +1,9 @@
+DataMapper::Model.raise_on_save_failure = true
+
+DataMapper::Property::String.length(255)
+DataMapper::Property::Boolean.allow_nil(false)
+
+require 'authoritarian/model/application'
+require 'authoritarian/model/user'
+
+DataMapper.finalize

data/lib/authoritarian/model/application.rb

@@ -0,0 +1,16 @@
+class Application
+  include ::DataMapper::Resource
+  has n, :users
+
+  property :id,              Serial
+  property :type,            String
+  property :name,            String
+  property :consumer_key,    String
+  property :consumer_secret, String
+  timestamps :at
+
+  validates_presence_of :type
+  validates_presence_of :name
+  validates_presence_of :consumer_key
+  validates_presence_of :consumer_secret
+end

data/lib/authoritarian/model/user.rb

@@ -0,0 +1,12 @@
+class User
+  include ::DataMapper::Resource
+  belongs_to :application
+
+  property :id,                 Serial
+  property :username,           String
+  property :oauth_token,        String
+  property :oauth_token_secret, String
+  timestamps :at
+
+  validates_presence_of :application_id
+end

data/lib/authoritarian/twitter.rb

@@ -0,0 +1,103 @@
+module Authoritarian
+  # This class performs OAuth authorization for Twitter user accounts.
+  class Twitter
+    ############################################################################
+    # Constructor
+    ############################################################################
+
+    # Creates a Twitter OAuth authorizer.
+    def initialize(consumer_key=nil, consumer_secret=nil)
+      self.consumer_key    = consumer_key
+      self.consumer_secret = consumer_secret
+    end
+    
+    
+    ############################################################################
+    # Public Attributes
+    ############################################################################
+    
+    # The consumer key for the application that is authorizing the user.
+    attr_accessor :consumer_key
+    
+    # The consumer secret for the application that is authorizing the user.
+    attr_accessor :consumer_secret
+
+    
+    ############################################################################
+    # Public Methods
+    ############################################################################
+    
+    def authorize(username, password)
+      # Generate request token
+      request_token = consumer.get_request_token
+      
+      # Create in-process browser
+      mechanize = Mechanize.new do |agent|
+        #agent.user_agent_alias = 'Authoritarian'
+      end
+
+      # Request authorization
+      mechanize.get(generate_authorize_url(request_token)) do |login_page|
+        # Login and allow
+        form = *login_page.forms
+        form.field_with(:name => 'session[username_or_email]').value = username
+        form.field_with(:name => 'session[password]').value = password
+        auth_page = form.submit(form.button_with(:value => 'Allow'))
+        
+        # Verify returned page has no errors
+        error = auth_page.parser.css('p.oauth-errors').text.strip
+        if error != ''
+          raise Authoritarian::InvalidLoginError.new(error)
+        end
+        
+        # If not then get access token from PIN
+        pin = auth_page.parser.css('div#oauth_pin').text.strip
+
+        # Create OAuth token from PIN
+        access_token = request_token.get_access_token(:oauth_verifier => pin)
+        return {:token => access_token.token, :secret => access_token.secret}
+      end
+
+      return nil
+    end
+
+
+    ############################################################################
+    # Private Methods
+    ############################################################################
+    
+    protected
+
+    # Generates the authorization url to have the user log into.
+    def generate_authorize_url(request_token)
+      # Create request
+      request = 
+        consumer.create_signed_request(
+          :get, 
+          consumer.authorize_path, 
+          request_token, 
+          {:oauth_callback => 'oob'}
+        )
+      
+      # Alter parameters
+      params = request['Authorization'].sub(/^OAuth\s+/, '').split(/,\s+/).map { |p|
+        k, v = p.split('=')
+        v =~ /"(.*?)"/
+        "#{k}=#{CGI::escape($1)}"
+      }.join('&')
+      
+      # Return authorize url
+      return "https://api.twitter.com#{request.path}?#{params}"
+    end
+
+    # The OAuth consumer object.
+    def consumer
+      @consumer ||=
+        ::OAuth::Consumer.new(
+          consumer_key,
+          consumer_secret,
+          :site => "https://api.twitter.com"
+        )
+    end
+  end
+end

data/lib/authoritarian/version.rb

@@ -0,0 +1,3 @@
+module Authoritarian
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification 
+name: authoritarian
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ben Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-28 00:00:00 -07:00
+default_executable: authoritarian
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: data_mapper
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dm-sqlite-adapter
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 1
+        - 0
+        - 2
+        version: 1.0.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: commander
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 4
+        - 0
+        - 3
+        version: 4.0.3
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: terminal-table
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 1
+        - 4
+        - 2
+        version: 1.4.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
+        version: 0.9.12
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: unindentable
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :development
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id009
+description: 
+email: 
+- benbjohnson@yahoo.com
+executables: 
+- authoritarian
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/authoritarian/model/application.rb
+- lib/authoritarian/model/user.rb
+- lib/authoritarian/model.rb
+- lib/authoritarian/twitter.rb
+- lib/authoritarian/version.rb
+- lib/authoritarian.rb
+- README.md
+- bin/authoritarian
+has_rdoc: true
+homepage: http://github.com/benbjohnson/authoritarian
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A command line OAuth authorization tool.
+test_files: []
+