tweetwine 0.2.4

data/CHANGELOG.rdoc

@@ -0,0 +1,84 @@
+=== 0.2.4 released 2009-09-16
+
+* Retry connection upon connection reset, trying maximum of three times.
+* Display proper version info on Ruby 1.8 when using option "-v".
+* Minor code cleanups.
+* Release 0.2.3 is skipped due to my error in tagging the wrong commit.
+
+=== 0.2.2 released 2009-09-03
+
+* Highlight hashtags in statuses.
+* URL shortening step shortens only unique URLs.
+* URL shortening step is skipped if
+  - there is a connection error to the URL shortening service, or
+  - required libraries are not installed (nokogiri).
+* Fixed a colorization bug for duplicate URLs.
+* Removed dependencies to Rubygems.
+
+=== 0.2.1 released 2009-08-17
+
+* Command line option "-v" show version information.
+* Slight implementation code cleaning.
+
+=== 0.2.0 released 2009-08-17
+
+* URL shortening by using an external web service.
+* Show a preview before sending status update.
+* Avoid stack trace upon erroneous connection.
+
+=== 0.1.11 released 2009-08-10
+
+* Fixed highlighting multiple nicks in statuses.
+
+=== 0.1.10 released 2009-08-09
+
+* Improved URL highlight support.
+
+=== 0.1.9 released 2009-07-15
+
+* Added commands "friends" and "followers"
+* Removed dependency to the "json" gem. It is included in Ruby 1.9.
+
+=== 0.1.8 released 2009-07-01
+
+* SIGINT (Ctrl+c) is trapper earlier, resulting in clean abort while Ruby
+  loads the program's required libraries.
+
+=== 0.1.7 released 2009-06-07
+
+* Small compatibility fix with Ruby 1.9.
+
+=== 0.1.6 released 2009-06-07
+
+* Improved URL highlighting.
+
+=== 0.1.5 released 2009-06-06
+
+* URLs of http(s) scheme are highlighted. Changed colors.
+* Friendly abort message when interrupting the program with Ctrl+C.
+
+=== 0.1.4 released 2009-05-12
+
+* Command line option "--page N" fetches a specific status page
+
+=== 0.1.3 released 2009-05-05
+
+* Empty status update indicates cancellation of the command
+* Other minor improvements
+
+=== 0.1.2 released 2009-05-04
+
+* Renamed command "friends" to "home"
+* Added command "mentions"
+* When showing a status, indicate if it is a reply
+* Improved command line argument and configuration file parsing
+
+=== 0.1.1 released 2009-04-23
+
+* Renamed command "msg" to "update"
+* If status update if longer than 140 characters, warn about it
+
+=== 0.1.0 released 2009-04-22
+
+* Initial release with minimal functionality
+* Usable for quickly checking friends' statuses and sending status updates

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Tuomas Kareinen.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,87 @@
+= Tweetwine
+
+A simple but tasty Twitter agent for command line use, made for fun.
+
+== Installation
+
+Install Tweetwine as a RubyGem from GitHub:
+
+  $ sudo gem install tuomas-tweetwine --source http://gems.github.com
+
+The program is compatible with Ruby 1.9.1, and it requires <b>rest_client</b>
+gem to be installed. In addition, <b>json</b> gem is needed for Ruby 1.8.6.
+
+== Usage
+
+In the command line, run the program by entering
+
+  $ tweetwine [options...] [command]
+
+The program needs the user's username and password for authentication. This
+information can be supplied either via a configuration file or as an option
+(<tt>-a USERNAME:PASSWORD</tt>) to the program. It is recommended to use the
+former method over the latter.
+
+The configuration file, in <tt>~/.tweetwine</tt>, is in YAML syntax. The
+program recognizes the following basic settings:
+
+  username: <your_username>
+  password: <your_password>
+  colorize: true|false 
+
+When invoking the program, the supported commands are
+
+<tt>home</tt>:: Fetch friends' latest statuses (the contents of the authenticated user's home).
+<tt>mentions</tt>:: Fetch latest mentions for the authenticated user.
+<tt>user [name]</tt>:: Fetch a specific user's latest statuses, identified by the argument; if given no argument, fetch the statuses of the authenticated user.
+<tt>update [status]</tt>:: Send a status update, but confirm the action first before actually sending. The status update can either be given as an argument or via STDIN if no argument is given.
+<tt>friends</tt>:: Fetch friends and their latest statuses.
+<tt>followers</tt>:: Fetch followers and their latest statuses.
+
+If no <tt>[command]</tt> is given, the default action is <tt>home</tt>.
+
+For all the options, see:
+
+  $ tweetwine -h
+
+=== URL shortening for status update
+
+Before actually sending a status update, it is possible for the software to
+shorten the URLs in the update by using an external web service. This can be
+enabled via the <tt>shorten_urls</tt> key in configuration file; for
+example:
+
+  username: spoonman
+  password: withyourhands
+  colorize: true
+  shorten_urls:
+    enable: true
+    service_url: http://is.gd/create.php
+    method: post
+    url_param_name: URL
+    xpath_selector: //input[@id='short_url']/@value
+
+The supported methods are <tt>get</tt> and <tt>post</tt>. The method chosen
+affects whether parameters are passed as URL query parameters or as payload
+in the HTTP request, respectively. Extra parameters can be given via
+<tt>extra_params</tt> key, as a hash.
+
+The <tt>xpath_selector</tt> is needed to extract the shortened URL from the
+result.
+
+The feature can be disabled by
+
+* not defining <tt>shorten_urls</tt> key in the configuration file,
+* setting key <tt>enable</tt> to <tt>false</tt>, or
+* using the command line option <tt>--no-url-shorten</tt>.
+
+The use of the feature requires <b>nokogiri</b> gem to be installed.
+
+== Contacting
+
+Please send feedback by email to Tuomas Kareinen < tkareine (at) gmail (dot)
+com >.
+
+== Legal notes
+
+Copyright (c) 2009 Tuomas Kareinen. See MIT-LICENSE.txt in this directory.

