tweetwine 0.2.4

data/lib/tweetwine/rest_client_wrapper.rb

@@ -0,0 +1,37 @@
+require "rest_client"
+
+module Tweetwine
+  class ClientError < RuntimeError; end
+
+  class RestClientWrapper
+    instance_methods.each { |m| undef_method m unless m =~ /(^__|^send$|^object_id$)/ }
+
+    MAX_RETRIES = 3
+    RETRY_BASE_WAIT_TIMEOUT = 4
+
+    def initialize(io)
+      @io = io
+    end
+
+    protected
+
+    def method_missing(name, *args, &block)
+      tries = 0
+      begin
+        tries += 1
+        RestClient.send(name, *args, &block)
+      rescue Errno::ECONNRESET => e
+        if tries < MAX_RETRIES
+          timeout = RETRY_BASE_WAIT_TIMEOUT**tries
+          @io.warn("Could not connect -- retrying in #{timeout} seconds")
+          sleep timeout
+          retry
+        else
+          raise ClientError, e
+        end
+      rescue RestClient::Exception, SocketError, SystemCallError => e
+        raise ClientError, e
+      end
+    end
+  end
+end

data/lib/tweetwine/startup_config.rb

@@ -0,0 +1,40 @@
+require "yaml"
+
+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))
+      Util.symbolize_hash_keys(options)
+    end
+  end
+end

data/lib/tweetwine/url_shortener.rb

@@ -0,0 +1,38 @@
+module Tweetwine
+  class UrlShortener
+    def initialize(rest_client, options)
+      @rest_client = rest_client
+      options = Options.new(options, "URL shortening")
+      @method = (options[:method] || :get).to_sym
+      @service_url = options.require :service_url
+      @url_param_name = options.require :url_param_name
+      @extra_params = options[:extra_params] || {}
+      if @method == :get
+        tmp = []
+        @extra_params.each_pair { |k, v| tmp << "#{k}=#{v}" }
+        @extra_params = tmp
+      end
+      @xpath_selector = options.require :xpath_selector
+    end
+
+    def shorten(url)
+      require "nokogiri"
+      rest = case @method
+      when :get
+        tmp = @extra_params.dup
+        tmp << "#{@url_param_name}=#{url}"
+        service_url = "#{@service_url}?#{tmp.join('&')}"
+        [service_url]
+      when :post
+        service_url = @service_url
+        params = @extra_params.merge({ @url_param_name.to_sym => url })
+        [service_url, params]
+      else
+        raise "Unrecognized HTTP request method"
+      end
+      response = @rest_client.send(@method, *rest)
+      doc = Nokogiri::HTML(response)
+      doc.xpath(@xpath_selector).first.to_s
+    end
+  end
+end

data/lib/tweetwine/util.rb

@@ -0,0 +1,52 @@
+require "time"
+
+module Tweetwine
+  module Util
+    def self.humanize_time_diff(from, to)
+      from = Time.parse(from.to_s) unless from.is_a? Time
+      to = Time.parse(to.to_s) unless to.is_a? Time
+
+      difference = (to - from).to_i.abs
+
+      value, unit = case difference
+      when 0..59 then [difference, "sec"]
+      when 60..3599 then [(difference/60.0).round, "min"]
+      when 3600..86399 then [(difference/3600.0).round, "hour"]
+      else [(difference/86400.0).round, "day"]
+      end
+
+      [value, pluralize_unit(value, unit)]
+    end
+
+    def self.symbolize_hash_keys(hash)
+      hash.inject({}) do |result, pair|
+        value = pair.last
+        value = symbolize_hash_keys(value) if value.is_a? Hash
+        result[pair.first.to_sym] = value
+        result
+      end
+    end
+
+    def self.parse_int_gt(value, default, min, name_for_error)
+      if value
+        value = value.to_i
+        if value >= min
+          value
+        else
+          raise ArgumentError, "Invalid #{name_for_error} -- must be greater than or equal to #{min}"
+        end
+      else
+        default
+      end
+    end
+
+    private
+
+    def self.pluralize_unit(value, unit)
+      if ["hour", "day"].include?(unit) && value > 1
+        unit = unit + "s"
+      end
+      unit
+    end
+  end
+end

