tweetwine 0.2.12 → 0.3.0

data/lib/tweetwine/config.rb

@@ -0,0 +1,65 @@
+# coding: utf-8
+
+require "set"
+require "yaml"
+
+module Tweetwine
+  class Config
+    def self.read(args = [], default_config = {}, &cmd_option_parser)
+      new parse_options(args, default_config, &cmd_option_parser)
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def keys
+      @options.keys
+    end
+
+    def save
+      raise "No config file specified" unless @file
+      to_file = @options.reject { |key, _| @excludes.include? key }
+      should_set_file_access_to_user_only = !File.exist?(@file)
+      File.open(@file, 'w') do |io|
+        io.chmod(0600) if should_set_file_access_to_user_only
+        YAML.dump(Util.stringify_hash_keys(to_file), io)
+      end
+    end
+
+    private
+
+    def initialize(options)
+      @options = options
+      @file = options[:config_file]
+      @excludes = Set.new(options[:excludes] || []).merge([:config_file, :env_lookouts, :excludes])
+    end
+
+    def self.parse_options(args, default_config, &cmd_option_parser)
+      env_lookouts = default_config[:env_lookouts]
+      cmd_options = if cmd_option_parser then cmd_option_parser.call(args) else {} end
+      env_options = if env_lookouts then parse_env_vars(env_lookouts) else {} end
+      launch_options = env_options.merge(cmd_options)
+      config_file = launch_options[:config_file] || default_config[:config_file]
+      file_options = if config_file && File.file?(config_file) then parse_config_file(config_file) else {} end
+      default_config.merge(file_options.merge(launch_options))
+    end
+
+    def self.parse_env_vars(env_lookouts)
+      env_lookouts.inject({}) do |result, env_var_name|
+        env_option = ENV[env_var_name.to_s]
+        result[env_var_name.to_sym] = env_option unless Util.blank?(env_option)
+        result
+      end
+    end
+
+    def self.parse_config_file(config_file)
+      options = File.open(config_file, 'r') { |io| YAML.load(io) }
+      Util.symbolize_hash_keys(options)
+    end
+  end
+end

