tweetwine 0.4.0 → 0.4.1

data/.gitignore

@@ -4,3 +4,4 @@
 /coverage/
 /man/
 !/man/*.ronn
+/rdoc/

data/CHANGELOG.rdoc

@@ -1,3 +1,8 @@
+=== 0.4.1 released 2011-03-23
+
+* Handle socket errors just like connection errors
+* Minor cleanups
+
 === 0.4.0 released 2011-02-22
 
 * Add option <tt>-r</tt> to reverse the order of showing tweets

data/Rakefile

@@ -1,51 +1,51 @@
 # coding: utf-8
 
-require 'rake/clean'
+require File.expand_path('project', File.dirname(__FILE__))
 
-$LOAD_PATH.unshift(File.expand_path('lib', File.dirname(__FILE__)))
-name = 'tweetwine'
-require "#{name}/version"
-version = Tweetwine.version
+require 'rake/clean'
 
 namespace :gem do
-  CLOBBER.include "#{name}-*.gem"
+  CLOBBER.include "#{Project.name}-*.gem"
 
-  file "#{name}-#{version}.gem" do |f|
-    sh %{gem build #{name}.gemspec}
+  current_gem = "#{Project.name}-#{Project.version}.gem"
+
+  file current_gem do |f|
+    sh %{gem build #{Project.name}.gemspec}
   end
 
   desc "Package the software as a gem"
-  task :build => [:"man:build", :"test:all", "#{name}-#{version}.gem"]
+  task :build => [:"man:build", :"test:all", current_gem]
 
   desc "Install the software as a gem"
   task :install => :build do
-    sh %{gem install #{name}-#{version}.gem}
+    sh %{gem install #{current_gem}}
   end
 
   desc "Uninstall the gem"
   task :uninstall => :clean do
-    sh %{gem uninstall #{name}}
+    sh %{gem uninstall #{Project.name}}
   end
 end
 
 namespace :man do
-  CLOBBER.include "man/#{name}.?", "man/#{name}.?.html"
+  CLOBBER.include "#{Project.dirs.man}/#{Project.name}.?", "#{Project.dirs.man}/#{Project.name}.?.html"
 
   desc "Build the manual"
   task :build do
-    sh "ronn -br5 --manual='#{name.capitalize} Manual' --organization='Tuomas Kareinen' man/*.ronn"
+    sh %{ronn -br5 --manual='#{Project.name.capitalize} Manual' --organization='#{Project.authors.first}' #{Project.dirs.man}/*.ronn}
   end
 
   desc "Show the manual section 7"
   task :show => :build do
-    sh "man man/#{name}.7"
+    sh %{man #{Project.dirs.man}/#{Project.name}.7}
   end
 end
 
-CLOBBER.include 'rdoc'
+CLOBBER.include Project.dirs.rdoc
+
 desc "Generate RDoc"
 task :rdoc do
-  sh %{rdoc --encoding=UTF-8 --line-numbers --title='#{name} #{version}' --output=rdoc *.rdoc LICENSE.txt lib}
+  sh %{rdoc --encoding=UTF-8 --line-numbers --title='#{Project.title}' --output=#{Project.dirs.rdoc} *.rdoc LICENSE.txt lib}
 end
 
 namespace :test do
@@ -53,7 +53,7 @@ namespace :test do
     base_dir  = options[:base_dir]
     file_glob = options[:file_glob]
     test_desc = options[:desc] || "Run #{type} tests"
-    includes  = ['lib', 'test', base_dir].map { |dir| "-I #{dir}" }.join(' ')
+    includes  = ['lib', Project.dirs.test, base_dir].map { |dir| "-I #{dir}" }.join(' ')
     warn_opt  = options[:warn] ? '-w' : ''
 
     desc test_desc
@@ -68,11 +68,11 @@ namespace :test do
   end
 
   create_test_task :unit,
-      :base_dir   => 'test/unit',
+      :base_dir   => "#{Project.dirs.test}/unit",
       :file_glob  => '**/*_test.rb',
       :warn       => true
   create_test_task :example,
-      :base_dir   => 'test/example',
+      :base_dir   => "#{Project.dirs.test}/example",
       :file_glob  => '**/*_example.rb',
       :desc       => 'Run integration/example tests',
       :warn       => false

data/lib/tweetwine/http.rb

@@ -80,12 +80,10 @@ module Tweetwine
         response = yield connection, uri
         raise HttpError.new(response.code, response.message) unless response.is_a? Net::HTTPSuccess
         response.body
-      rescue Errno::ECONNABORTED, Errno::ECONNRESET => e
+      rescue Errno::ECONNABORTED, Errno::ECONNRESET, SocketError => e
         raise ConnectionError, e
       rescue Timeout::Error => e
         raise TimeoutError, e
-      rescue Net::HTTPError => e
-        raise HttpError, e
       end
 
       def https_scheme?(uri)

data/lib/tweetwine/ui.rb

@@ -10,6 +10,7 @@ module Tweetwine
     }.freeze
     HASHTAG_REGEX = /#[\w-]+/
     USERNAME_REGEX = /^(@\w+)|\s+(@\w+)/
