tweetwine 0.2.5 → 0.2.7

data/example/show_user_example.rb

@@ -0,0 +1,37 @@
+require "example_helper"
+
+FakeWeb.register_uri(:get, "https://#{TEST_AUTH}@twitter.com/statuses/user_timeline/#{TEST_USER}.json?count=20&page=1", :body => fixture("user.json"))
+
+Feature "show a specific user's latest statuses" do
+  in_order_to "to see what is going on with a specific user"
+  as_a "authenticated user"
+  i_want_to "see the latest statuses of a specific user"
+
+  Scenario "see my latest statuses" do
+    When "application is launched 'user' command and without extra arguments" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --no-colors user})
+    end
+
+    Then "my the latest statuses are shown" do
+      @output[0].should == "jillv, in reply to chris, 9 hours ago:"
+      @output[1].should == "@chris wait me until the garden"
+      @output[2].should == ""
+      @output[3].should == "jillv, 3 days ago:"
+      @output[4].should == "so boring to wait"
+    end
+  end
+
+  Scenario "see the latest statuses of another user" do
+    When "application is launched 'user' command and the user as an extra argument" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --no-colors user #{TEST_USER}})
+    end
+
+    Then "the latest statuses of the user are shown" do
+      @output[0].should == "jillv, in reply to chris, 9 hours ago:"
+      @output[1].should == "@chris wait me until the garden"
+      @output[2].should == ""
+      @output[3].should == "jillv, 3 days ago:"
+      @output[4].should == "so boring to wait"
+    end
+  end
+end

data/example/update_status_example.rb