data/Rakefile

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+
+require "rubygems"
+
+name = "tweetwine"
+require "#{name}"
+version = Tweetwine::VERSION
+
+require "rake/clean"
+
+require "rake/gempackagetask"
+spec = Gem::Specification.new do |s|
+  s.name = name
+  s.version = version
+  s.homepage = "http://github.com/tuomas/tweetwine"
+  s.summary = "A simple Twitter agent for command line use"
+  s.description = "A simple but tasty Twitter agent for command line use, made for fun."
+
+  s.author = "Tuomas Kareinen"
+  s.email = "tkareine@gmail.com"
+
+  s.platform = Gem::Platform::RUBY
+  s.files = FileList["Rakefile", "MIT-LICENSE.txt", "*.rdoc", "bin/**/*", "lib/**/*", "test/**/*"].to_a
+  s.executables = ["tweetwine"]
+
+  s.add_dependency("rest-client", ">= 1.0.0")
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = FileList["MIT-LICENSE.txt", "*.rdoc"].to_a
+  s.rdoc_options << "--title"   << "#{name} #{version}" \
+                 << "--main"    << "README.rdoc" \
+                 << "--exclude" << "test" \
+                 << "--line-numbers"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = true
+end
+
+desc "Generate a gemspec file"
+task :gemspec do
+  File.open("#{spec.name}.gemspec", "w") do |f|
+    f.write spec.to_ruby
+  end
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{name}-#{version}.gem}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{name}}
+end
+
+require "rake/rdoctask"
+desc "Create documentation"
+Rake::RDocTask.new(:rdoc) do |rd|
+  rd.rdoc_dir = "rdoc"
+  rd.title = "#{name} #{version}"
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("MIT-LICENSE.txt", "*.rdoc", "lib/**/*.rb")
+  rd.options << "--line-numbers"
+end
+
+require "rake/testtask"
+desc "Run tests"
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+  t.warning = true
+  t.ruby_opts << "-rrubygems"
+  t.libs << "test"
+end
+
+desc "Find code smells"
+task :roodi do
+  sh %{roodi "**/*.rb"}
+end
+
+desc "Search unfinished parts of source code"
+task :todo do
+  FileList["**/*.rb", "**/*.rdoc", "**/*.txt"].egrep /(TODO|FIXME)/
+end
+
+task :default => :test

