tweetwine 0.2.5 → 0.2.7

data/lib/tweetwine/io.rb

@@ -15,7 +15,7 @@ module Tweetwine
     def initialize(options)
       @input = options[:input] || $stdin
       @output = options[:output] || $stdout
-      @colorize = options[:colorize] || false
+      @colors = options[:colors] || false
     end
 
     def prompt(prompt)
@@ -34,7 +34,7 @@ module Tweetwine
     def confirm(msg)
       @output.print "#{msg} [yN] "
       confirmation = @input.gets.strip
-      confirmation.downcase[0,1] == "y"
+      confirmation.downcase[0, 1] == "y"
     end
 
     def show_status_preview(status)
@@ -46,6 +46,7 @@ module Tweetwine
     end
 
     def show_record(record)
+      clean_record!(record)
       if record[:status]
         show_record_as_user_with_status(record)
       else
@@ -55,63 +56,73 @@ module Tweetwine
 
     private
 
+    def clean_record!(record)
+      record.each_pair do |key, value|
+        if value.is_a? Hash
+          clean_record!(value)
+        else
+          unless value.nil?
+            value = value.to_s
+            record[key] = value.empty? ? nil : value
+          end
+        end
+      end
+    end
+
     def show_record_as_user(record)
       @output.puts <<-END
-#{format_user(record[:user])}
+#{format_user(record[:from_user])}
 
       END
     end
 
     def show_record_as_user_with_status(record)
       @output.puts <<-END
-#{format_record_header(record)}
-#{format_status(record[:status][:text])}
+#{format_record_header(record[:from_user], record[:to_user], record[:created_at])}
+#{format_status(record[:status])}
 
       END
     end
 
     def format_user(user)
-      user = user.dup
-      colorize!(:green, user) if @colorize
+      user = colorize(:green, user) if @colors
       user
     end
 
     def format_status(status)
-      status = status.dup
-      if @colorize
-        colorize_all_by_group!(:yellow, status, USERNAME_REGEX)
-        colorize_all_by_group!(:magenta, status, HASHTAG_REGEX)
+      if @colors
+        status = colorize_all_by_group(:yellow, status, USERNAME_REGEX)
+        status = colorize_all_by_group(:magenta, status, HASHTAG_REGEX)
         URI.extract(status, ["http", "https"]).uniq.each do |url|
-          colorize_all!(:cyan, status, url)
+          status = colorize_all(:cyan, status, url)
         end
       end
       status
     end
 
-    def format_record_header(record)
-      time_diff_value, time_diff_unit = Util.humanize_time_diff(record[:status][:created_at], Time.now)
-      from_user = record[:user].dup
-      colorize!(:green, from_user) if @colorize
-      in_reply_to = record[:status][:in_reply_to]
-      in_reply_to = if in_reply_to && !in_reply_to.empty?
-        in_reply_to = colorize!(:green, in_reply_to.dup) if @colorize
-        "in reply to #{in_reply_to}, "
+    def format_record_header(from_user, to_user, created_at)
+      time_diff_value, time_diff_unit = Util.humanize_time_diff(created_at, Time.now)
+      if @colors
+        from_user = colorize(:green, from_user)
+        to_user = colorize(:green, to_user) if to_user
+      end
+      if to_user
+        "#{from_user}, in reply to #{to_user}, #{time_diff_value} #{time_diff_unit} ago:"
       else
-        ""
+        "#{from_user}, #{time_diff_value} #{time_diff_unit} ago:"
       end
-      "#{from_user}, #{in_reply_to}#{time_diff_value} #{time_diff_unit} ago:"
     end
 
-    def colorize_all!(color, str, pattern)
-      str.gsub!(pattern) { |s| colorize_str(COLOR_CODES[color.to_sym], s) }
+    def colorize_all(color, str, pattern)
+      str.gsub(pattern) { |s| colorize_str(COLOR_CODES[color.to_sym], s) }
     end
 
-    def colorize_all_by_group!(color, str, pattern)
-      str.replace Util.str_gsub_by_group(str, pattern) { |s| colorize_str(COLOR_CODES[color.to_sym], s) }
+    def colorize_all_by_group(color, str, pattern)
+      Util.str_gsub_by_group(str, pattern) { |s| colorize_str(COLOR_CODES[color.to_sym], s) }
     end
 
-    def colorize!(color, str)
-      str.replace colorize_str(COLOR_CODES[color.to_sym], str)
+    def colorize(color, str)
+      colorize_str(COLOR_CODES[color.to_sym], str)
     end
 
     def colorize_str(color_code, str)

data/lib/tweetwine/meta.rb

@@ -1,3 +1,3 @@
 module Tweetwine
-  VERSION = "0.2.5"
+  VERSION = "0.2.7"
 end

data/lib/tweetwine/retrying_http.rb

