tweetwine 0.3.2 → 0.4.0

data/test/unit/ui_test.rb

@@ -1,10 +1,13 @@
 # coding: utf-8
 
-require "unit_helper"
+require 'unit_helper'
+require 'tweet_helper'
 
 module Tweetwine::Test
 
 class UITest < UnitTestCase
+  include TweetHelper
+
   context "a UI instance" do
     setup do
       @in  = mock
@@ -69,75 +72,109 @@ class UITest < UnitTestCase
         @ui = UI.new({:in => @in, :out => @out, :colors => false })
       end
 
-      should "output a record as user info when no status is given" do
+      should "output tweet with just user info" do
         from_user = "fooman"
-        record = { :from_user => from_user }
+        tweet = create_tweet(:from_user => from_user)
         @out.expects(:puts).with(<<-END
 #{from_user}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
-      should "output a record as status info when status is given, without in-reply info" do
+      should "output regular tweet" do
         from_user = "fooman"
         status = "Hi, @barman! Lulz woo! #hellos"
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => status,
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :status     => status
+        )
+        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
 #{from_user}, 2 secs ago:
 #{status}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
-      should "output a record as status info when status is given, with in-reply info" do
+      should "output replying tweet" do
         from_user = "barman"
         to_user = "fooman"
-        status = "Hi, @fooman! How are you doing?"
-        record = {
+        status = "Hi, @#{to_user}! How are you doing?"
+        tweet = create_tweet(
           :from_user  => from_user,
           :status     => status,
-          :created_at => Time.at(1),
           :to_user    => to_user
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        )
+        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
 #{from_user}, in reply to #{to_user}, 2 secs ago:
 #{status}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
+      should "output regular retweet" do
+        from_user = "barman"
+        rt_user = "fooman"
+        status = "status worth retweeting"
+        tweet = create_tweet(
+          :from_user  => from_user,
+          :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:
+#{status}
+
+        END
+        )
+        @ui.show_tweet(tweet)
+      end
+
+      should "output replying retweet" do
+        from_user = "barman"
+        to_user = "jackman"
+        rt_user = "fooman"
+        status = "@#{to_user}, reply worth retweeting"
+        tweet = create_tweet(
+          :from_user  => from_user,
+          :to_user    => to_user,
+          :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:
+#{status}
+
+        END
+        )
+        @ui.show_tweet(tweet)
+      end
 
       should "unescape HTML in a status" do
         from_user = "fooman"
         escaped_status = "apple &gt; orange &amp; grapefruit &lt; banana"
         unescaped_status = "apple > orange & grapefruit < banana"
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => escaped_status,
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :status     => escaped_status
+        )
+        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
 #{from_user}, 2 secs ago:
 #{unescaped_status}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
       should "output a preview of a status" do
@@ -157,53 +194,89 @@ class UITest < UnitTestCase
         @ui = UI.new({:in => @in, :out => @out, :colors => true})
       end
 
-      should "output a record as user info when no status is given" do
+      should "output tweet with just user info" do
         from_user = "fooman"