+    URI_SCHEMES_TO_COLORIZE = %w{http https}
 
     def initialize(options = {})
       @in       = options[:in]            || $stdin
@@ -96,7 +97,7 @@ module Tweetwine
       if @colors
         status = colorize_matching(:yellow,   status, USERNAME_REGEX)
         status = colorize_matching(:magenta,  status, HASHTAG_REGEX)
-        status = colorize_matching(:cyan,     status, Uri.extract(status, %w{http https}).uniq)
+        status = colorize_matching(:cyan,     status, Uri.extract(status, URI_SCHEMES_TO_COLORIZE).uniq)
       end
       status
     end

data/lib/tweetwine/version.rb

@@ -1,7 +1,7 @@
 # coding: utf-8
 
 module Tweetwine
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.4.1'.freeze
 
   class << self
     def version

data/project.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+require 'ostruct'
+
+name = 'tweetwine'
+$LOAD_PATH.unshift File.expand_path('lib', File.dirname(__FILE__))
+require "#{name}/version"
+
+Project = OpenStruct.new({
+  :name         => name,
+  :version      => Tweetwine.version.dup,
+  :summary      => Tweetwine.summary,
+  :description  => '',
+  :email        => 'tkareine@gmail.com',
+  :homepage     => 'https://github.com/tkareine/tweetwine',
+  :authors      => ['Tuomas Kareinen'],
+  :dirs         => OpenStruct.new({
+    :man  => 'man',
+    :rdoc => 'rdoc',
+    :test => 'test'
+  }).freeze
+})
+
+Project.description = <<-END
+A simple but tasty Twitter agent for command line use, designed for quickly
+showing the latest tweets.
+  END
+Project.title = "#{Project.name} #{Project.version}"
+
+Project.freeze

data/test/unit/config_test.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require "test_helper"
+require "unit_helper"
 
 require "fileutils"
 require "tempfile"
@@ -190,10 +190,7 @@ class ConfigTest < UnitTestCase
       end
 
       should "ignore nonexisting config file for initial read" do
-        assert_contains_exactly(@default_config.keys, @config.keys) do |a, b|
-          # On Ruby 1.8, Symbol does not have #<=> operator for comparison.
-          a.to_s <=> b.to_s
-        end
+        assert_contains_exactly @default_config.keys, @config.keys
       end
 
       should "save config to the file, implicitly without config file, env lookouts, and excludes set itself" do

data/test/unit/http_test.rb

@@ -79,17 +79,18 @@ class HttpTest < UnitTestCase
     end
 
     [
-      [Errno::ECONNABORTED, 'abort'],
-      [Errno::ECONNRESET,   'reset']
-    ].each do |error, desc|
-      should "retry connection upon connection #{desc} to #{method} request" do
+      [Errno::ECONNABORTED, 'connection abort'],
+      [Errno::ECONNRESET,   'connection reset'],
+      [SocketError,         'socket error']
+    ].each do |(error, desc)|
+      should "retry connection upon #{desc} to #{method} request" do
         stub_request(method, LATEST_ARTICLES_URL).to_raise(error).then.to_return(:body => RESPONSE_BODY)
         @ui.expects(:warn).with("Could not connect -- retrying in 4 seconds")
         @client.send(method, LATEST_ARTICLES_URL)
         assert_equal(RESPONSE_BODY, @client.send(method, LATEST_ARTICLES_URL))
       end
 
-      should "retry connection a maximum of certain number of times upon connection #{desc} to #{method} request" do
+      should "retry connection a maximum of certain number of times upon #{desc} to #{method} request" do
         stub_request(method, LATEST_ARTICLES_URL).to_raise(error)
         io_calls = sequence("IO")
         Http::Client::MAX_RETRIES.times { @ui.expects(:warn).in_sequence(io_calls) }

data/test/unit/promise_test.rb

@@ -48,6 +48,8 @@ class PromiseTest < UnitTestCase
     assert_equal(@result.to_s, @promise.to_s)
   end
 
+  private
+
   def eval_action
     @promise * 42   # just do something with it
   end

data/test/unit/support_test.rb

@@ -16,28 +16,28 @@ class SupportTest < UnitTestCase
       ["foo",   false,  "nonempty string"],
       [[],      true,   "empty array"],
       [%w{a b}, false,  "nonempty array"]
-    ].each do |(subject, emptiness, description)|
-      should "return #{emptiness} for blank? with #{description}" do
+    ].each do |(subject, emptiness, desc)|
+      should "return #{emptiness} for blank? with #{desc}" do
         assert_equal emptiness, blank?(subject)
       end
 
-      should "return #{!emptiness} for present? with #{description}" do
+      should "return #{!emptiness} for present? with #{desc}" do
         assert_equal !emptiness, present?(subject)
       end
 
-      should "return non-empty subject for presence, when subject is #{description}" do
+      should "return non-empty subject for presence, when subject is #{desc}" do
         actual = presence(subject)
         expected = present?(subject) ? subject : nil
         assert_same expected, actual
       end
 