data/lib/tweetwine.rb

@@ -0,0 +1,12 @@
+%w{
+  meta
+  util
+  options
+  startup_config
+  io
+  rest_client_wrapper
+  url_shortener
+  client
+}.each do |f|
+  require "tweetwine/#{f}"
+end

data/test/client_test.rb

@@ -0,0 +1,475 @@
+require "test_helper"
+require "json"
+
+Mocha::Configuration.allow(:stubbing_non_existent_method)
+
+module Tweetwine
+
+class ClientTest < Test::Unit::TestCase
+  context "A client instance" do
+    setup do
+      @io = mock()
+      @rest_client = mock()
+      @url_shortener = mock()
+      url_shortener = lambda { |options| @url_shortener }
+      @deps = {
+        :io             => @io,
+        :rest_client    => @rest_client,
+        :url_shortener  => url_shortener
+      }
+    end
+
+    context "upon initialization" do
+      should "raise exception when no authentication data is given" do
+        assert_raise(ArgumentError) { Client.new(@deps, {}) }
+        assert_raise(ArgumentError) { Client.new(@deps, { :password => "bar" }) }
+        assert_raise(ArgumentError) { Client.new(@deps, { :username => "", :password => "bar" }) }
+        assert_nothing_raised { Client.new(@deps, { :username => "foo", :password => "bar" }) }
+      end
+
+      should "use default number of statuses if not configured otherwise" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar" })
+        assert_equal Client::DEFAULT_NUM_STATUSES, @client.num_statuses
+      end
+
+      should "use configured number of statuses if in allowed range" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar", :num_statuses => 12 })
+        assert_equal 12, @client.num_statuses
+      end
+
+      should "raise an exception for configured number of statuses if not in allowed range" do
+        assert_raise(ArgumentError) { Client.new(@deps, { :username => "foo", :password => "bar", :num_statuses => 0 }) }
+      end
+
+      should "use default page number if not configured otherwise" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar" })
+        assert_equal Client::DEFAULT_PAGE_NUM, @client.page_num
+      end
+
+      should "use configured page number if in allowed range" do
+        @client = Client.new(@deps, { :username => "foo", :password => "bar", :page_num => 12 })
+        assert_equal 12, @client.page_num
+      end
+
+      should "raise an exception for configured page number if not in allowed range" do
+        assert_raise(ArgumentError) { Client.new(@deps, { :username => "foo", :password => "bar", :page_num => 0 }) }
+      end
+    end
+
+    context "at runtime" do
+      setup do
+        @username = "spiky"
+        @password = "lullaby"
+        @client = Client.new(@deps, { :username => @username, :password => @password })
+        @base_url = "https://#{@username}:#{@password}@twitter.com"
+        @statuses_query_params = "count=#{Client::DEFAULT_NUM_STATUSES}&page=#{Client::DEFAULT_PAGE_NUM}"
+        @users_query_params = "page=#{Client::DEFAULT_PAGE_NUM}"
+      end
+
+      should "fetch friends' statuses (home view)" do
+        status_records, gen_records = create_test_statuses(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup?",
+              :in_reply_to  => nil
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "nuttin'",
+              :in_reply_to  => nil
+            }
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/friends_timeline.json?#{@statuses_query_params}") \
+            .returns(status_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @io.expects(:show_record).with(gen_records[1])
+        @client.home
+      end
+
+      should "fetch mentions" do
+        status_records, gen_records = create_test_statuses(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup, @#{@username}?",
+              :in_reply_to  => @username
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "@#{@username}, doing nuttin'",
+              :in_reply_to  => @username
+            }
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/mentions.json?#{@statuses_query_params}") \
+            .returns(status_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @io.expects(:show_record).with(gen_records[1])
+        @client.mentions
+      end
+
+      should "fetch a specific user's statuses, when the user identified by given argument" do
+        user = "spoonman"
+        status_records, gen_records = create_test_statuses(
+          {
+            :user => user,
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup?",
+              :in_reply_to  => nil
+            }
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/user_timeline/#{user}.json?#{@statuses_query_params}") \
+            .returns(status_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @client.user(user)
+      end
+
+      should "fetch a specific user's statuses, with the user being the authenticated user itself when given no argument" do
+        status_records, gen_records = create_test_statuses(
+          {
+            :user => @username,
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup?",
+              :in_reply_to  => nil
+            }
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/user_timeline/#{@username}.json?#{@statuses_query_params}") \
+            .returns(status_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @client.user
+      end
+
+      context "for posting status updates" do
+        should "post a status update via argument, when positive confirmation" do
+          status = "wondering around"
+          status_records, gen_records = create_test_statuses(
+            {
+              :user => @username,
+              :status => {
+                :created_at   => Time.at(1).to_s,
+                :text         => status,
+                :in_reply_to  => nil
+              }
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => status}) \
+              .returns(status_records[0].to_json)
+          @io.expects(:confirm).with("Really send?").returns(true)
+          @io.expects(:show_status_preview).with(status)
+          @io.expects(:info).with("Sent status update.\n\n")
+          @io.expects(:show_record).with(gen_records[0])
+          @client.update(status)
+        end
+
+        should "post a status update via prompt, when positive confirmation" do
+          status = "wondering around"
+          status_records, gen_records = create_test_statuses(
+            { :user => @username,
+              :status => {
+                :created_at   => Time.at(1).to_s,
+                :text         => status,
+                :in_reply_to  => nil
+              }
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => status}) \
+              .returns(status_records[0].to_json)
+          @io.expects(:prompt).with("Status update").returns(status)
+          @io.expects(:show_status_preview).with(status)
+          @io.expects(:confirm).with("Really send?").returns(true)
+          @io.expects(:info).with("Sent status update.\n\n")
+          @io.expects(:show_record).with(gen_records[0])
+          @client.update
+        end
+
+        should "cancel a status update via argument, when negative confirmation" do
+          status = "wondering around"
+          @rest_client.expects(:post).never
+          @io.expects(:show_status_preview).with(status)
+          @io.expects(:confirm).with("Really send?").returns(false)
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update(status)
+        end
+
+        should "cancel a status update via prompt, when negative confirmation" do
+          status = "wondering around"
+          @rest_client.expects(:post).never
+          @io.expects(:prompt).with("Status update").returns(status)
+          @io.expects(:show_status_preview).with(status)
+          @io.expects(:confirm).with("Really send?").returns(false)
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update
+        end
+
+        should "cancel a status update via argument, when empty status" do
+          @rest_client.expects(:post).never
+          @io.expects(:confirm).never
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update("")
+        end
+
+        should "cancel a status update via prompt, when empty status" do
+          @rest_client.expects(:post).never
+          @io.expects(:prompt).with("Status update").returns("")
+          @io.expects(:confirm).never
+          @io.expects(:info).with("Cancelled.")
+          @io.expects(:show_record).never
+          @client.update
+        end
+
+        should "remove excess whitespace around a status update" do
+          whitespaced_status = "  oh, i was sloppy \t   "
+          stripped_status = "oh, i was sloppy"
+          status_records, gen_records = create_test_statuses(
+            { :user => @username,
+              :status => {
+                :created_at   => Time.at(1).to_s,
+                :text         => stripped_status,
+                :in_reply_to  => nil
+              }
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => stripped_status}) \
+              .returns(status_records[0].to_json)
+          @io.expects(:show_status_preview).with(stripped_status)
+          @io.expects(:confirm).with("Really send?").returns(true)
+          @io.expects(:info).with("Sent status update.\n\n")
+          @io.expects(:show_record).with(gen_records[0])
+          @client.update(whitespaced_status)
+        end
+
+        should "truncate a status update with too long argument and warn the user" do
+          long_status = "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 = "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_records, gen_records = create_test_statuses(
+            { :user => @username,
+              :status => {
+                :created_at   => Time.at(1).to_s,
+                :text         => truncated_status,
+                :in_reply_to  => nil
+              }
+            }
+          )
+          @rest_client.expects(:post) \
+              .with("#{@base_url}/statuses/update.json", {:status => truncated_status}) \
+              .returns(status_records[0].to_json)
+          @io.expects(:warn).with("Status will be truncated.")
+          @io.expects(:show_status_preview).with(truncated_status)
+          @io.expects(:confirm).with("Really send?").returns(true)
+          @io.expects(:info).with("Sent status update.\n\n")
+          @io.expects(:show_record).with(gen_records[0])
+          @client.update(long_status)
+        end
+
+        context "with URL shortening enabled" do
+          setup do
+            @client = Client.new(@deps, {
+              :username => @username,
+              :password => @password,
+              :shorten_urls => {
+                :enable         => true,
+                :service_url    => "http://shorten.it/create",
+                :method         => "post",
+                :url_param_name => "url",
+                :xpath_selector => "//input[@id='short_url']/@value"
+              }
+            })
+          end
+
+          should "shorten URLs, avoiding truncation with long URLs" do
+            long_urls = ["http://www.google.fi/search?q=ruby+nokogiri&ie=utf-8&oe=utf-8&aq=t&rls=org.mozilla:en-US:official&client=firefox-a", "http://www.w3.org/TR/1999/REC-xpath-19991116"]
+            long_status = long_urls.join(" and ")
+            short_urls = ["http://shorten.it/2k7i8", "http://shorten.it/2k7mk"]
+            shortened_status = short_urls.join(" and ")
+            status_records, gen_records = create_test_statuses(
+              { :user => @username,
+                :status => {
+                  :created_at   => Time.at(1).to_s,
+                  :text         => shortened_status,
+                  :in_reply_to  => nil
+                }
+              }
+            )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => shortened_status}) \
+                .returns(status_records[0].to_json)
+            @url_shortener.expects(:shorten).with(long_urls.first).returns(short_urls.first)
+            @url_shortener.expects(:shorten).with(long_urls.last).returns(short_urls.last)
+            @io.expects(:show_status_preview).with(shortened_status)
+            @io.expects(:confirm).with("Really send?").returns(true)
+            @io.expects(:info).with("Sent status update.\n\n")
+            @io.expects(:show_record).with(gen_records[0])
+            @client.update(long_status)
+          end
+
+          should "discard obviously invalid shortened URLs, using originals instead" do
+            long_urls = ["http://www.google.fi/", "http://www.w3.org/TR/1999/REC-xpath-19991116"]
+            status = long_urls.join(" and ")
+            short_urls = [nil, ""]
+            status_records, gen_records = create_test_statuses(
+              { :user => @username,
+                :status => {
+                  :created_at   => Time.at(1).to_s,
+                  :text         => status,
+                  :in_reply_to  => nil
+                }
+              }
+            )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => status}) \
+                .returns(status_records[0].to_json)
+            @url_shortener.expects(:shorten).with(long_urls.first).returns(short_urls.first)
+            @url_shortener.expects(:shorten).with(long_urls.last).returns(short_urls.last)
+            @io.expects(:show_status_preview).with(status)
+            @io.expects(:confirm).with("Really send?").returns(true)
+            @io.expects(:info).with("Sent status update.\n\n")
+            @io.expects(:show_record).with(gen_records[0])
+            @client.update(status)
+          end
+
+          should "reuse a shortened URL for duplicate long URLs" do
+            long_urls = ["http://www.w3.org/TR/1999/REC-xpath-19991116"] * 2
+            long_status = long_urls.join(" and ")
+            short_url = "http://shorten.it/2k7mk"
+            short_status = ([short_url] * 2).join(" and ")
+            status_records, gen_records = create_test_statuses(
+              { :user => @username,
+                :status => {
+                  :created_at   => Time.at(1).to_s,
+                  :text         => short_status,
+                  :in_reply_to  => nil
+                }
+              }
+            )
+            @rest_client.expects(:post) \
+                .with("#{@base_url}/statuses/update.json", {:status => short_status}) \
+                .returns(status_records[0].to_json)
+            @url_shortener.expects(:shorten).with(long_urls.first).returns(short_url)
+            @io.expects(:show_status_preview).with(short_status)
+            @io.expects(:confirm).with("Really send?").returns(true)
+            @io.expects(:info).with("Sent status update.\n\n")
+            @io.expects(:show_record).with(gen_records[0])
+            @client.update(long_status)
+          end
+
+          context "in erroneous situations" do
+            setup do
+              @url = "http://www.w3.org/TR/1999/REC-xpath-19991116"
+              @status = "skimming through #{@url}"
+              @status_records, @gen_records = create_test_statuses(
+                { :user => @username,
+                  :status => {
+                    :created_at   => Time.at(1).to_s,
+                    :text         => @status,
+                    :in_reply_to  => nil
+                  }
+                }
+              )
+            end
+
+            should "skip shortening URLs if required libraries are not found" do
+              @rest_client.expects(:post) \
+                  .with("#{@base_url}/statuses/update.json", {:status => @status}) \
+                  .returns(@status_records[0].to_json)
+              @url_shortener.expects(:shorten).with(@url).raises(LoadError, "gem not found")
+              @io.expects(:warn)
+              @io.expects(:show_status_preview).with(@status)
+              @io.expects(:confirm).with("Really send?").returns(true)
+              @io.expects(:info).with("Sent status update.\n\n")
+              @io.expects(:show_record).with(@gen_records[0])
+              @client.update(@status)
+            end
+
+            should "skip shortening URLs upon connection error to the URL shortening service" do
+              @rest_client.expects(:post) \
+                  .with("#{@base_url}/statuses/update.json", {:status => @status}) \
+                  .returns(@status_records[0].to_json)
+              @url_shortener.expects(:shorten).with(@url).raises(ClientError, "connection error")
+              @io.expects(:warn)
+              @io.expects(:show_status_preview).with(@status)
+              @io.expects(:confirm).with("Really send?").returns(true)
+              @io.expects(:info).with("Sent status update.\n\n")
+              @io.expects(:show_record).with(@gen_records[0])
+              @client.update(@status)
+            end
+          end
+        end
+      end
+
+      should "fetch friends" do
+        user_records, gen_records = create_test_users(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup, @foo?",
+              :in_reply_to  => "foo"
+            }
+          },
+          {
+            :user => "lulzwoo",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "@foo, doing nuttin'",
+              :in_reply_to  => "foo"
+            }
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/friends/#{@username}.json?#{@users_query_params}") \
+            .returns(user_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @io.expects(:show_record).with(gen_records[1])
+        @client.friends
+      end
+
+      should "fetch followers" do
+        user_records, gen_records = create_test_users(
+          {
+            :user => "zanzibar",
+            :status => {
+              :created_at   => Time.at(1).to_s,
+              :text         => "wassup, @foo?",
+              :in_reply_to  => "foo"
+            }
+          },
+          {
+            :user => "lulzwoo"
+          }
+        )
+        @rest_client.expects(:get) \
+            .with("#{@base_url}/statuses/followers/#{@username}.json?#{@users_query_params}") \
+            .returns(user_records.to_json)
+        @io.expects(:show_record).with(gen_records[0])
+        @io.expects(:show_record).with(gen_records[1])
+        @client.followers
+      end
+    end
+  end
+end
+
+end