-        record = { :from_user => from_user }
+        tweet = create_tweet(:from_user => from_user)
         @out.expects(:puts).with(<<-END
 \e[32m#{from_user}\e[0m
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
-      should "output a record as status info when status is given, without in-reply info" do
+      should "output regular tweet" do
         from_user = "fooman"
         status = "Wondering about the meaning of life."
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => status,
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :status     => status
+        )
+        Support.expects(:humanize_time_diff).returns([2, "secs"])
         @out.expects(:puts).with(<<-END
 \e[32m#{from_user}\e[0m, 2 secs ago:
 #{status}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
-      should "output a record as status info when status is given, with in-reply info" do
+      should "output replying tweet" do
         from_user = "barman"
         to_user = "fooman"
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
           :status     => "@#{to_user}! How are you doing?",
-          :created_at => Time.at(1),
           :to_user    => to_user
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+        )
+        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[33m@#{to_user}\e[0m! How are you doing?
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
+      end
+
+      should "output regular retweet" do
+        from_user = "barman"
+        rt_user = "fooman"
+        status = "status worth retweeting"
+        tweet = create_tweet(
+          :from_user  => from_user,
+          :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:
+#{status}
+
+        END
+        )
+        @ui.show_tweet(tweet)
+      end
+
+      should "output replying retweet" do
+        from_user = "barman"
+        to_user = "jackman"
+        rt_user = "fooman"
+        tweet = create_tweet(
+          :from_user  => from_user,
+          :to_user    => to_user,
+          :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[33m@#{to_user}\e[0m, reply worth retweeting
+
+        END
+        )
+        @ui.show_tweet(tweet)
       end
 
       should "output a preview of a status" do
@@ -220,39 +293,35 @@ class UITest < UnitTestCase
       should "highlight hashtags in a status" do
         from_user = "barman"
         hashtags = %w{#slang #beignHappy}
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => "Lulz, so happy! #{hashtags[0]} #{hashtags[1]}",
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :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:
 Lulz, so happy! \e[35m#{hashtags[0]}\e[0m \e[35m#{hashtags[1]}\e[0m
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(tweet)
       end
 
       %w{http://is.gd/1qLk3 http://is.gd/1qLk3?id=foo}.each do |url|
         should "highlight HTTP and HTTPS URLs in a status, given #{url}" do
           from_user = "barman"
-          record = {
+          tweet = create_tweet(
             :from_user  => from_user,
-            :status     => "New Rails³ - #{url}",
-            :created_at => Time.at(1),
-            :to_user    => nil
-          }
-          Util.expects(:humanize_time_diff).returns([2, "secs"])
+            :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:
 New Rails³ - \e[36m#{url}\e[0m
 
           END
           )
-          @ui.show_record(record)
+          @ui.show_tweet(tweet)
         end
       end
 
@@ -262,60 +331,87 @@ New Rails³ - \e[36m#{url}\e[0m
       ].each do |(first_url, second_url)|
         should "highlight HTTP and HTTPS URLs in a status, given #{first_url} and #{second_url}" do
           from_user = "barman"
-          record = {
+          tweet = create_tweet(
             :from_user  => from_user,
-            :status     => "Links: #{first_url} and #{second_url} np",
-            :created_at => Time.at(1),
-            :to_user    => nil
-          }
-          Util.expects(:humanize_time_diff).returns([2, "secs"])
+            :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:
 Links: \e[36m#{first_url}\e[0m and \e[36m#{second_url}\e[0m np
 
           END
           )
-          @ui.show_record(record)
+          @ui.show_tweet(tweet)
         end
       end
 
       should "highlight usernames in a status" do
         from_user = "barman"
         users = %w{@fooman @barbaz @spoonman}
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => "I salute you #{users[0]}, #{users[1]}, and #{users[2]}!",
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :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:
 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_record(record)
+        @ui.show_tweet(tweet)
       end
 
       should "not highlight email addresses as usernames in a status" do
         from_user = "barman"
         users = %w{@fooman @barbaz}
         email = "barbaz@foo.net"
-        record = {
+        tweet = create_tweet(
           :from_user  => from_user,
-          :status     => "Hi, #{users[0]}! You should notify #{users[1]}, #{email}",
-          :created_at => Time.at(1),
-          :to_user    => nil
-        }
-        Util.expects(:humanize_time_diff).returns([2, "secs"])
+          :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:
 Hi, \e[33m#{users[0]}\e[0m! You should notify \e[33m#{users[1]}\e[0m, #{email}
 
         END
         )
-        @ui.show_record(record)
+        @ui.show_tweet(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:
+#{status}
+
+        END
+        }
+        @tweets = @users_and_statuses.map { |(user, status)| create_tweet(
+          :from_user => user,
+          :status    => status
+        )}
+        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)
+      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)
       end
     end
   end

data/test/unit/unit_helper.rb

@@ -16,22 +16,34 @@ module Tweetwine::Test
     # 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 = '', &sorter)
+    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, msg)
+      assert_equal(expected, actual, get_message(msg) {
+        'after sorting, collection %s is not equal to %s' % [expected.inspect, actual.inspect]
+      })
     end
 
     # Fails unless +str+ is a full match to +regex+.
-    def assert_full_match(regex, str, msg = '')
+    def assert_full_match(regex, str, msg = nil)
       match_data = regex.match(str)
-      assert(str == match_data.to_s, msg)
+      assert(str == match_data.to_s, get_message(msg) {
+        '%s is not 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 = '')
+    def assert_no_full_match(regex, str, msg = nil)
       match_data = regex.match(str)
-      assert(str != match_data.to_s, msg)
+      assert(str != match_data.to_s, get_message(msg) {
+        '%s is a full match to %s' % [str, regex.inspect]
+      })
+    end
+
+    private
+
+    def get_message(given, &default)
+      given.nil? ? default.call : given
     end
   end
 

data/test/unit/uri_test.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+require "unit_helper"
+
+module Tweetwine::Test
+
+class UriTest < UnitTestCase
+  context "for percent-encoding strings" do
+    [
+      %w{a a},
+      %w{B B},
+      %w{3 3},
+      %w{. period},
+      %w{- dash},
+      %w{_ underscore},
+    ].each do |char, desc|
+      should "not encode safe characters, case #{desc}" do
+        assert_equal char, Uri.percent_encode(char)
+      end
+    end
+
+    should "encode space character with percent-encoding, not with '+' character" do
+      assert_equal "%20", Uri.percent_encode(" ")
+    end
+
+    [
+      %w{& %26 ampersand},
+      %w{? %3F question mark},
+      %w{/ %2F slash},
+      %w{: %3A colon},
+      %w{, %2C comma}
+    ].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)
+      end
+    end
+  end
+end
+
+end

data/test/unit/url_shortener_test.rb

@@ -90,7 +90,7 @@ class UrlShortenerTest < UnitTestCase
           },
           :xpath_selector   => "//input[@id='short_url']/@value")
         @http.expects(:get).
-            with("http://shorten.it/create?token=xyz&url=http://www.ruby-doc.org/core/")
+          with("http://shorten.it/create?token=xyz&url=http://www.ruby-doc.org/core/")
         url_shortener.shorten("http://www.ruby-doc.org/core/")
       end
     end
@@ -103,7 +103,7 @@ class UrlShortenerTest < UnitTestCase
           :url_param_name   => "url",
           :xpath_selector   => "//input[@id='short_url']/@value")
         @http.expects(:post).
-            with("http://shorten.it/create", {:url => "http://www.ruby-doc.org/core/"})
+          with("http://shorten.it/create", {:url => "http://www.ruby-doc.org/core/"})
         url_shortener.shorten("http://www.ruby-doc.org/core/")
       end
 
@@ -117,9 +117,9 @@ class UrlShortenerTest < UnitTestCase
           },
           :xpath_selector   => "//input[@id='short_url']/@value")
         @http.expects(:post).
-            with("http://shorten.it/create",
-              :token => "xyz",
-              :url   => "http://www.ruby-doc.org/core/")
+          with("http://shorten.it/create",
+            :token => "xyz",
+            :url   => "http://www.ruby-doc.org/core/")
         url_shortener.shorten("http://www.ruby-doc.org/core/")
       end
     end
@@ -132,8 +132,8 @@ class UrlShortenerTest < UnitTestCase
           :url_param_name   => "url",
           :xpath_selector   => "//input[@id='short_url']/@value")
         @http.expects(:post).
-            with("http://shorten.it/create", :url => "http://www.ruby-doc.org/core/").
-            raises(HttpError.new(404, "Not Found"))
+          with("http://shorten.it/create", :url => "http://www.ruby-doc.org/core/").
+          raises(HttpError.new(404, "Not Found"))
         assert_raise(HttpError) { url_shortener.shorten("http://www.ruby-doc.org/core/") }
       end
     end

data/tweetwine.gemspec

@@ -2,49 +2,39 @@
 
 $LOAD_PATH.unshift(File.expand_path('lib', File.dirname(__FILE__)))
 name = 'tweetwine'
-require name
-summary = Tweetwine.summary
-version = Tweetwine.version.dup
+require "#{name}/version"
+version = Tweetwine.version
 
 Gem::Specification.new do |s|
   s.name = name
-  s.version = version
+  s.version = version.dup
 
-  s.summary = summary
+  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/tuomas/tweetwine'
+  s.homepage = 'https://github.com/tkareine/tweetwine'
 
   s.authors = ['Tuomas Kareinen']
 
-  s.executables = %w{tweetwine}
-  s.files = Dir[
-    '*.md',
-    '*.rdoc',
-    'LICENSE.txt',
-    'Gemfile',
-    'Rakefile',
-    'tweetwine.gemspec',
-    '{bin,contrib,lib}/**/*',
-    'man/**/*.[1-9]',
-    'man/**/*.ronn'
-  ]
-  s.test_files = Dir['test/**/*']
+  s.files = `git ls-files`.split("\n") + Dir['man/**/*.[1-9]']
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
 
   s.add_dependency 'oauth', '~> 0.4.4'
   s.add_development_dependency 'contest',       '~> 0.1.2'
-  s.add_development_dependency 'coulda',        '~> 0.6.0'
+  s.add_development_dependency 'coulda',        '~> 0.6.3'
   s.add_development_dependency 'gem-man',       '~> 0.2.0'
   s.add_development_dependency 'mcmire-matchy', '~> 0.5.2'
-  s.add_development_dependency 'mocha',         '=  0.9.8'
+  s.add_development_dependency 'mocha',         '~> 0.9.12'
   s.add_development_dependency 'open4',         '~> 1.0.1'
+  s.add_development_dependency 'rake',          '~> 0.8.7'
   s.add_development_dependency 'ronn',          '~> 0.7.3'
   s.add_development_dependency 'timecop',       '~> 0.3.5'
-  s.add_development_dependency 'webmock',       '~> 1.6.1'
+  s.add_development_dependency 'webmock',       '~> 1.6.2'
 
   s.post_install_message = <<-END