data/bin/tweetwine

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+EXIT_HELP = 1
+EXIT_VERSION = 2
+EXIT_SIGINT = 6
+EXIT_ERROR = 64
+
+trap("INT") do
+  puts "\nAbort"
+  exit(EXIT_SIGINT)
+end
+
+require "optparse"
+require "tweetwine"
+
+include Tweetwine
+
+cmd_parser = lambda do |args|
+  options = {}
+  begin
+    OptionParser.new do |opt|
+      opt.banner =<<-END
+Usage: tweetwine [options...] [command]
+
+  Commands: #{Client::COMMANDS.join(", ")}
+
+  Options:
+
+      END
+      opt.on("-a", "--auth USERNAME:PASSWORD", "Authentication") do |arg|
+        options[:username], options[:password] = arg.split(":", 2)
+      end
+      opt.on("-c", "--colorize", "Colorize output with ANSI escape codes") do
+        options[:colorize] = true
+      end
+      opt.on("-n", "--num N", Integer, "The number of statuses to fetch, defaults to #{Client::DEFAULT_NUM_STATUSES}") do |arg|
+        options[:num_statuses] = arg
+      end
+      opt.on("--no-url-shorten", "Do not shorten URLs for status update") do
+        options[:shorten_urls] = { :enable => false }
+      end
+      opt.on("-p", "--page N", Integer, "The page number of the statuses to fetch, defaults to #{Client::DEFAULT_PAGE_NUM}") do |arg|
+        options[:page_num] = arg
+      end
+      opt.on("-v", "--version", "Show version information and exit") do
+        puts "#{File.basename($0)} #{Tweetwine::VERSION}"
+        exit(EXIT_VERSION)
+      end
+      opt.on_tail("-h", "--help", "Show this help message and exit") do
+        puts opt
+        exit(EXIT_HELP)
+      end
+    end.parse!(args)
+  rescue OptionParser::ParseError => e
+    raise ArgumentError, e.message
+  end
+  options
+end
+
+def create_dependencies(options)
+  io = Tweetwine::IO.new(options)
+  rest_client = RestClientWrapper.new(io)
+  url_shortener = lambda { |opts| UrlShortener.new(rest_client, opts) }
+  {
+    :io             => io,
+    :rest_client    => rest_client,
+    :url_shortener  => url_shortener
+  }
+end
+
+begin
+  config = StartupConfig.new(Client::COMMANDS)
+  config.parse(ARGV, ENV["HOME"] + "/.tweetwine", &cmd_parser)
+  client = Client.new(create_dependencies(config.options), config.options)
+  client.send(config.command, *config.args)
+rescue ArgumentError, ClientError => e
+  puts "Error: #{e.message}"
+  exit(EXIT_ERROR)
+end

data/lib/tweetwine/client.rb

