tuomas-tweetwine 0.1.1 → 0.1.2

data/CHANGELOG.rdoc

@@ -1,3 +1,9 @@
+=== 0.1.2 released 2009-05-04
+
+* Renamed command "friends" to "home".
+* Added command "mentions".
+* Improved command line argument and configuration file parsing.
+
 === 0.1.1 released 2009-04-23
 
 * Renamed command "msg" to "update".

data/README.rdoc

@@ -14,28 +14,29 @@ The program is compatible with Ruby 1.9.1.
 
 In the command line, run the program by entering
 
-  $ tweetwine [-a username:password] [command]
+  $ tweetwine [options...] [command]
 
 The program needs the user's username and password for authentication. This
-information can be supplied either as an option to the program or via a
-configuration file. Without option <tt>[-a]</tt>, the program attempts to
-read the configuration file for authentication.
+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 supported commands are
-
-<tt>friends</tt>:: Fetch friends' latest statuses (the contents of the user's home).
-<tt>user [name]</tt>:: Fetch a specific user's latest statuses, identified by the argument; if given no argument, fetch your own statuses.
-<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.
-
-If <tt>[command]</tt> is not given, it defaults to <tt>friends</tt>.
-
-The configuration file, in <tt>~/.tweetwine</tt>, is in YAML syntax. It can
-contain the following settings:
+The configuration file, in <tt>~/.tweetwine</tt>, is in YAML syntax. The
+program recognizes the following 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.
+
+If no <tt>[command]</tt> is given, the default action is <tt>home</tt>.
+
 For all the options, see:
 
   $ tweetwine -h

data/Rakefile

@@ -2,7 +2,7 @@ require "rubygems"
 
 full_name = "Tweetwine"
 package_name = "tweetwine"
-version = "0.1.1"
+version = "0.1.2"
 
 require "lib/#{package_name}"
 
@@ -20,7 +20,7 @@ spec = Gem::Specification.new do |s|
   s.email = "tkareine@gmail.com"
 
   s.platform = Gem::Platform::RUBY
-  s.files = FileList["Rakefile", "*.rdoc", "bin/**/*", "lib/**/*", "spec/**/*"].to_a
+  s.files = FileList["Rakefile", "*.rdoc", "bin/**/*", "lib/**/*", "test/**/*"].to_a
   s.executables = ["tweetwine"]
 
   s.add_dependency("json", ">= 1.1.4")
@@ -30,7 +30,7 @@ spec = Gem::Specification.new do |s|
   s.extra_rdoc_files = FileList["*.rdoc"].to_a
   s.rdoc_options << "--title"   << "#{full_name} #{version}" \
                  << "--main"    << "README.rdoc" \
-                 << "--exclude" << "spec" \
+                 << "--exclude" << "test" \
                  << "--line-numbers"
 end
 

data/bin/tweetwine

@@ -1,102 +1,48 @@
 #!/usr/bin/env ruby
 
 require "rubygems"
-require "getoptlong"
+require "optparse"
+
 require File.dirname(__FILE__) << "/../lib/tweetwine"
 
 include Tweetwine
 
-class HelpNeeded < StandardError; end
-class AlreadyReportedArgumentError < ArgumentError; end
-
-DEFAULT_OPTIONS = {
-  :colorize     => false,
-  :num_statuses => Client::MAX_NUM_STATUSES
-}
-
-def exit_with_error(why = nil)
-  puts "Error: #{why}" if why
-  exit(2)
-end
-
-def exit_with_usage(why = nil)
-  puts "#{why}\n\n" if why
-  puts <<-END
+begin
+  config = StartupConfig.new(Client::COMMANDS)
+  config.parse(ARGV, ENV["HOME"] + "/.tweetwine") do |args|
+    options = {}
+    begin
+      OptionParser.new do |opt|
+        opt.banner =<<-END
 Usage: tweetwine [options...] [command]
 
