termtter 1.9.0 → 1.10.0

data/lib/plugins/truncate.rb

@@ -5,10 +5,20 @@ def multibyte_string(text)
 end
 
 def truncate(text, length = 140, omission = "...")
-  o = multibyte_string(omission)
-  l = length - o.length
   chars = multibyte_string(text)
-  chars.length > length ? (chars[0...l] + o).pack('U*') : text
+  if chars.length > length
+    _, text_base, urls =
+      text.match(/\A(.*?)((?:\s+#{URI.regexp(%w(http https ftp))}\S*)*)\z/).to_a
+    chars_base = multibyte_string(text_base)
+    o = multibyte_string(omission + urls)
+    if o.length >= length
+      o = multibyte_string(omission)
+      chars_base = chars
+    end
+    (chars_base[0...(length - o.length)] + o).pack('U*')
+  else
+    text
+  end
 end
 
 Termtter::RubytterProxy.register_hook(

data/lib/plugins/update_editor.rb

@@ -34,7 +34,7 @@ module Termtter::Client
                        text.split("\n").each do |post|
                          break if post =~ /^__END__$/
                          unless post.empty?
-                           Termtter::API.twitter.update(post)
+                           execute("update #{post}")
                            puts "=> #{post}"
                          end
                        end

data/lib/plugins/url.rb

@@ -0,0 +1,11 @@
+def url_by_tweet(t)
+  "http://twitter.com/#{t.user.screen_name}/status/#{t.id}"
+end
+
+Termtter::Client.register_command(:name => :url,
+                                  :exec => lambda do |arg|
+  t = Termtter::API.twitter.show(arg)
+  puts url_by_tweet(t)
+end)
+
+

data/lib/plugins/user_stream.rb

@@ -1,3 +1,53 @@
+module Termtter
+  class UserStreamReceiver
+
+    def run(&block)
+      loop {
+        begin
+          self.process &block
+        rescue => error
+          Termtter::Client.handle_error error
+          sleep 10
+        end
+      }
+    end
+
+    def self.repack_error(error, chunk)
+      new_error = error.class.new("#{error.message} (#{JSON.parse(chunk).inspect})")
+      error.instance_variables.each{ |v|
+        new_error.instance_variable_set(v, error.instance_variable_get(v))
+      }
+      new_error
+    rescue
+      error
+    end
+
+    protected
+    ENDPOINT = URI.parse('https://userstream.twitter.com/2/user.json')
+
+    def process(&block)
+      Termtter::Client.logger.info("connecting to UserStream")
+      https = Net::HTTP.new(ENDPOINT.host, ENDPOINT.port)
+      https.use_ssl = true
+      https.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      https.start{ |https|
+        request = Net::HTTP::Get.new(ENDPOINT.request_uri)
+        request.oauth!(https, Termtter::API.twitter.access_token.consumer, Termtter::API.twitter.access_token)
+        https.request(request){ |response|
+          raise StandardError, response.code.to_i unless response.code.to_i == 200
+          raise StandardError, 'Response is not chuncked' unless response.chunked?
+          Termtter::Client.logger.info("connected to UserStream")
+          response.read_body{ |chunk|
+            Termtter::Client.logger.debug("received: #{chunk}")
+            yield chunk
+          }
+        }
+      }
+    end
+  end
+end
+
 module Termtter::Client
   register_command(:"user_stream stop", :help => 'user_stream stop') do |arg|
     logger.info 'stopping user stream'
@@ -5,11 +55,13 @@ module Termtter::Client
       @user_stream_thread.exit
     end
     @user_stream_thread = nil
+    plug "defaults/auto_reload"
   end
 
   handle_chunk = lambda { |chunk|
     data = Termtter::ActiveRubytter.new(JSON.parse(chunk)) rescue return
     Termtter::Client.logger.debug "user_stream: received #{JSON.parse(chunk).inspect}"
+    Termtter::Client.clear_line
     begin
       if data[:event]
         if /list_/ =~ data[:event]
@@ -34,79 +86,52 @@ module Termtter::Client
       elsif data[:friends]
         puts "You have #{data[:friends].length} friends."
       elsif data[:delete]
-        status = Termtter::API.twitter.safe.show(data.delete.status.id)
-        puts "#{status.user.screen_name} deleted: #{status.text}"
+        # status = Termtter::API.twitter.cached_status(data.delete.status.id)
+        # puts "#{status.user.screen_name} deleted: #{status.text}"
+      elsif data[:direct_message]
+        dm = data[:direct_message]
+        sender = dm.sender
+        text = dm.text
+        puts "[DM] #{sender.screen_name}: #{text}"
       else
-        output([data], Termtter::Event.new(:update_friends_timeline, :type => :main))
         Termtter::API.twitter.store_status_cache(data)
+        output([data], :update_friends_timeline)
       end
-    rescue Termtter::RubytterProxy::FrequentAccessError
-      # ignore
     rescue Timeout::Error, StandardError => error
-      new_error = error.class.new("#{error.message} (#{JSON.parse(chunk).inspect})")
-      error.instance_variables.each{ |v|
-        new_error.instance_variable_set(v, error.instance_variable_get(v))
-      }
-      handle_error new_error
+      Termtter::Client.handle_error Termtter::UserStreamReceiver.repack_error(error, chunk)
+    ensure
+      Readline.refresh_line
     end
   }
 
   register_command(:"user_stream", :help => 'user_stream') do |arg|
-    unless config.password.kind_of? String
-      raise "config.password is required."
-    end
-
-    uri = URI.parse('http://betastream.twitter.com/2b/user.json')
-
-    unless @user_stream_thread
-      logger.info 'checking API status'
-      1.times{ # to use break
-        Net::HTTP.start(uri.host, uri.port){ |http|
-          request = Net::HTTP::Get.new(uri.request_uri)
-          request.basic_auth(config.user_name, config.password)
-          http.request(request){ |response|
-            raise response.code.to_i unless response.code.to_i == 200
-            break
-          }
-        }
-      }
-      logger.info 'API seems working'
-    end
 
     execute('user_stream stop') if @user_stream_thread
     delete_task(:auto_reload)
 
     @user_stream_thread = Thread.new {
-      loop do
-        begin
-          logger.info 'connecting to user stream'
-          Net::HTTP.start(uri.host, uri.port){ |http|
-            request = Net::HTTP::Get.new(uri.request_uri)
-            request.basic_auth(config.user_name, config.password)
-            http.request(request){ |response|
-              raise response.code.to_i unless response.code.to_i == 200
-              raise 'Response is not chuncked' unless response.chunked?
-              response.read_body{ |chunk|
-                handle_chunk.call(chunk)
-              }
-            }
-          }
-        rescue Timeout::Error, StandardError => e
-          handle_error e
-          logger.info 'sleeping'
-          sleep 10
-        end
-      end
+      Termtter::UserStreamReceiver.new.run{|chunk|
+        call_hooks(:user_stream_receive, chunk)
+      }
     }
   end
 
   register_hook(
     :name => :user_stream_init,
-    :author => '?', # FIXME
     :point => :initialize,
     :exec => lambda {
       execute('user_stream')
     })
+
+  register_hook(
+    :name => :user_stream_print,
+    :point => :user_stream_receive,
+    :exec => lambda {|chunk|
+      Thread.new {
+        handle_chunk.call(chunk)
+      }
+    })
+
 end
 
 # user_stream.rb

data/lib/termtter.rb

@@ -43,6 +43,7 @@ module Termtter
   OptParser.parse!(ARGV)
   CONF_DIR = File.expand_path('~/.termtter') unless defined? CONF_DIR
   CONF_FILE = File.join(Termtter::CONF_DIR, 'config') unless defined? CONF_FILE
+  config.token_file = File.join(Termtter::CONF_DIR, config.token_file_name)
   $:.unshift(CONF_DIR)
 
   CONSUMER_KEY = 'eFFLaGJ3M0VMZExvNmtlNHJMVndsQQ=='

data/lib/termtter/active_rubytter.rb

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
-gem 'rubytter', '>= 0.6.5'
 require 'rubytter'
+raise Gem::LoadError, 'Could not find RubyGem rubytter (>= 0.6.5)' \
+  unless Rubytter::VERSION >= '0.6.5'
 
 module Termtter
   class ActiveRubytter
@@ -17,11 +18,7 @@ module Termtter
     end
 
     def method_missing(name, *args)
-      if @data.key?(name)
-        return @data[name]
-      else
-        super
-      end
+      @data[name]
     end
 
     def attributes=(raw_hash)

data/lib/termtter/api.rb

@@ -2,9 +2,9 @@
 
 config.set_default(:host, 'api.twitter.com')
 config.set_default(:oauth_consumer_site, 'http://api.twitter.com')
-if ENV.has_key?('HTTP_PROXY')
+if ENV['HTTP_PROXY'] || ENV['http_proxy']
   require 'uri'
-  proxy = ENV['HTTP_PROXY']
+  proxy = ENV['HTTP_PROXY'] || ENV['http_proxy']
   proxy = "http://" + proxy if proxy !~ /^http:\/\//
   u = URI.parse(proxy)
   config.proxy.set_default(:host, u.host)
@@ -50,12 +50,12 @@ module Termtter
       end
       
       def authorize_by_oauth(show_information=false, save_to_token_file=true, put_to_config=true, verbose=true)
-        puts '1. Contacting to twitter...' if verbose
+        puts '1. Connecting to twitter...' if verbose
 
         request_token = consumer.get_request_token
 
-        puts '2. URL for authorize: ' + request_token.authorize_url if verbose
-        puts '   Opening web page to authorization...' if verbose
+        puts '2. Authorization URL: ' + request_token.authorize_url if verbose
+        puts '   Opening authorization web page...' if verbose
 
         begin
           open_browser(request_token.authorize_url)
@@ -67,7 +67,7 @@ module Termtter
         ui = create_highline
         pin = ui.ask('3. Enter PIN: ')
         puts ""
-        puts "4. Getting access_token..."
+        puts "4. Fetching access_token..."
         access_token = request_token.get_access_token(:oauth_verifier => pin)
 
         if put_to_config
@@ -83,7 +83,7 @@ module Termtter
           end
         end
 
-        puts "Authorize is successfully done."
+        puts "Authorization successfully completed."
 
         return {:token  => access_token.token,
                 :secret => access_token.secret}
@@ -94,7 +94,7 @@ module Termtter
           Termtter::Crypt.decrypt(CONSUMER_KEY),
           Termtter::Crypt.decrypt(CONSUMER_SECRET),
           :site => config.oauth_consumer_site,
-          :proxy => ENV['http_proxy']
+          :proxy => proxy_string
         )
       end
 
@@ -115,6 +115,16 @@ module Termtter
           :proxy_password => config.proxy.password
         }
       end
+
+      def proxy_string
+        return unless config.proxy.host
+        if config.proxy.user_name && config.proxy.password
+          "http://#{config.proxy.user_name}:#{config.proxy.password}@#{config.proxy.host}:#{config.proxy.port}"
+        else
+          "http://#{config.proxy.host}:#{config.proxy.port}"
+        end
+      end
+
     end
   end
 end

data/lib/termtter/client.rb

@@ -19,7 +19,8 @@ module Termtter
     class << self
       attr_reader :commands, :logger, :task_manager
 
-      # plug :: Name -> (Hash) -> IO () where NAME = String | Symbol | [NAME]
+      # call-seq:
+      #   plug :: Name -> (Hash) -> IO () where NAME = String | Symbol | [NAME]
       def plug(name, options = {})
         if Array === name # Obviously `name.respond_to?(:each)` is better, but for 1.8.6 compatibility we cannot.
           name.each {|i| plug(i, options) }
@@ -116,7 +117,7 @@ module Termtter
       #             :text => status,
       #             :original_data => original data,
       #           }
-      def output(statuses, event)
+      def output(statuses, event = :default)
         return if statuses.nil? || statuses.empty?
         event = Termtter::Event.new(event) unless event.kind_of? Termtter::Event
 
@@ -132,7 +133,7 @@ module Termtter
 
         call_hooks(:post_filter, filtered, event)
         get_hooks(:output).each do |hook|
-          Termtter::Client.logger.debug "output: call hook :output #{hook.inspect}"
+          Termtter::Client.logger.debug { "output: call hook :output #{hook.inspect}" }
           hook.call(
             apply_filters_for_hook(:"filter_for_#{hook.name}", filtered, event),
             event)
@@ -232,6 +233,10 @@ module Termtter
           ConfigSetup.run
         end
         load Termtter::CONF_FILE
+        unless config.dmsg_permission
+          require 'termtter/config_setup'
+          ConfigSetup.reauth
+        end
       end
 
       def legacy_config_support
@@ -261,6 +266,7 @@ module Termtter
       def setup_logger
         @logger = config.logger || default_logger
         @logger.level = config.devel ? Logger::DEBUG : Logger::INFO
+        call_hooks(:post_setup_logger)
         @logger
       end
 
@@ -314,24 +320,20 @@ module Termtter
 
       def run
         parse_options
-        config.__freeze__(:user_name) unless config.user_name.empty?
-        show_splash
+        show_splash unless config.system.cmd_mode
         setup_task_manager
         load_config
         load_plugins
         eval_init_block
-        config.__unfreeze__(:user_name)
-        Termtter::API.setup
-
-        config.system.eval_scripts.each do |script|
-          begin
-            eval script
-          rescue Exception => e
-            handle_error(e)
-          end
+        begin
+          Termtter::API.setup
+        rescue Rubytter::APIError => e
+          handle_error(e)
+          exit!
         end
 
-        config.system.run_commands.each {|cmd| execute(cmd) }
+        config.system.eval_scripts.each {|script| rescue_error { eval script }}
+        config.system.run_commands.each {|cmd| rescue_error { execute(cmd) }}
 
         unless config.system.cmd_mode
           @task_manager.run()
@@ -344,13 +346,23 @@ module Termtter
       end
 
       def handle_error(e)
-        message = e.message
-        message = message[0..29] + " ..." if message.size >= 30 && !config.devel
-        logger.error("#{e.class.to_s}: #{message}")
+        logger.error("#{e.class.to_s}: #{e.message}")
         logger.error(e.backtrace.join("\n")) if (e.backtrace and config.devel)
         get_hooks(:on_error).each {|hook| hook.call(e) }
       end
 
+      def rescue_error
+        begin
+          yield
+        rescue Exception => e
+          handle_error(e)
+        end
+      end
+
+      def clear_line
+        print "\e[0G" + "\e[K" unless win?
+      end
+
       def confirm(message, default_yes = true, &block)
         pause # TODO: TaskManager から呼ばれるならこれいらないなぁ
 

data/lib/termtter/command.rb

@@ -28,7 +28,8 @@ module Termtter
       set cfg
     end
 
-    # set :: Hash -> ()
+    # call-seq:
+    #   set :: Hash -> ()
     def set(cfg)
       self.name             = cfg[:name].to_sym
       self.aliases          = cfg[:aliases]
@@ -38,7 +39,8 @@ module Termtter
       self.author           = cfg[:author]
     end
 
-    # complement :: String -> [String]
+    # call-seq:
+    #   complement :: String -> [String]
     def complement(input)
       input = input.sub(/^\s*/, '')
       if match?(input) && input =~ /^[^\s]+\s/
@@ -53,7 +55,8 @@ module Termtter
       end
     end
 
-    # call :: ???
+    # call-seq:
+    #   call :: ???
     def call(cmd = nil, arg = nil, original_text = nil)
       from = Time.now
       arg = case arg
@@ -64,27 +67,30 @@ module Termtter
         else
           raise ArgumentError, 'arg should be String or nil'
         end
-      Termtter::Client.logger.debug "command: #{cmd} #{arg}"
+      Termtter::Client.logger.debug { "command: #{cmd} #{arg}" }
       result = exec_proc.call(arg)
-      Termtter::Client.logger.debug "command: #{cmd} #{arg} #{'%.2fsec' % (Time.now - from)}"
+      Termtter::Client.logger.debug { "command: #{cmd} #{arg} #{'%.2fsec' % (Time.now - from)}" }
       result
     rescue => e
-      Termtter::Client.logger.debug "command: #{cmd} #{arg} #{e.message} #{'%.2fsec' % (Time.now - from)}"
+      Termtter::Client.logger.debug { "command: #{cmd} #{arg} #{e.message} #{'%.2fsec' % (Time.now - from)}" }
       raise e
     end
 
-    # match? :: String -> Boolean
+    # call-seq:
+    #   match? :: String -> Boolean
     def match?(input)
       !!pattern.match(input)
     end
 
-    # pattern :: Regexp
+    # call-seq:
+    #   pattern :: Regexp
     def pattern
       commands_regex = commands.map {|name| name.to_s.split(' ').map {|i| Regexp.quote(i)}.join('\s+') }.join('|')
-      /^\s*((#{commands_regex})|(#{commands_regex})\s+(.*?))\s*$/
+      /^\s*((#{commands_regex})|(#{commands_regex})(?:\s+|\b)(.*?))\s*$/
     end
 
-    # commands :: [Symbol]
+    # call-seq:
+    #   commands :: [Symbol]
     def commands
       [name] + aliases
     end
@@ -93,12 +99,14 @@ module Termtter
       @aliases = as.map { |a| a.to_sym }
     end
 
-    # alias= :: Symbol -> ()
+    # call-seq:
+    #   alias= :: Symbol -> ()
     def alias=(a)
       self.aliases = [a]
     end
 
-    # author= :: String -> ()
+    # call-seq:
+    #   author= :: String -> ()
     def author=(a)
       @author = a
     end
@@ -107,7 +115,8 @@ module Termtter
       name.to_s.split(/\s+/)
     end
 
-    # split_command_line :: String -> (String, String)
+    # call-seq:
+    #   split_command_line :: String -> (String, String)
     def split_command_line(line)
       m = pattern.match(line)
       if m