@@ -0,0 +1,174 @@
+require "json"
+require "uri"
+
+module Tweetwine
+  class Client
+    attr_reader :num_statuses, :page_num
+
+    COMMANDS = [:home, :mentions, :user, :update, :friends, :followers]
+
+    DEFAULT_NUM_STATUSES = 20
+    DEFAULT_PAGE_NUM = 1
+    MAX_STATUS_LENGTH = 140
+
+    def initialize(dependencies, options)
+      @io = dependencies[:io]
+      @rest_client = dependencies[:rest_client]
+      @username = options[:username].to_s
+      raise ArgumentError, "No authentication data given" if @username.empty?
+      @base_url = "https://#{@username}:#{options[:password]}@twitter.com/"
+      @num_statuses = Util.parse_int_gt(options[:num_statuses], DEFAULT_NUM_STATUSES, 1, "number of statuses_to_show")
+      @page_num = Util.parse_int_gt(options[:page_num], DEFAULT_PAGE_NUM, 1, "page number")
+      @url_shortener = if options[:shorten_urls] && options[:shorten_urls][:enable]
+        dependencies[:url_shortener].call(options[:shorten_urls])
+      else
+        nil
+      end
+      @status_update_factory = StatusUpdateFactory.new(@io, @url_shortener)
+    end
+
+    def home
+      show_statuses(get_response_as_json("statuses/friends_timeline", :num_statuses, :page))
+    end
+
+    def mentions
+      show_statuses(get_response_as_json("statuses/mentions", :num_statuses, :page))
+    end
+
+    def user(user = @username)
+      show_statuses(get_response_as_json("statuses/user_timeline/#{user}", :num_statuses, :page))
+    end
+
+    def update(new_status = nil)
+      new_status = @status_update_factory.prepare(new_status)
+      completed = false
+      unless new_status.empty?
+        @io.show_status_preview(new_status)
+        if @io.confirm("Really send?")
+          status = JSON.parse(post("statuses/update.json", {:status => new_status.to_s}))
+          @io.info "Sent status update.\n\n"
+          show_statuses([status])
+          completed = true
+        end
+      end
+      @io.info "Cancelled." unless completed
+    end
+
+    def friends
+      show_users(get_response_as_json("statuses/friends/#{@username}", :page))
+    end
+
+    def followers
+      show_users(get_response_as_json("statuses/followers/#{@username}", :page))
+    end
+
+    private
+
+    def get_response_as_json(url_body, *query_opts)
+      url = url_body + ".json?#{parse_query_options(query_opts)}"
+      JSON.parse(get(url))
+    end
+
+    def parse_query_options(query_opts)
+      str = []
+      query_opts.each do |opt|
+        case opt
+        when :page
+          str << "page=#{@page_num}"
+        when :num_statuses
+          str << "count=#{@num_statuses}"
+        # do nothing on else
+        end
+      end
+      str.join("&")
+    end
+
+    def show_statuses(data)
+      show_responses(data) { |entry| [entry["user"], entry] }
+    end
+
+    def show_users(data)
+      show_responses(data) { |entry| [entry, entry["status"]] }
+    end
+
+    def show_responses(data)
+      data.each do |entry|
+        user_data, status_data = yield entry
+        @io.show_record(parse_response(user_data, status_data))
+      end
+    end
+
+    def parse_response(user_data, status_data)
+      record = { :user => user_data["screen_name"] }
+      if status_data
+        record[:status] = {
+          :created_at  => status_data["created_at"],
+          :in_reply_to => status_data["in_reply_to_screen_name"],
+          :text        => status_data["text"]
+        }
+      end
+      record
+    end
+
+    def get(body_url)
+      @rest_client.get @base_url + body_url
+    end
+
+    def post(body_url, body)
+      @rest_client.post @base_url + body_url, body
+    end
+
+    class StatusUpdateFactory
+      def initialize(io, url_shortener)
+        @io = io
+        @url_shortener = url_shortener
+      end
+
+      def prepare(status)
+        StatusUpdate.new(status, @io, @url_shortener).to_s
+      end
+    end
+
+    class StatusUpdate
+      def initialize(status, io, url_shortener)
+        @io = io
+        @url_shortener = url_shortener
+        @text = prepare(status)
+      end
+
+      def to_s
+        @text.to_s
+      end
+
+      private
+
+      def prepare(status)
+        status = unless status
+          @io.prompt("Status update")
+        else
+          status.dup
+        end
+        status.strip!
+        shorten_urls!(status) if @url_shortener
+        truncate!(status) if status.length > MAX_STATUS_LENGTH
+        status
+      end
+
+      def truncate!(status)
+        status.replace status[0...MAX_STATUS_LENGTH]
+        @io.warn("Status will be truncated.")
+      end
+
+      def shorten_urls!(status)
+        url_pairs = URI.extract(status, ["http", "https"]).uniq.map do |url_to_be_shortened|
+          [url_to_be_shortened, @url_shortener.shorten(url_to_be_shortened)]
+        end
+        url_pairs.reject { |pair| pair.last.nil? || pair.last.empty? }.each do |url_pair|
+          status.gsub!(url_pair.first, url_pair.last)
+        end
+      rescue ClientError, LoadError => e
+        @io.warn "#{e}. Skipping URL shortening..."
+      end
+    end
+  end
+end