-  The program needs the user's username and password for authentication.
-  This information can be given either as an option to the program or via a
-  configuration file. Without option [-a], the program attempts to read the
-  configuration file in YAML format at "~/.tweetwine" for authentication.
-
-  Argument [command] can be one of #{Client::COMMANDS.map {|cmd| "\"#{cmd}\"" }.join(", ")}.
-  If [command] is not given, it defaults to "#{Client::COMMANDS[0]}".
+  Commands: #{Client::COMMANDS.join(", ")}
 
   Options:
 
-  -a, --auth <username>:<password>  Authentication data.
-  -c, --color                       Colorize output with ANSI escape codes.
-  -h, --help                        This help message.
-  -n, --num <num>                   The number of statuses to fetch,
-                                    defaults to #{DEFAULT_OPTIONS[:num_statuses]}.
-
-  END
-  exit(1)
-end
-
-def parse_args
-  options = DEFAULT_OPTIONS.dup
-
-  opts = GetoptLong.new(
-    [ "--auth",   "-a", GetoptLong::REQUIRED_ARGUMENT ],
-    [ "--color",  "-c", GetoptLong::NO_ARGUMENT ],
-    [ "--help",   "-h", GetoptLong::NO_ARGUMENT ],
-    [ "--num",    "-n", GetoptLong::REQUIRED_ARGUMENT ]
-  )
-
-  begin
-    opts.each do |opt, arg|
-      case opt
-      when "--auth"   then options[:username], options[:password] = arg.split(":", 2)
-      when "--color"  then options[:colorize] = true
-      when "--help"   then raise HelpNeeded
-      when "--num"
-        arg = arg.to_i
-        if (1..Client::MAX_NUM_STATUSES).include? arg
+        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
-        else
-          raise ArgumentError, "Invalid number of statuses to show -- must be between 1..#{Client::MAX_NUM_STATUSES}"
         end
-      end
-    end
-  rescue GetoptLong::InvalidOption, GetoptLong::MissingArgument
-    raise AlreadyReportedArgumentError
-  end
-
-  unless options[:username]
-    begin
-      config = Tweetwine::Config.load(ENV["HOME"] + "/.tweetwine")
-      options[:username], options[:password] = [config.username, config.password]
-      options[:colorize] = config.colorize if config.colorize?
-    rescue Exception => e
-      raise ArgumentError, "No auth info given as argument and no configuration file (~/.tweetwine) found."
+        opt.on_tail("-h", "--help", "Show this help message") do
+          puts opt
+          exit(1)
+        end
+      end.parse!(args)
+    rescue OptionParser::ParseError => e
+      raise ArgumentError.new(e)
     end
+    options
   end
-
-  command = if ARGV.empty? then Client::COMMANDS[0] else ARGV.shift end
-  raise ArgumentError, "Unknown command." unless Client::COMMANDS.include? command
-
-  [options, command, ARGV]
-end
-
-begin
-  options, command, args = parse_args
-  client = Client.new(options)
-  client.send(command.to_sym, *args)
-rescue HelpNeeded, AlreadyReportedArgumentError
-  exit_with_usage
-rescue ArgumentError => e
-  exit_with_usage e.message
-rescue ClientError => e
-  exit_with_error e.message
+  client = Client.new(config.options)
+  client.send(config.command, *config.args)
+rescue ArgumentError, ClientError => e
+  puts "Error: #{e.message}"
+  exit(2)
 end

data/lib/tweetwine.rb

@@ -1,3 +1,3 @@
-%w{util config io client}.each do |f|
+%w{util startup_config io client}.each do |f|
   require File.dirname(__FILE__) << "/tweetwine/#{f}"
 end

data/lib/tweetwine/client.rb

@@ -5,23 +5,39 @@ module Tweetwine
   class ClientError < RuntimeError; end
 
   class Client
-    COMMANDS = %w{friends user update}
+    attr_reader :num_statuses
 