@@ -0,0 +1,93 @@
+require "rest_client"
+
+module Tweetwine
+  class HttpError < RuntimeError; end
+
+  module RetryingHttp
+    class Base
+      MAX_RETRIES = 3
+      RETRY_BASE_WAIT_TIMEOUT = 4
+
+      def self.use_retries_with(*methods)
+        methods.each do |method_name|
+          module_eval do
+            non_retrying_method_name = "original_#{method_name}".to_sym
+            alias_method non_retrying_method_name, method_name
+            define_method(method_name) do |*args|
+              do_with_retries { send(non_retrying_method_name, *args) }
+            end
+          end
+        end
+      end
+
+      private
+
+      def do_with_retries
+        tries = 0
+        begin
+          tries += 1
+          yield
+        rescue Errno::ECONNRESET => e
+          if tries < MAX_RETRIES
+            timeout = RETRY_BASE_WAIT_TIMEOUT**tries
+            @io.warn("Could not connect -- retrying in #{timeout} seconds") if @io
+            sleep timeout
+            retry
+          else
+            raise HttpError, e
+          end
+        rescue RestClient::Exception, SocketError, SystemCallError => e
+          raise HttpError, e
+        end
+      end
+    end
+
+    class Client < Base
+      attr_accessor :io
+
+      def initialize(io)
+        @io = io
+      end
+
+      def get(*args)
+        RestClient.get(*args)
+      end
+
+      def post(*args)
+        RestClient.post(*args)
+      end
+
+      def as_resource(url, options = {})
+        resource = Resource.new(RestClient::Resource.new(url, options))
+        resource.io = @io
+        resource
+      end
+
+      use_retries_with :get, :post
+    end
+
+    class Resource < Base
+      attr_accessor :io
+
+      def initialize(wrapped_resource)
+        @wrapped = wrapped_resource
+      end
+
+      def [](suburl)
+        instance = self.class.new(@wrapped[suburl])
+        instance.io = @io
+        instance
+      end
+
+      def get(*args)
+        @wrapped.get(*args)
+      end
+
+      def post(*args)
+        @wrapped.post(*args)
+      end
+
+      use_retries_with :get, :post
+    end
+  end
+end

data/lib/tweetwine/startup_config.rb

@@ -2,34 +2,33 @@ require "yaml"
 
 module Tweetwine
   class StartupConfig
-    attr_reader :options, :command, :args, :supported_commands
+    attr_reader :options, :command
 
-    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 = []
+    def initialize(supported_commands, default_command, default_opts = {})
+      raise ArgumentError, "Must give at least one supported command" if supported_commands.empty?
+      raise ArgumentError, "Default command is not a supported command" unless supported_commands.include? default_command
+      @supported_commands, @default_command = supported_commands, default_command
+      @options, @command = default_opts, nil
     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
+    def parse(args = [], config_file = nil, &cmd_option_parser)
+      options = @options.merge(parse_options(args, config_file, &cmd_option_parser))
+      command = if args.empty? then @default_command else args.shift.to_sym end
       raise ArgumentError, "Unknown command" unless @supported_commands.include? command
-      @options, @command, @args = options, command, args
+      @options, @command = options, command
       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
+    def parse_options(args, config_file, &cmd_option_parser)
+      cmd_options = if cmd_option_parser then parse_cmdline_args(args, &cmd_option_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)
+    def parse_cmdline_args(args, &cmd_option_parser)
+      cmd_option_parser.call(args)
     end
 
     def parse_config_file(config_file)

data/lib/tweetwine/url_shortener.rb

@@ -1,7 +1,7 @@
 module Tweetwine
   class UrlShortener
-    def initialize(rest_client, options)
-      @rest_client = rest_client
+    def initialize(http_client, options)
+      @http_client = http_client
       options = Options.new(options, "URL shortening")
       @method = (options[:method] || :get).to_sym
       @service_url = options.require :service_url
@@ -17,22 +17,27 @@ module Tweetwine
 
     def shorten(url)
       require "nokogiri"
-      rest = case @method
+      response = @http_client.send(@method, *get_service_url_and_params(url))
+      doc = Nokogiri::HTML(response)
+      doc.xpath(@xpath_selector).first.to_s
+    end
+
+    private
+
+    def get_service_url_and_params(url_to_shorten)
+      case @method
       when :get
         tmp = @extra_params.dup
-        tmp << "#{@url_param_name}=#{url}"
+        tmp << "#{@url_param_name}=#{url_to_shorten}"
         service_url = "#{@service_url}?#{tmp.join('&')}"
         [service_url]
       when :post
         service_url = @service_url
-        params = @extra_params.merge({ @url_param_name.to_sym => url })
+        params = @extra_params.merge({ @url_param_name.to_sym => url_to_shorten })
         [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

@@ -1,4 +1,5 @@
 require "time"
+require "uri"
 
 module Tweetwine
   module Util
@@ -59,6 +60,19 @@ module Tweetwine
       dup_str
     end
 
+    def self.percent_encode(str)
+      URI.escape(str.to_s, /[^#{URI::PATTERN::UNRESERVED}]/)
+    end
+
+    def self.find_hash_path(hash, path)
+      return nil if hash.nil?
+      path = [path] if !path.is_a? Array
+      path.inject(hash) do |result, key|
+        return hash.default if key.nil? || result.nil?
+        result[key]
+      end
+    end
+
     private
 
     def self.pluralize_unit(value, unit)

data/lib/tweetwine.rb

@@ -4,9 +4,10 @@
   options
   startup_config
   io
-  rest_client_wrapper
+  retrying_http
   url_shortener
   client
+  cli
 }.each do |f|
   require "tweetwine/#{f}"
 end

data/test/cli_test.rb

@@ -0,0 +1,16 @@
+require "test_helper"
+
+module Tweetwine
+
+class CLITest < Test::Unit::TestCase
+  context "A CLI, upon initialization" do
+    should "disallow using #new to create a new instance" do
+      assert_raise(NoMethodError) { CLI.new("-v", "test", "") {} }
+    end
+  end
+
+  # Other unit tests are meaningless. See /example directory for tests
+  # about the functionality of the application.
+end
+
+end