nakajima-twitter-client 0.0.2

data/lib/core_ext/delegation.rb

@@ -0,0 +1,25 @@
+module Twitter
+  module Delegation
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def delegate(*args)
+        opts = args.last.is_a?(Hash) ? args.pop : {}
+        if target = opts[:to]
+          args.each do |sym|
+            class_eval(<<-END, __FILE__, __LINE__)
+              def #{sym}(*args, &block)
+                send(#{target.inspect}) \
+                  .send(#{sym.inspect}, *args, &block)
+              end
+            END
+          end
+        else
+          raise ArgumentError, "You must pass a target as :to option"
+        end
+      end
+    end
+  end
+end

data/lib/twitter/api.rb

@@ -0,0 +1,13 @@
+module Twitter
+  # Namespace for constants and exceptions related to the Twitter API.
+  module API
+    # Everything goes to Twitter for now
+    BASE = 'twitter.com'
+
+    # Everything goes through JSON for now
+    FORMAT = 'json'
+
+    # Raised when API returns a 401 response status.
+    class Unauthorized < StandardError ; end
+  end
+end

data/lib/twitter/connection.rb

@@ -0,0 +1,52 @@
+module Twitter
+  class Connection
+    include Delegation
+
+    attr_reader :session
+
+    delegate :username, :password, :to => :session
+
+    def initialize(session)
+      @session = session
+    end
+
+    # Make GET request with HTTP auth
+    def get(path, params={})
+      request(:get, path, params)
+    end
+
+    # Make post request with HTTP auth
+    def post(path, params={})
+      request(:post, path, params) do |req|
+        req.set_form_data(params)
+      end
+    end
+
+    # Ensure authentication credentials are valid
+    def authenticate!
+      @response ||= get('/account/verify_credentials')
+    end
+
+    private
+
+    # Wrap common request logic for POST/GET requests
+    def request(verb, path, params)
+      path = path + '.' + Twitter::API::FORMAT
+      res = Net::HTTP.start(Twitter::API::BASE) do |http|
+        req = Net::HTTP.const_get(verb.to_s.capitalize).new(path)
+        req.basic_auth username, password
+        yield req if block_given?
+        res = http.request(req)
+        check_response(res)
+      end
+    end
+
+    # Ensure response is valid
+    def check_response(res)
+      case res
+      when Net::HTTPUnauthorized then raise API::Unauthorized.new
+      else res
+      end
+    end
+  end
+end

data/lib/twitter/session.rb

@@ -0,0 +1,46 @@
+module Twitter
+  # Most of the logic in twitter-client lives in here. Responsible
+  # for maintaining/persisting credentials.
+  class Session
+    attr_reader :username, :password
+    attr_writer :filename
+
+    def initialize(username, password, opts={})
+      @username, @password = username, password
+      @connection = opts[:connected]
+    end
+
+    # Post a via the current session.
+    # TODO The Session class should be infrastructural. Domain logic like
+    #      this should go elsewhere.
+    def tweet!(msg)
+      connection.post('/statuses/update', :status => msg) ; msg
+    end
+
+    # Ensure validity of credentials
+    def connect!
+      connection(true)
+    end
+
+    # Provide verification that session is able to be used
+    def connected?
+      if @connection
+        true
+      end
+    end
+
+    def ==(other)
+      [username, password] == [other.username, other.password]
+    end
+
+    private
+
+    def connection(force=false)
+      (@connection and not force) ? @connection : begin
+        @connection = Connection.new(self)
+        @connection.authenticate!
+        @connection
+      end
+    end
+  end
+end

data/lib/twitter/store.rb

@@ -0,0 +1,52 @@
+module Twitter
+  class Store
+    attr_writer :filename
+
+    def initialize(env={})
+      @env = env
+      @sessions = @env[:sessions]
+    end
+
+    # Persist the current session to a dot file
+    def save
+      f = File.new(File.join(ENV['HOME'], filename), 'w+')
+      f << yaml_dump
+      f.close
+    end
+
+    # Attempt to load the current session from a dot file
+    def load
+      YAML.load_file(File.join(ENV['HOME'], filename)) || {}
+    end
+
+    # Allow custom name for dot file used to persist sessions
+    def filename
+      @filename || '.twitter'
+    end
+
+    def sessions
+      @sessions ||= begin
+        load[:sessions].inject({}) do |res, (key, val)|
+          password = crypter.decrypt_string(val)
+          res[key] = Session.new(key, password, :connected => true)
+          res
+        end
+      end
+    end
+
+    private
+
+    def crypter
+      @crypter ||= Crypt::Blowfish.new('twitter-crypt-key')
+    end
+
+    def yaml_dump
+      session_data = sessions.inject({}) do |res, session|
+        res[session.username] = crypter.encrypt_string(session.password)
+        res
+      end
+
+      { :sessions => session_data }.to_yaml
+    end
+  end
+end

data/lib/twitter/twitter.rb

@@ -0,0 +1,77 @@
+module Twitter
+  class << self
+    # Reset session
+    def reset!
+      sessions.clear
+      @username = nil
+    end
+
+    def use(username)
+      @username = username
+    end
+
+    def save(filename=nil)
+      store = Store.new(:sessions => sessions.values)
+      store.filename = filename if filename
+      store.save
+    end
+
+    def load(filename=nil)
+      store = Store.new
+      store.filename = filename if filename
+      if store.load
+        @sessions = store.sessions
+        @username = @sessions.keys.first
+      end
+    end
+
+    # Delegate method missing calls to session
+    def method_missing(sym, *args, &blk)
+      if authenticated? and delegating?(sym)
+        current_session.send(sym, *args, &blk)
+      else
+        super
+      end
+    end
+
+    # Check for presence of session or try to load saved session
+    def authenticated?(loaded=false)
+      return true if current_session and current_session.connected?
+      if not loaded
+        load
+        authenticated?(true)
+      end
+    end
+
+    # Create new session from passed credentials
+    def authenticate(username, password)
+      session = Session.new(username, password)
+      session.connect!
+      sessions[username] = session
+      @username = username
+    end
+
+    # Load saved session from a .twitter file
+    def load_session
+      session = Session.new(nil, nil)
+      if session.load
+        @session = session ; true
+      end
+    end
+
+    private
+
+    def current_session
+      sessions[@username]
+    end
+
+    def sessions
+      @sessions ||= {}
+    end
+
+    # Check to see if Twitter is delegating this method to session
+    def delegating?(sym)
+      Session.public_instance_methods.include?(sym.to_s)
+    end
+  end
+end

data/lib/twitter-client.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH << File.dirname(__FILE__)
+
+# standard library
+require 'rubygems'
+require 'fileutils'
+require 'net/http'
+require 'yaml'
+require 'cgi'
+
+# Gems
+begin
+  require 'crypt/blowfish'
+rescue LoadError
+  $NO_CRYPT = true
+  # Fake encrypter if it's not available
+  module Crypt
+    class Blowfish
+      def initialize(*args) end
+      def decrypt_string(str); str end
+      def encrypt_string(str); str end
+    end
+  end
+  puts "  Warning!"
+  puts
+  puts "  The crypt/blowfish gem was not found."
+  puts "  As a result, saved session file will not be encrypted."
+  puts "  Run `gem install crypt` to install encryption libraries."
+end
+
+# Extensions
+require 'core_ext/delegation'
+
+# Source files
+require 'twitter/api'
+require 'twitter/store'
+require 'twitter/session'
+require 'twitter/connection'
+require 'twitter/twitter'
+
+# Hpricot-y constant-method
+def Twitter(*args, &block)
+  if args.empty? and not block_given?
+    Twitter
+  else
+    if args.length == 1
+      Twitter.tweet!(*args)
+    end
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+name: nakajima-twitter-client
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-30 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: patnakajima@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/core_ext
+- lib/core_ext/delegation.rb
+- lib/twitter
+- lib/twitter/api.rb
+- lib/twitter/connection.rb
+- lib/twitter/session.rb
+- lib/twitter/store.rb
+- lib/twitter/twitter.rb
+- lib/twitter-client.rb
+has_rdoc: true
+homepage: http://github.com/nakajima/twitter-client
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Simple, clean, redundant.
+test_files: []
+