-    MAX_NUM_STATUSES = 20
+    COMMANDS = [:home, :mentions, :user, :update]
+
+    DEFAULT_NUM_STATUSES = 20
+    MAX_NUM_STATUSES = 200
     MAX_STATUS_LENGTH = 140
 
     def initialize(options)
-      @username, password = options[:username].to_s, options[:password].to_s
-      @base_url = "https://#{@username}:#{password}@twitter.com/"
+      @username = options[:username].to_s
+      raise ArgumentError, "No authentication data given" if @username.empty?
+      @base_url = "https://#{@username}:#{options[:password]}@twitter.com/"
       @colorize = options[:colorize] || false
-      @num_statuses = options[:num_statuses] || MAX_NUM_STATUSES
+      @num_statuses = if options[:num_statuses]
+        if (1..MAX_NUM_STATUSES).include? options[:num_statuses]
+          options[:num_statuses]
+        else
+          raise ArgumentError, "Invalid number of statuses to show -- must be between 1..#{Client::MAX_NUM_STATUSES}"
+        end
+      else
+        DEFAULT_NUM_STATUSES
+      end
       @io = IO.new(options)
     end
 
-    def friends
+    def home
       @io.show_statuses JSON.parse(get("statuses/friends_timeline.json?count=#{@num_statuses}"))
     end
 
+    def mentions
+      @io.show_statuses JSON.parse(get("statuses/mentions.json?count=#{@num_statuses}"))
+    end
+
     def user(user = @username)
       @io.show_statuses JSON.parse(get("statuses/user_timeline/#{user}.json?count=#{@num_statuses}"))
     end

data/lib/tweetwine/io.rb

@@ -30,10 +30,17 @@ module Tweetwine
         time_diff_value, time_diff_unit = Util.humanize_time_diff(Time.now, status["created_at"])
         from_user = status["user"]["screen_name"]
         from_user = colorize(:green, from_user) if @colorize
+        in_reply_to = status["in_reply_to_screen_name"]
+        in_reply_to = if in_reply_to && !in_reply_to.empty?
+          in_reply_to = colorize(:green, in_reply_to) if @colorize
+          "in reply to #{in_reply_to}, "
+        else
+          ""
+        end
         text = status["text"]
         text = colorize(:red, text, /@\w+/) if @colorize
         @output.puts <<-END
-#{from_user}, #{time_diff_value} #{time_diff_unit} ago:
+#{from_user}, #{in_reply_to}#{time_diff_value} #{time_diff_unit} ago:
 #{text}
 
         END
@@ -44,8 +51,7 @@ module Tweetwine
 
     COLOR_CODES = {
       :green    => "\033[32m",
-      :red      => "\033[31m",
-      :neutral  => "\033[0m"
+      :red      => "\033[31m"
     }
 
     def colorize(color, str, matcher = nil)
@@ -59,7 +65,7 @@ module Tweetwine
     end
 
     def colorize_str(color_code, str)
-      "#{color_code}#{str}#{COLOR_CODES[:neutral]}"
+      "#{color_code}#{str}\033[0m"
     end
   end
 end

data/lib/tweetwine/startup_config.rb

@@ -0,0 +1,41 @@
+module Tweetwine
+  class StartupConfig
+    attr_reader :options, :command, :args, :supported_commands
+
+    def initialize(supported_commands)
+      @supported_commands = supported_commands.to_a
+      raise ArgumentError, "Must give at least one supported command" if @supported_commands.empty?
+      @options = {}
+      @command = @supported_commands.first
+      @args = []
+    end
+
+    def parse(args = [], config_file = nil, &cmd_parser)
+      options = parse_options(args, config_file, &cmd_parser)
+      command = if args.empty? then @supported_commands.first else args.shift.to_sym end
+      raise ArgumentError, "Unknown command." unless @supported_commands.include? command
+      @options, @command, @args = options, command, args
+      self
+    end
+
+    private
+
+    def parse_options(args, config_file, &cmd_parser)
+      cmd_options = if cmd_parser then parse_cmdline_args(args, &cmd_parser) else {} end
+      config_options = if config_file && File.exists?(config_file) then parse_config_file(config_file) else {} end
+      config_options.merge(cmd_options)
+    end
+
+    def parse_cmdline_args(args, &cmd_parser)
+      cmd_parser.call(args)
+    end
+
+    def parse_config_file(config_file)
+      options = YAML.load(File.read(config_file))
+      options.inject({}) do |result, pair|
+        result[pair.first.to_sym] = pair.last
+        result
+      end
+    end
+  end
+end