@@ -0,0 +1,65 @@
+require "example_helper"
+
+FakeWeb.register_uri(:post, "https://#{TEST_AUTH}@twitter.com/statuses/update.json", :body => fixture("update.json"))
+
+Feature "update my status" do
+  in_order_to "tell something about me to the world"
+  as_a "authenticated user"
+  i_want_to "update my status"
+
+  STATUS = "bored. going to sleep."
+
+  Scenario "update my status from command line with colorization disabled" do
+    When "application is launched 'update' command" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --no-colors update '#{STATUS}'}, "y")
+    end
+
+    Then "the status sent is shown" do
+      @output[5].should == "#{TEST_USER}, 9 hours ago:"
+      @output[6].should == "#{STATUS}"
+    end
+  end
+
+  Scenario "update my status from command line with colorization enabled" do
+    When "application is launched 'update' command" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --colors update '#{STATUS}'}, "y")
+    end
+
+    Then "the status sent is shown" do
+      @output[5].should == "\e[32m#{TEST_USER}\e[0m, 9 hours ago:"
+      @output[6].should == "#{STATUS}"
+    end
+  end
+
+  Scenario "cancel a status from command line" do
+    When "application is launched 'update' command" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --colors update '#{STATUS}'}, "n")
+    end
+
+    Then "a cancellation message is shown" do
+      @output[3].should =~ /Cancelled./
+    end
+  end
+
+  Scenario "update my status from STDIN" do
+    When "application is launched 'update' command" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --no-colors update}, STATUS, "y")
+    end
+
+    Then "the status sent is shown" do
+      @output[0].should == "Status update: "
+      @output[5].should == "#{TEST_USER}, 9 hours ago:"
+      @output[6].should == "#{STATUS}"
+    end
+  end
+
+  Scenario "cancel a status update from STDIN" do
+    When "application is launched 'update' command" do
+      @output = launch_cli(%W{-a #{TEST_AUTH} --no-colors update}, STATUS, "n")
+    end
+
+    Then "a cancellation message is shown" do
+      @output[3].should =~ /Cancelled./
+    end
+  end
+end

data/lib/tweetwine/cli.rb

@@ -0,0 +1,241 @@
+require "optparse"
+
+module Tweetwine
+  class CLI
+    EXIT_HELP = 1
+    EXIT_VERSION = 2
+    EXIT_ERROR = 255
+
+    def self.launch(args, exec_name, config_file, extra_opts = {})
+      new(args, exec_name, config_file, extra_opts, &default_dependencies).execute(args)
+    rescue ArgumentError, HttpError => e
+      puts "Error: #{e.message}"
+      exit(EXIT_ERROR)
+    end
+
+    def execute(args)
+      if @config.command != :help
+        cmd_options = parse_command_options(@config.command, args)
+        @client.send(@config.command, args, cmd_options)
+      else
+        show_help_command_and_exit(args)
+      end
+    end
+
+    private
+
+    def self.default_dependencies
+      lambda do |options|
+        io = Tweetwine::IO.new(options)
+        http_client = RetryingHttp::Client.new(io)
+        url_shortener = lambda { |opts| UrlShortener.new(http_client, opts) }
+        Client::Dependencies.new(io, http_client, url_shortener)
+      end
+    end
+
+    def initialize(args, exec_name, config_file, extra_opts = {}, &dependencies_blk)
+      @global_option_parser = create_global_option_parser(exec_name)
+      @config = StartupConfig.new(Client::COMMANDS + [:help], Client::DEFAULT_COMMAND, extra_opts)
+      @config.parse(args, config_file, &@global_option_parser)
+      @client = Client.new(dependencies_blk.call(@config.options), @config.options) if @config.command != :help
+    end
+
+    def show_help_command_and_exit(args)
+      help_about_cmd = args.shift
+      if help_about_cmd
+        help_about_cmd = help_about_cmd.to_sym
+        parse_command_options(help_about_cmd, ["-h"]) if Client::COMMANDS.include?(help_about_cmd)
+      end
+      @global_option_parser.call(["-h"])
+    end
+
+    def self.create_option_parser
+      lambda do |args|
+        parsed_options = {}
+        begin
+          parser = OptionParser.new do |opt|
+            opt.on_tail("-h", "--help", "Show this help message and exit") {
+              puts opt
+              exit(EXIT_HELP)
+            }
+            schema = yield parsed_options
+            opt.banner = schema[:help]
+            schema[:opts].each do |opt_schema|
+              opt.on(*option_schema_to_ary(opt_schema), &opt_schema[:action])
+            end if schema[:opts]
+          end.order!(args)
+        rescue OptionParser::ParseError => e
+          raise ArgumentError, e.message
+        end
+        parsed_options
+      end
+    end
+
+    def self.option_schema_to_ary(opt_schema)
+      [:short, :long, :type, :desc].inject([]) do |result, key|
+        result << opt_schema[key] if opt_schema[key]
+        result
+      end
+    end
+
+    def create_global_option_parser(exec_name)
+      self.class.create_option_parser do |parsed|
+        {
+          :help => \
+"A simple but tasty Twitter agent for command line use, made for fun.
+
+Usage: #{exec_name} [global_options...] [command] [command_options...]
+
+  [command] is one of
+    * #{Client::COMMANDS[0...-1].join(",\n    * ")}, or
+    * #{Client::COMMANDS.last}.
+
+  The default command is #{Client::DEFAULT_COMMAND}.
+
+  [global_options]:
+",
+          :opts => [
+            {
+              :short  => "-a",
+              :long   => "--auth USERNAME:PASSWORD",
+              :desc   => "Authentication",
+              :action => lambda { |arg| parsed[:username], parsed[:password] = arg.split(":", 2) }
+            },
+            {
+              :short  => "-c",
+              :long   => "--colors",
+              :desc   => "Colorize output with ANSI escape codes",
+              :action => lambda { |arg| parsed[:colors] = true }
+            },
+            {
+              :short  => "-n",
+              :long   => "--num N",
+              :type   => Integer,
+              :desc   => "The number of statuses in page, default #{Client::DEFAULT_NUM_STATUSES}",
+              :action => lambda { |arg| parsed[:num_statuses] = arg }
+            },
+            {
+              :long   => "--no-colors",
+              :desc   => "Do not use ANSI colors",
+              :action => lambda { |arg| parsed[:colors] = false }
+            },
+            {
+              :long   => "--no-url-shorten",
+              :desc   => "Do not shorten URLs for status update",
+              :action => lambda { |arg| parsed[:shorten_urls] = { :enable => false } }
+            },
+            {
+              :short  => "-p",
+              :long   => "--page N",
+              :type   => Integer,
+              :desc   => "The page number for statuses, default #{Client::DEFAULT_PAGE_NUM}",
+              :action => lambda { |arg| parsed[:page_num] = arg }
+            },
+            {
+              :short  => "-v",
+              :long   => "--version",
+              :desc   => "Show version information and exit",
+              :action => lambda do |arg|
+                puts "#{exec_name} #{Tweetwine::VERSION}"
+                exit(EXIT_VERSION)
+              end
+            }
+          ]
+        }
+      end
+    end
+
+    def self.create_command_option_parser(command_name, schema)
+      create_option_parser do |parsed|
+        {
+          :help => \
+"#{command_name} [command_options...] #{schema[:help][:rest_args]}
+
+#{schema[:help][:desc]}
+
+  [command_options]:
+",
+          :opts => schema[:opts]
+        }
+      end
+    end
+
+    command_parser_schemas = {
+      :followers => {
+        :help => {
+          :desc => \
+"Show the followers of the authenticated user, together with the latest status
+of each follower."
+        }
+      },
+      :friends => {
+        :help => {
+          :desc => \
+"Show the friends of the authenticated user, together with the latest status of
+each friend."
+        }
+      },
+      :home => {
+        :help => {
+          :desc => \
+"Show the latest statuses of friends and own tweets (the home timeline of the
+authenticated user)."
+        }
+      },
+      :mentions => {
+        :help => {
+          :desc => \
+"Show the latest statuses that mention the authenticated user."
+        }
+      },
+      :search => {
+        :help => {
+          :rest_args  => "word_1 [word_2...]",
+          :desc       => \
+"Search the latest public statuses with one or more words."
+        },
+        :opts => [
+          {
+            :short  => "-a",
+            :long   => "--and",
+            :desc   => "All words must match",
+            :action => lambda { |arg| parsed[:bin_op] = :and }
+          },
+          {
+            :short  => "-o",
+            :long   => "--or",
+            :desc   => "Any word matches",
+            :action => lambda { |arg| parsed[:bin_op] = :or }
+          }
+        ]
+      },
+      :update => {
+        :help => {
+          :rest_args  => "[status]",
+          :desc       => \
+"Send a status update, but confirm the action first before actually sending.
+The status update can either be given as an argument or via STDIN if no
+[status] is given."
+        }
+      },
+      :user => {
+        :help => {
+          :rest_args  => "[username]",
+          :desc       => \
+"Show a specific user's latest statuses. The user is identified with [username]
+argument; if the argument is absent, the authenticated user's statuses are
+shown."
+        }
+      }
+    }
+
+    COMMAND_OPTION_PARSERS = Client::COMMANDS.inject({}) do |result, cmd|
+      result[cmd] = create_command_option_parser(cmd, command_parser_schemas[cmd])
+      result
+    end
+
+    def parse_command_options(command, args)
+      COMMAND_OPTION_PARSERS[command].call(args)
+    end
+  end
+end

data/lib/tweetwine/client.rb

@@ -3,22 +3,23 @@ require "uri"
 
 module Tweetwine
   class Client
-    Dependencies = Struct.new :io, :rest_client, :url_shortener
+    Dependencies = Struct.new :io, :http_client, :url_shortener
 
-    attr_reader :num_statuses, :page_num
-
-    COMMANDS = [:home, :mentions, :user, :update, :friends, :followers]
+    COMMANDS = [:followers, :friends, :home, :mentions, :search, :update, :user]
+    DEFAULT_COMMAND = :home
 
     DEFAULT_NUM_STATUSES = 20
     DEFAULT_PAGE_NUM = 1
     MAX_STATUS_LENGTH = 140
 
+    attr_reader :num_statuses, :page_num
+
     def initialize(dependencies, options)
       @io = dependencies.io
-      @rest_client = dependencies.rest_client
       @username = options[:username].to_s
       raise ArgumentError, "No authentication data given" if @username.empty?
-      @base_url = "https://#{@username}:#{options[:password]}@twitter.com/"
+      @http_client = dependencies.http_client
+      @http_resource = @http_client.as_resource("https://twitter.com", :user => @username, :password => options[:password])
       @num_statuses = Util.parse_int_gt(options[:num_statuses], DEFAULT_NUM_STATUSES, 1, "number of statuses_to_show")
       @page_num = Util.parse_int_gt(options[:page_num], DEFAULT_PAGE_NUM, 1, "page number")
       @url_shortener = if options[:shorten_urls] && options[:shorten_urls][:enable]
@@ -29,95 +30,131 @@ module Tweetwine
       @status_update_factory = StatusUpdateFactory.new(@io, @url_shortener)
     end
 
-    def home
-      show_statuses(get_response_as_json("statuses/friends_timeline", :num_statuses, :page))
+    def home(args = [], options = nil)
+      response = get_from_rest_api("statuses/home_timeline", :num_statuses, :page)
+      show_statuses_from_rest_api(*response)
     end
 
-    def mentions
-      show_statuses(get_response_as_json("statuses/mentions", :num_statuses, :page))
+    def mentions(args = [], options = nil)
+      response = get_from_rest_api("statuses/mentions", :num_statuses, :page)
+      show_statuses_from_rest_api(*response)
     end
 
-    def user(user = @username)
-      show_statuses(get_response_as_json("statuses/user_timeline/#{user}", :num_statuses, :page))
+    def user(args = [], options = nil)
+      user = if args.empty? then @username else args.first end
+      response = get_from_rest_api("statuses/user_timeline/#{user}", :num_statuses, :page)
+      show_statuses_from_rest_api(*response)
     end
 
-    def update(new_status = nil)
-      new_status = @status_update_factory.prepare(new_status)
+    def update(args = [], options = nil)
+      new_status = if args.empty? then nil else args.join(" ") end
+      new_status = @status_update_factory.create(new_status)
       completed = false
       unless new_status.empty?
         @io.show_status_preview(new_status)
         if @io.confirm("Really send?")
-          status = JSON.parse(post("statuses/update.json", {:status => new_status.to_s}))
+          response = post_to_rest_api("statuses/update", :status => new_status.to_s)
           @io.info "Sent status update.\n\n"
-          show_statuses([status])
+          show_statuses_from_rest_api(response)
           completed = true
         end
       end
       @io.info "Cancelled." unless completed
     end
 
-    def friends
-      show_users(get_response_as_json("statuses/friends/#{@username}", :page))
+    def friends(args = [], options = nil)
+      response = get_from_rest_api("statuses/friends/#{@username}")
+      show_users_from_rest_api(*response)
+    end
+
+    def followers(args = [], options = nil)
+      response = get_from_rest_api("statuses/followers/#{@username}")
+      show_users_from_rest_api(*response)
     end
 
-    def followers
-      show_users(get_response_as_json("statuses/followers/#{@username}", :page))
+    def search(args = [], options = nil)
+      raise ArgumentError, "No search word" if args.empty?
+      query = if options && options[:bin_op] == :or then args.join(" OR ") else args.join(" ") end
+      response = get_from_search_api(query, :num_statuses, :page)
+      show_statuses_from_search_api(*response["results"])
     end
 
     private
 
-    def get_response_as_json(url_body, *query_opts)
-      url = url_body + ".json?#{parse_query_options(query_opts)}"
-      JSON.parse(get(url))
+    def get_from_rest_api(sub_url, *query_opts)
+      query_str = query_options_to_string(query_opts, :page => "page", :num_statuses => "count")
+      url_suffix = unless query_str.empty? then "?" << query_str else "" end
+      JSON.parse(@http_resource[sub_url + ".json" + url_suffix].get)
     end
 
-    def parse_query_options(query_opts)
-      str = []
+    def post_to_rest_api(sub_url, payload)
+      JSON.parse(@http_resource[sub_url + ".json"].post(payload))
+    end
+
+    def get_from_search_api(query, *query_opts)
+      query_str = "q=#{Util.percent_encode(query)}&" \
+                << query_options_to_string(query_opts, :page => "page", :num_statuses => "rpp")
+      JSON.parse(@http_client.get("http://search.twitter.com/search.json?#{query_str}"))
+    end
+
+    def query_options_to_string(query_opts, key_mappings)
+      pairs = []
       query_opts.each do |opt|
         case opt
         when :page
-          str << "page=#{@page_num}"
+          pairs << "#{key_mappings[:page]}=#{@page_num}"
         when :num_statuses
-          str << "count=#{@num_statuses}"
-        # do nothing on else
+          pairs << "#{key_mappings[:num_statuses]}=#{@num_statuses}"
+        # else: ignore unknown query options
         end
       end
-      str.join("&")
+      pairs.join("&")
     end
 
-    def show_statuses(data)
-      show_responses(data) { |entry| [entry["user"], entry] }
-    end
-
-    def show_users(data)
-      show_responses(data) { |entry| [entry, entry["status"]] }
-    end
-
-    def show_responses(data)
-      data.each do |entry|
-        user_data, status_data = yield entry
-        @io.show_record(parse_response(user_data, status_data))
-      end
+    def show_statuses_from_rest_api(*responses)
+      show_records(
+        responses,
+        {
+          :from_user  => ["user", "screen_name"],
+          :to_user    => "in_reply_to_screen_name",
+          :created_at => "created_at",
+          :status     => "text"
+        }
+      )
     end
 
-    def parse_response(user_data, status_data)
-      record = { :user => user_data["screen_name"] }
-      if status_data
-        record[:status] = {
-          :created_at  => status_data["created_at"],
-          :in_reply_to => status_data["in_reply_to_screen_name"],
-          :text        => status_data["text"]
+    def show_users_from_rest_api(*responses)
+      show_records(
+        responses,
+        {
+          :from_user  => "screen_name",
+          :to_user    => ["status", "in_reply_to_screen_name"],
+          :created_at => ["status", "created_at"],
+          :status     => ["status", "text"]
         }
-      end
-      record
+      )
     end
 
-    def get(body_url)
-      @rest_client.get @base_url + body_url
+    def show_statuses_from_search_api(*responses)
+      show_records(
+        responses,
+        {
+          :from_user  => "from_user",
+          :to_user    => "to_user",
+          :created_at => "created_at",
+          :status     => "text"
+        }
+      )
     end
 
-    def post(body_url, body)
-      @rest_client.post @base_url + body_url, body
+    def show_records(twitter_records, paths)
+      twitter_records.each do |twitter_record|
+        internal_record = [ :from_user, :to_user, :created_at, :status ].inject({}) do |result, key|
+          result[key] = Util.find_hash_path(twitter_record, paths[key])
+          result
+        end
+        @io.show_record(internal_record)
+      end
     end
 
     class StatusUpdateFactory
@@ -126,7 +163,7 @@ module Tweetwine
         @url_shortener = url_shortener
       end
 
-      def prepare(status)
+      def create(status)
         StatusUpdate.new(status, @io, @url_shortener).to_s
       end
     end
@@ -168,7 +205,7 @@ module Tweetwine
         url_pairs.reject { |pair| pair.last.nil? || pair.last.empty? }.each do |url_pair|
           status.gsub!(url_pair.first, url_pair.last)
         end
-      rescue ClientError, LoadError => e
+      rescue HttpError, LoadError => e
         @io.warn "#{e}. Skipping URL shortening..."
       end
     end