data/lib/tweetwine/http.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+require "net/http"
+require "uri"
+
+module Tweetwine
+  module Http
+    module Retrying
+      MAX_RETRIES = 3
+      RETRY_BASE_WAIT_TIMEOUT = 4
+
+      def retrying(max_retries = MAX_RETRIES, retry_base_wait_timeout = RETRY_BASE_WAIT_TIMEOUT)
+        retries = 0
+        begin
+          yield
+        rescue ConnectionError, TimeoutError
+          if retries < max_retries
+            retries += 1
+            timeout = retry_base_wait_timeout**retries
+            CLI.ui.warn("Could not connect -- retrying in #{timeout} seconds")
+            sleep timeout
+            retry
+          else
+            raise
+          end
+        end
+      end
+    end
+
+    class Client
+      include Retrying
+
+      def initialize(options = {})
+        @http = Net::HTTP::Proxy(*parse_proxy_url(options[:http_proxy]))
+      end
+
+      def get(url, headers = nil, &block)
+        retrying do
+          requesting(url) do |connection, uri|
+            req = Net::HTTP::Get.new(uri.request_uri, headers)
+            block.call(connection, req) if block
+            connection.request(req)
+          end
+        end
+      end
+
+      def post(url, payload = nil, headers = nil, &block)
+        retrying do
+          requesting(url) do |connection, uri|
+            req = Net::HTTP::Post.new(uri.request_uri, headers)
+            req.form_data = payload if payload
+            block.call(connection, req) if block
+            connection.request(req)
+          end
+        end
+      end
+
+      def as_resource(url)
+        Resource.new(self, url)
+      end
+
+      private
+
+      def parse_proxy_url(url)
+        return [nil, nil] unless url
+        url = url.sub(%r{\Ahttps?://}, '')  # remove possible scheme
+        proxy_addr, proxy_port = url.split(':', 2)
+        begin
+          proxy_port = proxy_port ? Integer(proxy_port) : 8080
+        rescue ArgumentError
+          raise CommandLineError, "invalid proxy port: #{proxy_port}"
+        end
+        [proxy_addr, proxy_port]
+      end
+
+      def requesting(url)
+        uri = URI.parse(url)
+        connection = @http.new(uri.host, uri.port)
+        configure_for_ssl(connection) if https_scheme?(uri)
+        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
+        raise ConnectionError, e
+      rescue Timeout::Error => e
+        raise TimeoutError, e
+      rescue Net::HTTPError => e
+        raise HttpError, e
+      end
+
+      def https_scheme?(uri)
+        uri.scheme == 'https'
+      end
+
+      def configure_for_ssl(connection)
+        connection.use_ssl = true
+        connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+
+    class Resource
+      def initialize(client, url)
+        @client = client
+        @url = url
+      end
+
+      def [](suburl)
+        self.class.new(@client, "#{@url}/#{suburl}")
+      end
+
+      def get(headers = nil, &block)
+        @client.get(@url, headers, &block)
+      end
+
+      def post(payload = nil, headers = nil, &block)
+        @client.post(@url, payload, headers, &block)
+      end
+    end
+  end
+end

data/lib/tweetwine/oauth.rb

@@ -0,0 +1,104 @@
+# coding: utf-8
+
+require "cgi"
+require "oauth"
+
+module Tweetwine
+  class OAuth
+    SEP = ':'
+    CON = Obfuscate.read(<<-END).split(SEP)
+enpGfklDSjc7K0s+cklwdipiRiY6cGk8J0U5diFfZHh0JzxnfD5lPzxJcXN6
+PitkPXNhYGh7M194Qyc2PHgrRkdn
+    END
+
+    def initialize(access = nil)
+      @access_key, @access_secret = *if access
+        Obfuscate.read(access).split(SEP)
+      else
+        ['', '']
+      end
+    end
+
+    def authorize
+      request_token = get_request_token
+      CLI.ui.info "Please authorize: #{request_token.authorize_url}"
+      pin = CLI.ui.prompt 'Enter PIN'
+      access_token = get_access_token(request_token, pin)
+      reset_access_token(access_token)
+      yield(obfuscate_access_token) if block_given?
+    end
+
+    def request_signer
+      @signer ||= lambda do |connection, request|
+        request.oauth! connection, consumer, access_token
+      end
+    end
+
+    private
+
+    def consumer
+      @consumer ||= ::OAuth::Consumer.new(CON[0], CON[1],
+        :site               => 'https://api.twitter.com',
+        :scheme             => :header,
+        :http_method        => :post,
+        :request_token_path => '/oauth/request_token',
+        :authorize_path     => '/oauth/authorize',
+        :access_token_path  => '/oauth/access_token')
+    end
+
+    def access_token
+      @access_token ||= ::OAuth::AccessToken.from_hash(consumer,
+        :oauth_token        => @access_key,
+        :oauth_token_secret => @access_secret)
+    end
+
+    def reset_access_token(access_token)
+      @access_token = access_token
+      @access_key = access_token.token
+      @access_secret = access_token.secret
+    end
+
+    def obfuscate_access_token
+      Obfuscate.write("#{@access_key}#{SEP}#{@access_secret}")
+    end
+
+    def get_request_token
+      response = http_request(consumer.request_token_url) do |connection, request|
+        request.oauth! connection, consumer, nil, :oauth_callback => 'oob'
+      end
+      ::OAuth::RequestToken.from_hash(consumer, response)
+    end
+
+    def get_access_token(request_token, pin)
+      response = http_request(consumer.access_token_url) do |connection, request|
+        request.oauth! connection, consumer, request_token, :oauth_verifier => pin
+      end
+      ::OAuth::AccessToken.from_hash(consumer, response)
+    end
+
+    def http_request(url, &block)
+      method = consumer.http_method
+      response = CLI.http.send(method, url) do |connection, request|
+        request['Content-Length'] = '0'
+        block.call(connection, request)
+      end
+      parse_url_encoding(response)
+    rescue HttpError => e
+      # Do not raise HttpError with 401 response since that is expected this
+      # module to deal with.
+      if (400...500).include? e.http_code
+        raise AuthorizationError, "Unauthorized to #{method.to_s.upcase} #{url} for OAuth: #{e}"
+      else
+        raise
+      end
+    end
+
+    def parse_url_encoding(response)
+      CGI.parse(response).inject({}) do |hash, (key, value)|
+        key = key.strip
+        hash[key] = hash[key.to_sym] = value.first
+        hash
+      end
+    end
+  end
+end

data/lib/tweetwine/obfuscate.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require "base64"
+
+module Tweetwine
+  module Obfuscate
+    extend self
+
+    def obfuscate(str)
+      str.tr("\x21-\x7e", "\x50-\x7e\x21-\x4f")
+    end
+
+    def read(str)
+      obfuscate(Base64.decode64(str))
+    end
+
+    def write(str)
+      Base64.encode64(obfuscate(str))
+    end
+  end
+end

data/lib/tweetwine/option_parser.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+
+require "optparse"
+
+module Tweetwine
+  # A wrapper for OptionParser in standard library that returns parsing
+  # results as a Hash.
+  #
+  # Not threadsafe.
+  class OptionParser
+    def initialize(&blk)
+      @options = {}
+      @parser = ::OptionParser.new do |parser|
+        blk.call(parser, @options)
+      end
+    end
+
+    def parse(args = ARGV)
+      @parser.order! args
+      result = @options.dup
+      @options.clear
+      result
+    rescue ::OptionParser::ParseError => e
+      raise CommandLineError, e.message
+    end
+
+    def help
+      @parser.summarize.join.chomp
+    end
+  end
+end

data/lib/tweetwine/promise.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+module Tweetwine
+  # Lazy evaluation via proxy object.
+  #
+  # A naive implementation, but it's enough.
+  #
+  # Adapted from the book Ruby Best Practices, by Gregory Brown.
+  class Promise < BasicObject
+    def initialize(&action)
+      @action = action
+    end
+
+    def __result__
+      if @action
+        @result = @action.call
+        @action = nil
+      end
+      @result
+    end
+
+    def inspect
+      if @action
+        "#<Tweetwine::Promise action=#{@action.inspect}>"
+      else
+        @result.inspect
+      end
+    end
+
+    def respond_to?(method)
+      method = method.to_sym
+      [:__result__, :inspect].include?(method) || __result__.respond_to?(method)
+    end
+
+    def method_missing(*args, &blk)
+      __result__.__send__(*args, &blk)
+    end
+  end
+end

data/lib/tweetwine/twitter.rb

@@ -0,0 +1,211 @@
+# coding: utf-8
+
+require "json"
+require "uri"
+
+module Tweetwine
+  class Twitter
+    DEFAULT_NUM_STATUSES = 20
+    DEFAULT_PAGE_NUM = 1
+    MAX_STATUS_LENGTH = 140
+
+    attr_reader :num_statuses, :page, :username
+
+    def initialize(options = {})
+      @num_statuses = Util.parse_int_gt(options[:num_statuses], DEFAULT_NUM_STATUSES, 1, "number of statuses to show")
+      @page         = Util.parse_int_gt(options[:page], DEFAULT_PAGE_NUM, 1, "page number")
+      @username     = options[:username].to_s
+    end
+
+    def followers
+      response = get_from_rest_api "statuses/followers"
+      show_users_from_rest_api(*response)
+    end
+
+    def friends
+      response = get_from_rest_api "statuses/friends"
+      show_users_from_rest_api(*response)
+    end
+
+    def home
+      response = get_from_rest_api "statuses/home_timeline"
+      show_statuses_from_rest_api(*response)
+    end
+
+    def mentions
+      response = get_from_rest_api "statuses/mentions"
+      show_statuses_from_rest_api(*response)
+    end
+
+    def search(words = [], operator = nil)
+      raise ArgumentError, "No search words" if words.empty?
+      operator = :and unless operator
+      query = operator == :and ? words.join(' ') : words.join(' OR ')
+      response = get_from_search_api query
+      show_statuses_from_search_api(*response["results"])
+    end
+
+    def update(msg = nil)
+      new_status = create_status_update(msg)
+      completed = false
+      unless new_status.empty?
+        CLI.ui.show_status_preview(new_status)
+        status_in_utf8 = CharacterEncoding.to_utf8 new_status
+        if CLI.ui.confirm("Really send?")
+          response = post_to_rest_api("statuses/update", :status => status_in_utf8)
+          CLI.ui.info "Sent status update.\n\n"
+          show_statuses_from_rest_api response
+          completed = true
+        end
+      end
+      CLI.ui.info "Cancelled." unless completed
+    end
+
+    def user(who = username)
+      response = get_from_rest_api(
+        "statuses/user_timeline",
+        common_rest_api_query_params.merge!({ :screen_name => who })
+      )
+      show_statuses_from_rest_api(*response)
+    end
+
+    private
+
+    def common_rest_api_query_params
+      {
+        :count => @num_statuses,
+        :page  => @page
+      }
+    end
+
+    def common_search_api_query_params
+      {
+        :rpp  => @num_statuses,
+        :page => @page
+      }
+    end
+
+    def format_query_params(params)
+      params.each_pair.map { |k, v| "#{k}=#{v}" }.sort.join('&')
+    end
+
+    def rest_api
+      @rest_api ||= CLI.http.as_resource "https://api.twitter.com/1"
+    end
+
+    def search_api
+      @search_api ||= CLI.http.as_resource "http://search.twitter.com"
+    end
+
+    def get_from_rest_api(sub_url, params = common_rest_api_query_params)
+      query = format_query_params(params)
+      url_suffix = query.empty? ? "" : "?" << query
+      resource = rest_api["#{sub_url}.json#{url_suffix}"]
+      authorize_on_demand do
+        JSON.parse resource.get(&CLI.oauth.request_signer)
+      end
+    end
+
+    def post_to_rest_api(sub_url, payload)
+      resource = rest_api["#{sub_url}.json"]
+      authorize_on_demand do
+        JSON.parse resource.post(payload, &CLI.oauth.request_signer)
+      end
+    end
+
+    def get_from_search_api(query, params = common_search_api_query_params)
+      query = "q=#{Util.percent_encode(query)}&" << format_query_params(params)
+      JSON.parse search_api["search.json?#{query}"].get
+    end
+
+    def authorize_on_demand
+      yield
+    rescue HttpError => e
+      if e.http_code == 401
+        CLI.oauth.authorize { |access_token| save_config_with_access_token(access_token) }
+        retry
+      else
+        raise
+      end
+    end
+
+    def save_config_with_access_token(token)
+      CLI.config[:oauth_access] = token
+      CLI.config.save
+    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 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
+
+    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 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
+        CLI.ui.show_record(internal_record)
+      end
+    end
+
+    def create_status_update(status)
+      status = if Util.blank? status
+        CLI.ui.prompt("Status update")
+      else
+        status.dup
+      end
+      status.strip!
+      shorten_urls_in(status) if CLI.config[:shorten_urls] && !CLI.config[:shorten_urls][:disable]
+      truncate_status(status) if status.length > MAX_STATUS_LENGTH
+      status
+    end
+
+    def shorten_urls_in(status)
+      url_pairs = URI.
+          extract(status, %w{http http}).
+          uniq.
+          map { |full_url| [full_url, CLI.url_shortener.shorten(full_url)] }.
+          reject { |(full_url, short_url)| Util.blank? short_url }
+      url_pairs.each { |(full_url, short_url)| status.gsub!(full_url, short_url) }
+    rescue HttpError, LoadError => e
+      CLI.ui.warn "#{e}\nSkipping URL shortening..."
+    end
+
+    def truncate_status(status)
+      status.replace status[0...MAX_STATUS_LENGTH]
+      CLI.ui.warn("Status will be truncated.")
+    end
+  end
+end

data/lib/tweetwine/{io.rb → ui.rb}

@@ -1,47 +1,56 @@
 # coding: utf-8
 
-require "strscan"
 require "uri"
 
 module Tweetwine
-  class IO
+  class UI
     COLOR_CODES = {
       :cyan     => 36,
       :green    => 32,
       :magenta  => 35,
       :yellow   => 33
-    }
-
+    }.freeze
     HASHTAG_REGEX = /#[\w-]+/
     USERNAME_REGEX = /^(@\w+)|\s+(@\w+)/
 
-    def initialize(options)
-      @input = options[:input] || $stdin
-      @output = options[:output] || $stdout
-      @colors = options[:colors] || false
+    def initialize(options = {})
+      @in     = options[:in]      || $stdin
+      @out    = options[:out]     || $stdout
+      @err    = options[:err]     || $stderr
+      @colors = options[:colors]  || false
     end
 
-    def prompt(prompt)
-      @output.print "#{prompt}: "
-      @input.gets.strip!
+    def info(start_msg = "\n", end_msg = " done.")
+      if block_given?
+        @out.print start_msg
+        yield
+        @out.puts end_msg
+      else
+        @out.puts start_msg
+      end
     end
 
-    def info(msg)
-      @output.puts(msg)
+    def error(msg)
+      @err.puts "ERROR: #{msg}"
     end
 
     def warn(msg)
-      @output.puts "Warning: #{msg}"
+      @out.puts "Warning: #{msg}"
+    end
+
+    def prompt(prompt)
+      @out.print "#{prompt}: "
+      @in.gets.strip!
     end
 
     def confirm(msg)
-      @output.print "#{msg} [yN] "
-      confirmation = @input.gets.strip
+      @out.print "#{msg} [yN] "
+      confirmation = @in.gets.strip
       confirmation.downcase[0, 1] == "y"
     end
 
     def show_status_preview(status)
-      @output.puts <<-END
+      @out.puts <<-END
 
 #{format_status(status)}
 
@@ -73,14 +82,14 @@ module Tweetwine
     end
 
     def show_record_as_user(record)
-      @output.puts <<-END
+      @out.puts <<-END
 #{format_user(record[:from_user])}
 
       END
     end
 
     def show_record_as_user_with_status(record)
-      @output.puts <<-END
+      @out.puts <<-END
 #{format_record_header(record[:from_user], record[:to_user], record[:created_at])}
 #{format_status(record[:status])}
 
@@ -97,7 +106,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, ["http", "https"]).uniq)
+        status = colorize_matching(:cyan, status, URI.extract(status, %w{http https}).uniq)
       end
       status
     end
@@ -122,7 +131,7 @@ module Tweetwine
       when Regexp
         pattern
       else
-        raise "Unknown kind of pattern"
+        raise "unknown kind of pattern"
       end
       Util.str_gsub_by_group(str, regexp) { |s| colorize(color, s) }
     end