data/test/client_test.rb

@@ -0,0 +1,159 @@
+require File.dirname(__FILE__) << "/test_helper"
+require "json"
+
+module Tweetwine
+
+class ClientTest < Test::Unit::TestCase
+  context "Upon initializing a client" do
+    should "raise exception when no authentication data is given" do
+      assert_raises(ArgumentError) { Client.new({}) }
+      assert_raises(ArgumentError) { Client.new({ :password => "bar" }) }
+      assert_raises(ArgumentError) { Client.new({ :username => "", :password => "bar" }) }
+    end
+
+    should "use default num of statuses if not configured otherwise" do
+      @client = Client.new({ :username => "foo", :password => "bar" })
+      assert_equal Client::DEFAULT_NUM_STATUSES, @client.num_statuses
+    end
+
+    should "use configured num of statuses if in allowed range" do
+      @client = Client.new({ :username => "foo", :password => "bar", :num_statuses => 12 })
+      assert_equal 12, @client.num_statuses
+    end
+
+    should "raise an exception for configured num of statuses if not in allowed range" do
+      assert_raises(ArgumentError) { Client.new({ :username => "foo", :password => "bar", :num_statuses => Client::MAX_NUM_STATUSES + 1 }) }
+    end
+  end
+
+  context "A client" do
+    setup do
+      @client = Client.new({ :username => "foo", :password => "bar" })
+      @io = mock()
+      @client.instance_variable_set(:@io, @io)
+    end
+
+    should "raise ClientError for invalid request" do
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?count=20") \
+                .raises(RestClient::Unauthorized)
+      assert_raises(ClientError) { @client.home }
+    end
+
+    should "fetch friends' statuses (home view)" do
+      statuses = [
+        {
+          "created_at" => Time.at(1).to_s,
+          "user" => { "username" => "zanzibar" },
+          "text" => "wassup?"
+        },
+        {
+          "created_at" => Time.at(2).to_s,
+          "user" => { "username" => "lulzwoo" },
+          "text" => "nuttin"
+        }
+      ]
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/friends_timeline.json?count=20") \
+                .returns(statuses.to_json)
+      @io.expects(:show_statuses).with(statuses)
+      @client.home
+    end
+
+    should "fetch mentions" do
+      statuses = [
+        {
+          "created_at" => Time.at(1).to_s,
+          "in_reply_to_screen_name" => "foo",
+          "user" => { "username" => "zanzibar" },
+          "text" => "wassup, @foo?"
+        },
+        {
+          "created_at" => Time.at(2).to_s,
+          "in_reply_to_screen_name" => "foo",
+          "user" => { "username" => "lulzwoo" },
+          "text" => "@foo, doing nuttin"
+        }
+      ]
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/mentions.json?count=20") \
+                .returns(statuses.to_json)
+      @io.expects(:show_statuses).with(statuses)
+      @client.mentions
+    end
+
+    should "fetch a specific user's statuses, with the user identified by given argument" do
+      statuses = [
+        {
+          "created_at" => Time.at(1).to_s,
+          "user" => { "username" => "zanzibar" },
+          "text" => "wassup?"
+        }
+      ]
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/user_timeline/zanzibar.json?count=20") \
+                .returns(statuses.to_json)
+      @io.expects(:show_statuses).with(statuses)
+      @client.user("zanzibar")
+    end
+
+    should "fetch a specific user's statuses, with the user being the authenticated user itself when given no argument" do
+      statuses = [
+        {
+          "created_at" => Time.at(1).to_s,
+          "user" => { "username" => "foo" },
+          "text" => "wassup?"
+        }
+      ]
+      RestClient.expects(:get) \
+                .with("https://foo:bar@twitter.com/statuses/user_timeline/foo.json?count=20") \
+                .returns(statuses.to_json)
+      @io.expects(:show_statuses).with(statuses)
+      @client.user
+    end
+
+    should "post a status update, when positive confirmation" do
+      status = {
+        "created_at" => Time.at(1).to_s,
+        "user" => { "username" => "foo" },
+        "text" => "wondering about"
+      }
+      RestClient.expects(:post) \
+                .with("https://foo:bar@twitter.com/statuses/update.json", {:status => "wondering about"}) \
+                .returns(status.to_json)
+      @io.expects(:confirm).with("Really send?").returns(true)
+      @io.expects(:info).with("Sent status update.\n\n")
+      @io.expects(:show_statuses).with([status])
+      @client.update("wondering about")
+    end
+
+    should "cancel a status update, when negative confirmation" do
+      RestClient.expects(:post).never
+      @io.expects(:confirm).with("Really send?").returns(false)
+      @io.expects(:info).with("Cancelled.")
+      @io.expects(:show_statuses).never
+      @client.update("wondering about")
+    end
+
+    should "truncate a status update too long and warn the user" do
+      long_status_update = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 999 000"
+      truncated_status_update = "x aaa bbb ccc ddd eee fff ggg hhh iii jjj kkk lll mmm nnn ooo ppp qqq rrr sss ttt uuu vvv www xxx yyy zzz 111 222 333 444 555 666 777 888 99"
+      status = {
+        "created_at" => Time.at(1).to_s,
+        "user" => { "username" => "foo" },
+        "text" => truncated_status_update
+      }
+
+      RestClient.expects(:post) \
+                .with("https://foo:bar@twitter.com/statuses/update.json", {:status => truncated_status_update}) \
+                .returns(status.to_json)
+      @io.expects(:warn).with("Update will be truncated: #{truncated_status_update}")
+      @io.expects(:confirm).with("Really send?").returns(true)
+      @io.expects(:info).with("Sent status update.\n\n")
+      @io.expects(:show_statuses).with([status])
+      @client.update(long_status_update)
+    end
+  end
+end
+
+end