data/lib/tweetwine/io.rb

@@ -0,0 +1,117 @@
+require "uri"
+
+module Tweetwine
+  class IO
+    COLOR_CODES = {
+      :cyan     => 36,
+      :green    => 32,
+      :magenta  => 35,
+      :yellow   => 33
+    }
+
+    HASHTAG_REGEX = /#[\w-]+/
+    USERNAME_REGEX = /@\w+/
+
+    def initialize(options)
+      @input = options[:input] || $stdin
+      @output = options[:output] || $stdout
+      @colorize = options[:colorize] || false
+    end
+
+    def prompt(prompt)
+      @output.print "#{prompt}: "
+      @input.gets.strip!
+    end
+
+    def info(msg)
+      @output.puts(msg)
+    end
+
+    def warn(msg)
+      @output.puts "Warning: #{msg}"
+    end
+
+    def confirm(msg)
+      @output.print "#{msg} [yN] "
+      confirmation = @input.gets.strip
+      confirmation.downcase[0,1] == "y"
+    end
+
+    def show_status_preview(status)
+      @output.puts <<-END
+
+#{format_status(status)}
+
+      END
+    end
+
+    def show_record(record)
+      if record[:status]
+        show_record_as_user_with_status(record)
+      else
+        show_record_as_user(record)
+      end
+    end
+
+    private
+
+    def show_record_as_user(record)
+      @output.puts <<-END
+#{format_user(record[:user])}
+
+      END
+    end
+
+    def show_record_as_user_with_status(record)
+      @output.puts <<-END
+#{format_record_header(record)}
+#{format_status(record[:status][:text])}
+
+      END
+    end
+
+    def format_user(user)
+      user = user.dup
+      colorize!(:green, user) if @colorize
+      user
+    end
+
+    def format_status(status)
+      status = status.dup
+      if @colorize
+        colorize_all!(:yellow, status, USERNAME_REGEX)
+        colorize_all!(:magenta, status, HASHTAG_REGEX)
+        URI.extract(status, ["http", "https"]).uniq.each do |url|
+          colorize_all!(:cyan, status, url)
+        end
+      end
+      status
+    end
+
+    def format_record_header(record)
+      time_diff_value, time_diff_unit = Util.humanize_time_diff(record[:status][:created_at], Time.now)
+      from_user = record[:user].dup
+      colorize!(:green, from_user) if @colorize
+      in_reply_to = record[:status][:in_reply_to]
+      in_reply_to = if in_reply_to && !in_reply_to.empty?
+        in_reply_to = colorize!(:green, in_reply_to.dup) if @colorize
+        "in reply to #{in_reply_to}, "
+      else
+        ""
+      end
+      "#{from_user}, #{in_reply_to}#{time_diff_value} #{time_diff_unit} ago:"
+    end
+
+    def colorize_all!(color, str, pattern)
+      str.gsub!(pattern) { |s| colorize_str(COLOR_CODES[color.to_sym], s) }
+    end
+
+    def colorize!(color, str)
+      str.replace colorize_str(COLOR_CODES[color.to_sym], str)
+    end
+
+    def colorize_str(color_code, str)
+      "\033[#{color_code}m#{str}\033[0m"
+    end
+  end
+end

data/lib/tweetwine/meta.rb

@@ -0,0 +1,3 @@
+module Tweetwine
+  VERSION = "0.2.4"
+end

data/lib/tweetwine/options.rb

@@ -0,0 +1,22 @@
+module Tweetwine
+  class Options
+    def initialize(options, source = nil)
+      @hash = options.to_hash
+      @source = source
+    end
+
+    def [](key)
+      @hash[key]
+    end
+
+    def require(key)
+      value = @hash[key]
+      if value.nil?
+        msg = "Option #{key} is required"
+        msg << " for #{@source}" if @source
+        raise ArgumentError, msg
+      end
+      value
+    end
+  end
+end