-      should "return value of block for presence, when subject is #{description}" do
+      should "return value of block for presence, when subject is #{desc}" do
         actual = presence(subject) { |s| s.size }
         expected = present?(subject) ? subject.size : nil
         assert_same expected, actual
       end
 
-      should "allow presence to be used with || operator, when subject is #{description}" do
+      should "allow presence to be used with || operator, when subject is #{desc}" do
         alternative = "hey"
         actual = presence(subject) || alternative
         expected = present?(subject) ? subject : alternative
@@ -47,31 +47,66 @@ class SupportTest < UnitTestCase
   end
 
   context "for humanizing time differences" do
+    should "accept string and time arguments" do
+      start = '2009-01-01 01:01:00'
+      stop  = Time.parse '2009-01-01 01:03:00'
+      assert_commutative([2, 'min'], [start, stop]) do |a, b|
+        humanize_time_diff(a, b)
+      end
+    end
+
     should "use second granularity for time differences smaller than a minute" do
-      assert_equal [1,  "sec"], 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"], 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"], 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"], humanize_time_diff(Time.parse("2009-01-01 01:00:00").to_s, Time.parse("2009-01-01 01:00:59"))
+      [
+        [0,   '2009-01-01 01:00:00', '2009-01-01 01:00:00'],
+        [1,   '2009-01-01 00:00:59', '2009-01-01 00:01:00'],
+        [1,   '2009-01-01 01:00:00', '2009-01-01 01:00:01'],
+        [59,  '2009-01-01 01:00:00', '2009-01-01 01:00:59']
+      ].each do |(diff, start, stop)|
+        assert_commutative([diff, 'sec'], [start, stop]) do |a, b|
+          humanize_time_diff(a, b)
+        end
+      end
     end
 
     should "use minute granularity for time differences greater than a minute but smaller than an hour" do
-      assert_equal [59, "min"], humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 01:59"))
-      assert_equal [59, "min"], 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"], 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"], 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"], 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"], humanize_time_diff(Time.parse("2009-01-01 01:01:00").to_s, Time.parse("2009-01-01 01:58:30"))
+      [
+        [1,   '2009-01-01 01:00:00', '2009-01-01 01:01:00'],
+        [2,   '2009-01-01 01:01:00', '2009-01-01 01:03:29'],
+        [3,   '2009-01-01 01:01:00', '2009-01-01 01:03:30'],
+        [59,  '2009-01-01 01:00:00', '2009-01-01 01:59:00'],
+        [59,  '2009-01-01 01:00:30', '2009-01-01 01:59:00'],
+        [57,  '2009-01-01 01:01:00', '2009-01-01 01:58:00']
+      ].each do |(diff, start, stop)|
+        assert_commutative([diff, 'min'], [start, stop]) do |a, b|
+          humanize_time_diff(a, b)
+        end
+      end
     end
 
     should "use hour granularity for time differences greater than an hour but smaller than a day" do
-      assert_equal [1,  "hour"],  humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 02:00"))
-      assert_equal [1,  "hour"],  humanize_time_diff(Time.parse("2009-01-01 02:00").to_s, Time.parse("2009-01-01 01:00"))
-      assert_equal [2,  "hours"], humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-01 03:00"))
+      [
+        [1, 'hour',   '2009-01-01 01:00', '2009-01-01 02:00'],
+        [2, 'hours',  '2009-01-01 01:00', '2009-01-01 03:00'],
+        [2, 'hours',  '2009-01-01 01:00', '2009-01-01 03:29'],
+        [3, 'hours',  '2009-01-01 01:00', '2009-01-01 03:30']
+      ].each do |(diff, unit, start, stop)|
+        assert_commutative([diff, unit], [start, stop]) do |a, b|
+          humanize_time_diff(a, b)
+        end
+      end
     end
 
     should "use day granularity for time differences greater than a day" do
-      assert_equal [1,  "day"],  humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-02 03:00"))
-      assert_equal [2,  "days"], humanize_time_diff(Time.parse("2009-01-01 01:00").to_s, Time.parse("2009-01-03 03:00"))
+      [
+        [1, 'day',    '2009-01-01 01:00', '2009-01-02 01:00'],
+        [2, 'days',   '2009-01-01 01:00', '2009-01-03 01:00'],
+        [2, 'days',   '2009-01-01 01:00', '2009-01-03 12:59'],
+        [3, 'days',   '2009-01-01 01:00', '2009-01-03 13:00']
+      ].each do |(diff, unit, start, stop)|
+        assert_commutative([diff, unit], [start, stop]) do |a, b|
+          humanize_time_diff(a, b)
+        end
+      end
     end
   end
 
@@ -194,7 +229,7 @@ class SupportTest < UnitTestCase
       %w{- dash},
       %w{_ underscore},
       %w{+ plus}
-    ].each do |char, desc|
+    ].each do |(char, desc)|
       should "not affect already unescaped characters, case #{desc}" do
         assert_equal char, unescape_html(char)
       end