data/test/io_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+module Tweetwine
+
+class IOTest < Test::Unit::TestCase
+  context "An IO" do
+    setup do
+      @input = mock()
+      @output = mock()
+      @io = IO.new({ :input => @input, :output => @output })
+    end
+
+    should "output prompt and return input as trimmed" do
+      @output.expects(:print).with("The answer: ")
+      @input.expects(:gets).returns("  42 ")
+      assert_equal "42", @io.prompt("The answer")
+    end
+
+    should "output info message" do
+      @output.expects(:puts).with("foo")
+      @io.info("foo")
+    end
+
+    should "output warning message" do
+      @output.expects(:puts).with("Warning: monkey patching ahead")
+      @io.warn("monkey patching ahead")
+    end
+
+    should "confirm action, with positive answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("y")
+      assert_equal true, @io.confirm("Fire nukes?")
+    end
+
+    should "confirm action, with negative answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("n")
+      assert_equal false, @io.confirm("Fire nukes?")
+    end
+
+    should "confirm action, with default answer" do
+      @output.expects(:print).with("Fire nukes? [yN] ")
+      @input.expects(:gets).returns("")
+      assert_equal false, @io.confirm("Fire nukes?")
+    end
+  end
+
+  context "An IO, with colorization disabled" do
+    setup do
+      @input = mock()
+      @output = mock()
+      @io = IO.new({ :input => @input, :output => @output, :colorize => false })
+    end
+
+    should "print statuses without in-reply info" do
+      statuses = [
+        {
+          "created_at" => Time.at(1),
+          "user" => { "screen_name" => "fooman" },
+          "text" => "Hi, @barman! Lulz woo!"
+        }
+      ]
+      Util.expects(:humanize_time_diff).returns([2, "secs"])
+      @output.expects(:puts).with(<<-END
+fooman, 2 secs ago:
+Hi, @barman! Lulz woo!
+
+      END
+      )
+      @io.show_statuses(statuses)
+    end
+
+    should "print statuses with in-reply info" do
+      statuses = [
+        {
+          "created_at" => Time.at(1),
+          "in_reply_to_screen_name" => "barman",
+          "user" => { "screen_name" => "fooman" },
+          "text" => "Hi, @barman! Lulz woo!"
+        }
+      ]
+      Util.expects(:humanize_time_diff).returns([2, "secs"])
+      @output.expects(:puts).with(<<-END
+fooman, in reply to barman, 2 secs ago:
+Hi, @barman! Lulz woo!
+
+      END
+      )
+      @io.show_statuses(statuses)
+    end
+  end
+
+  context "An IO, with colorization enabled" do
+    setup do
+      @input = mock()
+      @output = mock()
+      @io = IO.new({ :input => @input, :output => @output, :colorize => true })
+    end
+
+    should "print statuses without in-reply info" do
+      statuses = [
+        {
+          "created_at" => Time.at(1),
+          "user" => { "screen_name" => "fooman" },
+          "text" => "Hi, @barman! Lulz woo!"
+        }
+      ]
+      Util.expects(:humanize_time_diff).returns([2, "secs"])
+      @output.expects(:puts).with(<<-END
+\033[32mfooman\033[0m, 2 secs ago:
+Hi, \033[31m@barman\033[0m! Lulz woo!
+
+      END
+      )
+      @io.show_statuses(statuses)
+    end
+
+    should "print statuses with in-reply info" do
+      statuses = [
+        {
+          "created_at" => Time.at(1),
+          "in_reply_to_screen_name" => "barman",
+          "user" => { "screen_name" => "fooman" },
+          "text" => "Hi, @barman! Lulz woo!"
+        }
+      ]
+      Util.expects(:humanize_time_diff).returns([2, "secs"])
+      @output.expects(:puts).with(<<-END
+\033[32mfooman\033[0m, in reply to \033[32mbarman\033[0m, 2 secs ago:
+Hi, \033[31m@barman\033[0m! Lulz woo!
+
+      END
+      )
+      @io.show_statuses(statuses)
+    end
+  end
+end
+
+end

data/test/startup_config_test.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) << "/test_helper"
+
+module Tweetwine
+
+class StartupConfigTest < Test::Unit::TestCase
+  TEST_CONFIG_FILE = File.dirname(__FILE__) << "/test_config.yaml"
+
+  context "To initialize a StartupConfig" do
+    should "require at least one supported command" do
+      assert_raise(ArgumentError) { StartupConfig.new([]) }
+      assert_nothing_raised { StartupConfig.new([:default_action]) }
+    end
+  end
+
+  context "An initialized StartupConfig" do
+    setup do
+      @config = StartupConfig.new([:default_action, :another_action])
+    end
+
+    should "use the first supported command as a default command when given no command as a cmdline argument" do
+      @config.parse
+      assert_equal :default_action, @config.command
+    end
+
+    context "when given no cmdline args and a config file" do
+      setup do
+        @config.parse([], TEST_CONFIG_FILE)
+      end
+
+      should "have the parsed option defined" do
+        assert_equal false, @config.options[:colorize]
+      end
+    end
+
+    context "when given cmdline args and no config file" do
+      setup do
+        @config.parse(%w{--opt foo}) do |args|
+          args.clear
+          {:opt => "foo"}
+        end
+      end
+
+      should "have the parsed option defined" do
+        assert_equal "foo", @config.options[:opt]
+      end
+    end
+
+    context "when given an option both as a cmdline option and in a config file" do
+      setup do
+        @config.parse(%w{--colorize}, TEST_CONFIG_FILE) do |args|
+          args.clear
+          {:colorize => true}
+        end
+      end
+
+      should "the command line option should override the config file option" do
+        assert_equal true, @config.options[:colorize]
+      end
+
+      should "have nil for an undefined option" do
+        assert_nil @config.options[:num_statuses]
+      end
+    end
+  end
+end
+
+end

data/test/test_config.yaml

@@ -0,0 +1,3 @@
+username: foo
+password: bar
+colorize: false

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+require File.dirname(__FILE__) << "/../lib/tweetwine"
+require "test/unit"
+require "shoulda"
+require "mocha"
+
+Mocha::Configuration.prevent(:stubbing_non_existent_method)

data/test/util_test.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) << "/test_helper"
+require "time"
+
+module Tweetwine
+
+class UtilTest < Test::Unit::TestCase
+  context "The module" do
+    should "humanize time difference" do
+      assert_equal [1,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 00:00:59").to_s, Time.parse("2009-01-01 00:01:00"))
+      assert_equal [0,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:00"))
+      assert_equal [1,  "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:01"))
+      assert_equal [59, "sec"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:59"))
+      assert_equal [59, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 01:59"))
+      assert_equal [59, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00:30").to_s, Time.parse("2009-01-01 01:59:00"))
+      assert_equal [57, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:00"))
+      assert_equal [56, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:31").to_s, Time.parse("2009-01-01 01:58:00"))
+      assert_equal [57, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:29"))
+      assert_equal [58, "min"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:30"))
+      assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 02:00"))
+      assert_equal [1,  "hour"],  Util.humanize_time_diff(Time.parse("2009-01-01 02:00").to_s, Time.parse("2009-01-01 01:00"))
+      assert_equal [2,  "hours"], Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 03:00"))
+      assert_equal [1,  "day"],   Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-02 03:00"))
+      assert_equal [2,  "days"],  Util.humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-03 03:00"))
+    end
+  end
+end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: tuomas-tweetwine
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors: 
 - Tuomas Kareinen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-23 00:00:00 -07:00
+date: 2009-05-04 00:00:00 -07:00
 default_executable: tweetwine
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,20 +48,26 @@ files:
 - bin/tweetwine
 - lib/tweetwine
 - lib/tweetwine/client.rb
-- lib/tweetwine/config.rb
 - lib/tweetwine/io.rb
+- lib/tweetwine/startup_config.rb
 - lib/tweetwine/util.rb
 - lib/tweetwine.rb
+- test/client_test.rb
+- test/io_test.rb
+- test/startup_config_test.rb
+- test/test_config.yaml
+- test/test_helper.rb
+- test/util_test.rb
 has_rdoc: true
 homepage: http://github.com/tuomas/tweetwine
 post_install_message: 
 rdoc_options: 
 - --title
-- Tweetwine 0.1.1
+- Tweetwine 0.1.2
 - --main
 - README.rdoc
 - --exclude
-- spec
+- test
 - --line-numbers
 require_paths: 
 - lib

data/lib/tweetwine/config.rb

@@ -1,25 +0,0 @@
-require "yaml"
-
-module Tweetwine
-  class Config
-    def self.load(file)
-      new(file)
-    end
-
-    private_class_method :new
-
-    def initialize(file)
-      @config = YAML.load(File.read(file))
-    end
-
-    def method_missing(sym)
-      key = sym.to_s
-      if key[-1,1] == "?"
-        result = @config.has_key? key[0...-1]
-      else
-        result = @config[key]
-      end
-      result
-    end
-  end
-end