@@ -206,7 +241,7 @@ class SupportTest < UnitTestCase
       %w{&amp;  &},
       %w{&quot; "},
       %W{&nbsp; \ }
-    ].each do |input, expected|
+    ].each do |(input, expected)|
       should "unescape HTML-escaped characters, case '#{input}'" do
         assert_equal expected, unescape_html(input)
       end
@@ -228,12 +263,12 @@ class SupportTest < UnitTestCase
     end
 
     should "support both a non-array and a single element array path for finding the value" do
-      assert_equal "beautiful", find_hash_path(@outer_hash, :simple)
-      assert_equal "beautiful", find_hash_path(@outer_hash, [:simple])
+      assert_equal @outer_hash[:simple], find_hash_path(@outer_hash, :simple)
+      assert_equal @outer_hash[:simple], find_hash_path(@outer_hash, [:simple])
     end
 
     should "find a nested value with an array path" do
-      assert_equal "slick", find_hash_path(@outer_hash, [:inner, :salmon])
+      assert_equal @inner_hash[:salmon], find_hash_path(@outer_hash, [:inner, :salmon])
     end
 
     should "return the default value of the hash if the value cannot be found" do
@@ -243,15 +278,19 @@ class SupportTest < UnitTestCase
     end
 
     should "return the default value of the hash if invalid path value" do
-      assert_equal @outer_hash.default, find_hash_path(@outer_hash, nil)
-      assert_equal @outer_hash.default, find_hash_path(@outer_hash, [:no_such, nil])
-      assert_equal @outer_hash.default, find_hash_path(@outer_hash, [:simple, nil])
-      assert_equal @outer_hash.default, find_hash_path(@outer_hash, [:inner, nil])
-      assert_equal @outer_hash.default, find_hash_path(@outer_hash, [:inner, :salmon, nil])
+      [
+        nil,
+        [:no_such, nil],
+        [:simple, nil],
+        [:inner, nil],
+        [:inner, :salmon, nil]
+      ].each do |path|
+        assert_equal @outer_hash.default, find_hash_path(@outer_hash, path)
+      end
     end
 
     should "return nil if nil hash value" do
-      assert_equal nil, find_hash_path(nil, nil)
+      assert_equal nil, find_hash_path(nil, [:salmon])
     end
   end
 end

data/test/unit/tweet_helper.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'timecop'
+
 module Tweetwine::Test
   module TweetHelper
     FIELD_PATHS = {
@@ -10,11 +12,13 @@ module Tweetwine::Test
       :status     => %w{status text}
     }.freeze
 
+    DEFAULT_TIMESTAMP = Time.utc(2011, 'feb', 17, 22, 28, 0)
+
     DEFAULT_FIELD_VALUES = {
       :from_user  => 'fred',
       :to_user    => nil,
       :retweet    => nil,
-      :created_at => Time.utc(2011, 'feb', 17, 22, 28, 0).iso8601,
+      :created_at => DEFAULT_TIMESTAMP.iso8601,
       :status     => nil
     }.freeze
 
@@ -38,6 +42,14 @@ module Tweetwine::Test
       Tweetwine::Tweet.new(create_record(fields), FIELD_PATHS)
     end
 
+    def at_default_time(&block)
+      Timecop.freeze(TweetHelper::DEFAULT_TIMESTAMP, &block)
+    end
+
+    def create_timestamp(minus_seconds)
+      (TweetHelper::DEFAULT_TIMESTAMP - minus_seconds).iso8601
+    end
+
     private
 
     def find_hash_of_field_path(hash, path)

data/test/unit/tweet_test.rb

@@ -14,7 +14,7 @@ class TweetTest < UnitTestCase
     end
   end
 
-  context "for equivalence" do
+  context "for equality" do
     should "equal to another tweet with same content" do
       status = 'foo'
       first  = create_tweet(:status => status)

data/test/unit/ui_test.rb

@@ -86,18 +86,19 @@ class UITest < UnitTestCase
       should "output regular tweet" do
         from_user = "fooman"
         status = "Hi, @barman! Lulz woo! #hellos"
+        time = 2
         tweet = create_tweet(
           :from_user  => from_user,
-          :status     => status
+          :status     => status,
+          :created_at => create_timestamp(time)
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-#{from_user}, 2 secs ago:
+#{from_user}, #{time} sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output replying tweet" do
@@ -109,14 +110,13 @@ class UITest < UnitTestCase
           :status     => status,
           :to_user    => to_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-#{from_user}, in reply to #{to_user}, 2 secs ago:
+#{from_user}, in reply to #{to_user}, 0 sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output regular retweet" do
@@ -128,14 +128,13 @@ class UITest < UnitTestCase
           :status     => status,
           :rt_user    => rt_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-#{rt_user} RT #{from_user}, 2 secs ago:
+#{rt_user} RT #{from_user}, 0 sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output replying retweet" do
@@ -149,14 +148,13 @@ class UITest < UnitTestCase
           :status     => status,
           :rt_user    => rt_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-#{rt_user} RT #{from_user}, in reply to #{to_user}, 2 secs ago:
+#{rt_user} RT #{from_user}, in reply to #{to_user}, 0 sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "unescape HTML in a status" do
@@ -167,14 +165,13 @@ class UITest < UnitTestCase
           :from_user  => from_user,
           :status     => escaped_status
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-#{from_user}, 2 secs ago:
+#{from_user}, 0 sec ago:
 #{unescaped_status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output a preview of a status" do
@@ -212,14 +209,13 @@ class UITest < UnitTestCase
           :from_user  => from_user,
           :status     => status
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output replying tweet" do
@@ -230,14 +226,13 @@ class UITest < UnitTestCase
           :status     => "@#{to_user}! How are you doing?",
           :to_user    => to_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, in reply to \e[32m#{to_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, in reply to \e[32m#{to_user}\e[0m, 0 sec ago:
 \e[33m@#{to_user}\e[0m! How are you doing?
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output regular retweet" do
@@ -249,14 +244,13 @@ class UITest < UnitTestCase
           :status     => status,
           :rt_user    => rt_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{rt_user}\e[0m RT \e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{rt_user}\e[0m RT \e[32m#{from_user}\e[0m, 0 sec ago:
 #{status}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output replying retweet" do
@@ -269,14 +263,13 @@ class UITest < UnitTestCase
           :status     => "@#{to_user}, reply worth retweeting",
           :rt_user    => rt_user
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{rt_user}\e[0m RT \e[32m#{from_user}\e[0m, in reply to \e[32m#{to_user}\e[0m, 2 secs ago:
+\e[32m#{rt_user}\e[0m RT \e[32m#{from_user}\e[0m, in reply to \e[32m#{to_user}\e[0m, 0 sec ago:
 \e[33m@#{to_user}\e[0m, reply worth retweeting
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "output a preview of a status" do
@@ -297,14 +290,13 @@ class UITest < UnitTestCase
           :from_user  => from_user,
           :status     => "Lulz, so happy! #{hashtags[0]} #{hashtags[1]}"
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 Lulz, so happy! \e[35m#{hashtags[0]}\e[0m \e[35m#{hashtags[1]}\e[0m
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       %w{http://is.gd/1qLk3 http://is.gd/1qLk3?id=foo}.each do |url|
@@ -314,14 +306,13 @@ Lulz, so happy! \e[35m#{hashtags[0]}\e[0m \e[35m#{hashtags[1]}\e[0m
             :from_user  => from_user,
             :status     => "New Rails³ - #{url}"
           )
-          Support.expects(:humanize_time_diff).returns([2, "secs"])
           @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 New Rails³ - \e[36m#{url}\e[0m
 
           END
           )
-          @ui.show_tweet(tweet)
+          show_tweet_at_default_time(tweet)
         end
       end
 
@@ -335,14 +326,13 @@ New Rails³ - \e[36m#{url}\e[0m
             :from_user  => from_user,
             :status     => "Links: #{first_url} and #{second_url} np"
           )
-          Support.expects(:humanize_time_diff).returns([2, "secs"])
           @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 Links: \e[36m#{first_url}\e[0m and \e[36m#{second_url}\e[0m np
 
           END
           )
-          @ui.show_tweet(tweet)
+          show_tweet_at_default_time(tweet)
         end
       end
 
@@ -353,14 +343,13 @@ Links: \e[36m#{first_url}\e[0m and \e[36m#{second_url}\e[0m np
           :from_user  => from_user,
           :status     => "I salute you #{users[0]}, #{users[1]}, and #{users[2]}!"
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 I salute you \e[33m#{users[0]}\e[0m, \e[33m#{users[1]}\e[0m, and \e[33m#{users[2]}\e[0m!
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
 
       should "not highlight email addresses as usernames in a status" do
@@ -371,86 +360,118 @@ I salute you \e[33m#{users[0]}\e[0m, \e[33m#{users[1]}\e[0m, and \e[33m#{users[2
           :from_user  => from_user,
           :status     => "Hi, #{users[0]}! You should notify #{users[1]}, #{email}"
         )
-        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
-\e[32m#{from_user}\e[0m, 2 secs ago:
+\e[32m#{from_user}\e[0m, 0 sec ago:
 Hi, \e[33m#{users[0]}\e[0m! You should notify \e[33m#{users[1]}\e[0m, #{email}
 
         END
         )
-        @ui.show_tweet(tweet)
+        show_tweet_at_default_time(tweet)
       end
     end
 
     context "for outputting a collection of tweets" do
       setup do
-        @users = %w{first_user second_user}
-        statuses = @users.map { |from| "Hi, I'm #{from}." }
-        @users_and_statuses = @users.zip statuses
-        @outputs = @users_and_statuses.map { |(user, status)| <<-END
-#{user}, 2 secs ago:
+        users_and_times = [
+          ['first',  11],
+          ['second', 12],
+          ['third',  13]
+        ]
+        statuses = users_and_times.map { |(user, _)| "Hi, I'm #{user}." }
+        users_and_statuses = users_and_times.zip(statuses)
+        @outputs = Hash[users_and_statuses.map { |(user, time), status|
+          output = <<-END
+#{user}, #{time} sec ago:
 #{status}
 
-        END
-        }
-        @tweets = @users_and_statuses.map { |(user, status)| create_tweet(
-          :from_user => user,
-          :status    => status
+          END
+          [user.to_sym, output]
+        }]
+        @tweets = users_and_statuses.map { |(user, time), status| create_tweet(
+          :from_user  => user,
+          :status     => status,
+          :created_at => create_timestamp(time)
         )}
-        Support.expects(:humanize_time_diff).twice.returns([2, "secs"])
       end
 
-      should "output tweets in descending order" do
-        ui = UI.new({ :out => @out, :show_reverse => false })
-        @out.expects(:puts).with(@outputs[0])
-        @out.expects(:puts).with(@outputs[1])
-        ui.show_tweets(@tweets)
+      should "output tweets in normal order" do
+        @ui = UI.new({ :out => @out, :show_reverse => false })
+        [:first, :second, :third].each do |user|
+          @out.expects(:puts).with(@outputs[user])
+        end
+        show_tweets_at_default_time(@tweets)
       end
 
-      should "output tweets in ascending order" do
-        ui = UI.new({ :out => @out, :show_reverse => true })
-        @out.expects(:puts).with(@outputs[1])
-        @out.expects(:puts).with(@outputs[0])
-        ui.show_tweets(@tweets)
+      should "output tweets in reverse order" do
+        @ui = UI.new({ :out => @out, :show_reverse => true })
+        [:third, :second, :first].each do |user|
+          @out.expects(:puts).with(@outputs[user])
+        end
+        show_tweets_at_default_time(@tweets)
       end
     end
   end
 
   context "username regex" do
-    should "match a proper username reference" do
-      assert_full_match UI::USERNAME_REGEX, "@nick"
-      assert_full_match UI::USERNAME_REGEX, "@nick_man"
-      assert_full_match UI::USERNAME_REGEX, "@nick"
-      assert_full_match UI::USERNAME_REGEX, " @nick"
+    [
+      ['@nick',     'normal'],
+      ['@nick_man', 'underscore separated'],
+      [' @nick',    'beginning with space']
+    ].each do |(nick, desc)|
+      should "match proper username reference, case #{desc}" do
+        assert_full_match UI::USERNAME_REGEX, nick
+      end
     end
 
-    should "not match an inproper username reference" do
-      assert_no_full_match UI::USERNAME_REGEX, "@"
-      assert_no_full_match UI::USERNAME_REGEX, "nick"
-      assert_no_full_match UI::USERNAME_REGEX, "-@nick"
-      assert_no_full_match UI::USERNAME_REGEX, "@nick-man"
-      assert_no_full_match UI::USERNAME_REGEX, "@nick "
-      assert_no_full_match UI::USERNAME_REGEX, " @nick "
-      assert_no_full_match UI::USERNAME_REGEX, "man @nick"
-      assert_no_full_match UI::USERNAME_REGEX, "man@nick"
+    [
+      ['@',         'just prefix'],
+      ['nick',      'just body'],
+      ['-@nick',    'beginning with dash'],
+      ['@nick-man', 'dash separated'],
+      ['@nick ',    'ending with space'],
+      [' @nick ',   'surrounded with space'],
+      ['man @nick', 'space separated'],
+      ['man@nick',  'prefix in between']
+    ].each do |(no_nick, desc)|
+      should "not match an inproper username reference, case #{desc}" do
+        assert_no_full_match UI::USERNAME_REGEX, no_nick
+      end
     end
   end
 
   context "hashtag regex" do
-    should "match a proper hashtag reference" do
-      assert_full_match UI::HASHTAG_REGEX, "#mayhem"
-      assert_full_match UI::HASHTAG_REGEX, "#friday_mayhem"
-      assert_full_match UI::HASHTAG_REGEX, "#friday-mayhem"
+    [
+      ['#mayhem',         'normal'],
+      ['#friday_mayhem',  'underscore separated'],
+      ['#friday-mayhem',  'dash separated']
+    ].each do |(hashtag, desc)|
+      should "match a proper hashtag reference, case #{desc}" do
+        assert_full_match UI::HASHTAG_REGEX, hashtag
+      end
     end
 
-    should "not match an inproper hashtag reference" do
-      assert_no_full_match UI::USERNAME_REGEX, "#"
-      assert_no_full_match UI::USERNAME_REGEX, "mayhem"
-      assert_no_full_match UI::USERNAME_REGEX, " #mayhem"
-      assert_no_full_match UI::USERNAME_REGEX, "#mayhem "
-      assert_no_full_match UI::USERNAME_REGEX, " #mayhem "
+    [
+      ['#',         'just prefix'],
+      ['mayhem',    'just body'],
+      [' #mayhem',  'beginning with space'],
+      ['#mayhem ',  'ending with space'],
+      [' #mayhem ', 'surrounded with space']
+    ].each do |(no_hashtag, desc)|
+      should "not match an inproper hashtag reference, case #{desc}" do
+        assert_no_full_match UI::HASHTAG_REGEX, no_hashtag
+      end
     end
   end
+
+  private
+
+  def show_tweet_at_default_time(tweet)
+    at_default_time { @ui.show_tweet(tweet) }
+  end
+
+  def show_tweets_at_default_time(tweets)
+    at_default_time { @ui.show_tweets(tweets) }
+  end
 end
 
 end

data/test/unit/unit_helper.rb

@@ -9,42 +9,64 @@ Mocha::Configuration.prevent(:stubbing_non_existent_method)
 
 module Tweetwine::Test
   module Assertions
-    # Asserts whether an Enumeration like object contains all the elements.
+    # Asserts whether an Enumeration-like object contains all the elements.
     # Fails unless +actual+ contains the same elements as +expected+, ignoring
     # the order of the elements.
-    #
-    # The method sorts +expected+ and +actual+ in order to compare them. By
-    # default, this sorting is done by calling #sort for each of them. If the
-    # method is called with a block, it is passed to the #sort calls.
-    def assert_contains_exactly(expected, actual, msg = nil, &sorter)
-      expected = block_given? ? expected.sort(&sorter) : expected.sort
-      actual   = block_given? ? actual.sort(&sorter)   : actual.sort
-      assert_equal(expected, actual, get_message(msg) {
-        'after sorting, collection %s is not equal to %s' % [expected.inspect, actual.inspect]
+    def assert_contains_exactly(expected, actual, msg_diff_size = nil, msg_diff_elems = nil)
+      assert_equal(expected.size, actual.size, message(msg_diff_size) {
+        'Expected %s to be of same size as %s' % [actual.inspect, expected.inspect]
+      })
+      assert(enumerable_minus_each_element(actual, expected).empty?, message(msg_diff_elems) {
+        'Expected %s to contain all the elements of %s' % [actual.inspect, expected.inspect]
       })
     end
 
     # Fails unless +str+ is a full match to +regex+.
     def assert_full_match(regex, str, msg = nil)
       match_data = regex.match(str)
-      assert(str == match_data.to_s, get_message(msg) {
-        '%s is not a full match to %s' % [str, regex.inspect]
+      assert(str == match_data.to_s, message(msg) {
+        'Expected %s to be a full match to %s' % [str, regex.inspect]
       })
     end
 
     # Fails if +str+ is a full match to +regex+.
     def assert_no_full_match(regex, str, msg = nil)
       match_data = regex.match(str)
-      assert(str != match_data.to_s, get_message(msg) {
-        '%s is a full match to %s' % [str, regex.inspect]
+      assert(str != match_data.to_s, message(msg) {
+        'Expected %s not to be a full match to %s' % [str, regex.inspect]
+      })
+    end
+
+    # Fails unless +fun.call(*args)+ is equal to +expected+ and
+    # +fun.call(*args)+ is equal to +fun.call(*args.reverse)+.
+    def assert_commutative(expected, args, msg_not_expected = nil, msg_not_commutative = nil, &fun)
+      left_args = args
+      left_actual = fun.call(left_args)
+      assert_equal(expected, left_actual, message(msg_not_expected) {
+        'Expected %s, not %s' % [expected.inspect, left_actual.inspect]
+      })
+      right_args = args.reverse
+      right_actual = fun.call(*right_args)
+      assert_equal(left_actual, right_actual, message(msg_not_commutative) {
+        'Expected fun%s => %s to be commutative with fun%s => %s' %
+          [left_args.inspect, left_actual.inspect, right_args.inspect, right_actual.inspect]
       })
     end
 
     private
 
-    def get_message(given, &default)
+    def message(given, &default)
       given.nil? ? default.call : given
     end
+
+    def enumerable_minus_each_element(enumerable, elements)
+      remaining = enumerable.dup.to_a
+      elements.each do |e|
+        index = remaining.index(e)
+        remaining.delete_at(index) if index
+      end
+      remaining
+    end
   end
 
   module Doubles

data/test/unit/uri_test.rb

@@ -13,7 +13,7 @@ class UriTest < UnitTestCase
       %w{. period},
       %w{- dash},
       %w{_ underscore},
-    ].each do |char, desc|
+    ].each do |(char, desc)|
       should "not encode safe characters, case #{desc}" do
         assert_equal char, Uri.percent_encode(char)
       end
@@ -29,7 +29,7 @@ class UriTest < UnitTestCase
       %w{/ %2F slash},
       %w{: %3A colon},
       %w{, %2C comma}
-    ].each do |char, expected, desc|
+    ].each do |(char, expected, desc)|
       should "encode unsafe characters that URI.encode leaves by default unencoded, case #{desc}" do
         assert_equal char, Uri.parser.escape(char)
         assert_equal expected, Uri.percent_encode(char)

data/tweetwine.gemspec

@@ -1,27 +1,18 @@
 # coding: utf-8
 
-$LOAD_PATH.unshift(File.expand_path('lib', File.dirname(__FILE__)))
-name = 'tweetwine'
-require "#{name}/version"
-version = Tweetwine.version
+require File.expand_path('project', File.dirname(__FILE__))
 
 Gem::Specification.new do |s|
-  s.name = name
-  s.version = version.dup
-
-  s.summary = Tweetwine.summary
-  s.description = <<-END
-A simple but tasty Twitter agent for command line use, designed for quickly
-showing the latest tweets.
-  END
-
-  s.email = 'tkareine@gmail.com'
-  s.homepage = 'https://github.com/tkareine/tweetwine'
-
-  s.authors = ['Tuomas Kareinen']
-
-  s.files = `git ls-files`.split("\n") + Dir['man/**/*.[1-9]']
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.name        = Project.name
+  s.version     = Project.version
+  s.summary     = Project.summary
+  s.description = Project.description
+  s.email       = Project.email
+  s.homepage    = Project.homepage
+  s.authors     = Project.authors
+
+  s.files = `git ls-files`.split("\n") + Dir["#{Project.dirs.man}/**/*.[1-9]"]
+  s.test_files = `git ls-files -- #{Project.dirs.test}/*`.split("\n")
   s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
 
   s.add_dependency 'oauth', '~> 0.4.4'
@@ -45,6 +36,5 @@ default. For Ruby 1.8, you can install 'json' gem, for example.
 
   s.has_rdoc = true
   s.extra_rdoc_files = Dir['*.rdoc', 'LICENSE.txt']
-  s.rdoc_options << '--title'   << "#{name} #{version}" \
-                 << '--exclude' << 'test'
+  s.rdoc_options << '--title' << Project.title << '--exclude' << Project.dirs.test
 end

metadata

@@ -1,8 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: tweetwine
 version: !ruby/object:Gem::Version 
+  hash: 13
   prerelease: 
-  version: 0.4.0
+  segments: 
+  - 0
+  - 4
+  - 1
+  version: 0.4.1
 platform: ruby
 authors: 
 - Tuomas Kareinen
@@ -10,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-22 00:00:00 +02:00
+date: 2011-03-23 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,6 +26,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 4
+        - 4
         version: 0.4.4
   type: :runtime
   version_requirements: *id001
@@ -32,6 +42,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 0
+        - 1
+        - 2
         version: 0.1.2
   type: :development
   version_requirements: *id002
@@ -43,6 +58,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 0
+        - 6
+        - 3
         version: 0.6.3
   type: :development
   version_requirements: *id003
@@ -54,6 +74,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 2
+        - 0
         version: 0.2.0
   type: :development
   version_requirements: *id004
@@ -65,6 +90,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 5
+        - 2
         version: 0.5.2
   type: :development
   version_requirements: *id005
@@ -76,6 +106,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
         version: 0.9.12
   type: :development
   version_requirements: *id006
@@ -87,6 +122,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 0
+        - 1
         version: 1.0.1
   type: :development
   version_requirements: *id007
@@ -98,6 +138,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 49
+        segments: 
+        - 0
+        - 8
+        - 7
         version: 0.8.7
   type: :development
   version_requirements: *id008
@@ -109,6 +154,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 0
+        - 7
+        - 3
         version: 0.7.3
   type: :development
   version_requirements: *id009
@@ -120,6 +170,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 3
+        - 5
         version: 0.3.5
   type: :development
   version_requirements: *id010
@@ -131,6 +186,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 1
+        - 6
+        - 2
         version: 1.6.2
   type: :development
   version_requirements: *id011
@@ -152,6 +212,7 @@ files:
 - Gemfile
 - LICENSE.txt
 - README.md
+- RELEASING.txt
 - Rakefile
 - bin/tweetwine
 - contrib/tweetwine-completion.bash
@@ -174,7 +235,7 @@ files:
 - lib/tweetwine/url_shortener.rb
 - lib/tweetwine/version.rb
 - man/tweetwine.7.ronn
-- release-script.txt
+- project.rb
 - test/example/authorization_example.rb
 - test/example/example_helper.rb
 - test/example/global_options_example.rb
@@ -223,12 +284,14 @@ has_rdoc: true
 homepage: https://github.com/tkareine/tweetwine
 licenses: []
 
-post_install_message: "\n\
-  Tweetwine requires a JSON parser library. Ruby 1.9 comes bundled with one by\n\
-  default. For Ruby 1.8, you can install 'json' gem, for example.\n\n"
+post_install_message: |+
+  
+  Tweetwine requires a JSON parser library. Ruby 1.9 comes bundled with one by
+  default. For Ruby 1.8, you can install 'json' gem, for example.
+  
 rdoc_options: 
 - --title
-- tweetwine 0.4.0
+- tweetwine 0.4.1
 - --exclude
 - test
 require_paths: 
@@ -238,17 +301,23 @@ required_ruby_version: !ruby/object:Gem::Requirement
   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.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Tweetwine shows the latest tweets from the command line quickly.