termtter 1.8.0 → 1.9.0

data/lib/plugins/mudan_kinshi.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+# http://twitter.com/ototorosama/status/14283311303
+
+Termtter::Client.register_hook(
+  :name => :mudan_kinshi,
+  :author => 'Sora Harakami',
+  :point => :pre_coloring,
+  :exec => lambda {|r,e|
+    r.gsub(/無断(.+?)禁止/) {|s|
+      "か、勝手に#{$1}しないでよね!! ...バカ....."
+    }
+  }
+)

data/lib/plugins/ndkn.rb

@@ -0,0 +1,7 @@
+Termtter::Client.register_command(
+  :name => :ndkn,
+  :exec => lambda do |arg|
+    n = Termtter::Crypt.crypt(arg)
+    puts "ndkned => #{n.inspect}"
+  end
+)

data/lib/plugins/other_user.rb

@@ -0,0 +1,47 @@
+require 'base64'
+
+config.plugins.other_user.set_default(:accounts,{})
+config.plugins.other_user.set_default(:tokens_file,"~/.termtter/other_user_tokens")
+config.plugins.other_user.set_default(:alias,{})
+
+Termtter::Client.register_command(
+  :name => :other_user,
+  :alias => :o,
+  :help => ['other_user, o','Post by other user'],
+  :exec => lambda do |arg_raw|
+  tokens =
+    if File.exist?(File.expand_path(config.plugins.other_user.tokens_file))
+      Marshal.load(
+        Base64.decode64(File.read(File.expand_path(
+          config.plugins.other_user.tokens_file))))
+    else
+      {}
+    end
+
+    body = arg_raw.split(/ /)
+    user_raw = body.shift
+    user = config.plugins.other_user.alias[user_raw] || user_raw
+
+    unless tokens[user]
+      puts "<on_red>ERROR</on_red> #{user} isn't authorized yet. Starting authorization...".termcolor
+      tokens[user] = Termtter::API.authorize_by_oauth(false,false,false)
+      open(File.expand_path(config.plugins.other_user.tokens_file), 'w') do |f|
+        f.print Base64.encode64(Marshal.dump(tokens))
+      end
+    end
+
+    at = OAuth::AccessToken.new(
+      OAuth::Consumer.new(
+        Termtter::Crypt.decrypt(Termtter::CONSUMER_KEY),
+        Termtter::Crypt.decrypt(Termtter::CONSUMER_SECRET),
+        :site => "http://twitter.com/",
+        :proxy => ENV['http_proxy']),
+        tokens[user][:token],
+        tokens[user][:secret])
+
+    t = OAuthRubytter.new(at, Termtter::API.twitter_option)
+    t.update(body.join(' '))
+
+    puts "updated by #{user} => #{body.join(' ')}"
+  end
+)

data/lib/plugins/reply_sound.rb

@@ -1,33 +1,83 @@
 #-*- coding: utf-8 -*-
 
-# FIXME: Currently this plugin is available only on Mac OS X.
+config.plugins.reply_sound.set_default(:interval, 600)
 
-if RUBY_PLATFORM =~ /darwin/i
-  config.plugins.reply_sound.set_default(:interval, 600)
-  config.plugins.reply_sound.set_default(
-    :sound_file, '/System/Library/Sounds/Hero.aiff')
+nul_port = /mswin/i =~ RUBY_PLATFORM ? "NUL" : "/dev/null"
 
-  reply_sound_cache = nil
-  reply_sound_cache_ids = []
+reply_sound_cache = nil
+reply_sound_cache_ids = []
+not_supported = false
+cmd_ok = false
 
-  Termtter::Client.add_task(
-    :name => :reply_sound,
-    :interval => config.plugins.reply_sound.interval) do
-    replies = Termtter::API.twitter.replies
-    new_replies = replies.delete_if {|x| reply_sound_cache_ids.index(x[:id]) }
-    if !reply_sound_cache.nil? && new_replies.size > 0
-      if respond_to? :spawn, true
-        system 'afplay "'+config.plugins.reply_sound.sound_file+'" 2>/dev/null &'
+
+Termtter::Client.register_hook(
+  :name => :reply_sound_initialization,
+  :point => :initialize,
+  :exec => lambda do
+    case RUBY_PLATFORM
+    when /darwin/i
+      config.plugins.reply_sound.set_default(
+        :sound_file, '/System/Library/Sounds/Hero.aiff')
+      config.plugins.reply_sound.set_default(
+        :command, ['afplay', config.plugins.reply_sound.sound_file, {:out => nul_port, :err => nul_port}])
+      cmd_ok = true
+    when /linux/i
+      case `uname -v`.chomp
+      when /ubuntu/i
+        config.plugins.reply_sound.set_default(
+          :sound_file, '/usr/share/sounds/gnome/default/alerts/drip.ogg')
       else
-        spawn 'afplay', config.plugins.reply_sound.sound_file, :out => '/dev/null'
+        config.plugins.reply_sound.set_default(
+          :sound_file, '')
+      end
+    else
+      not_supported = true
+      puts TermColor.parse(
+        "<red>WARNING: Currently reply_sound plugin is not supported yet in your environment.</red>")
+    end
+
+    unless cmd_ok
+      begin
+        if /mplayer/i =~ `mplayer -v`.chomp
+          config.plugins.reply_sound.set_default(
+            :command, ['mplayer', config.plugins.reply_sound.sound_file, :out => nul_port, :err => nul_port])
+          cmd_ok = true
+          not_supported = false
+        end
+      rescue Errno::ENOENT
       end
-      Termtter::Client.output(
-        new_replies, Termtter::Event.new(:new_replies,:type => :reply))
     end
-    reply_sound_cache = replies
-    reply_sound_cache_ids += replies.map {|x| x[:id]}
-  end
-else
-  puts TermColor.parse(
-    "<red>WARNING: Currently reply_sound plugin is available only on Mac OS X.</red>")
-end
+
+    unless not_supported
+      Termtter::Client.add_task(
+        :name => :reply_sound_wait,
+        :interval => 10) do
+          Termtter::Client.add_task(
+            :name => :reply_sound,
+            :interval => config.plugins.reply_sound.interval) do
+              cmd = config.plugins.reply_sound.command.kind_of?(Array) ?
+                config.plugins.reply_sound.command : [config.plugins.reply_sound.command]
+              replies = Termtter::API.twitter.replies
+              new_replies = replies.delete_if {|x| reply_sound_cache_ids.index(x[:id]) }
+              if !reply_sound_cache.nil? && new_replies.size > 0
+                if respond_to? :spawn, true
+                  if respond_to? :fork, true
+                    fork { exec *cmd }
+                  else
+                    system *cmd
+                  end
+                else
+                  spawn *cmd
+                end
+                print "\e[0G" + "\e[K" unless win?
+                Termtter::Client.output(
+                  new_replies, Termtter::Event.new(:new_replies,:type => :reply))
+                Readline.refresh_line
+              end
+              reply_sound_cache = replies
+              reply_sound_cache_ids += replies.map {|x| x[:id]}
+            end
+          Termtter::Client.delete_task(:reply_sound_wait)
+        end
+    end
+  end)

data/lib/plugins/ruby-v.rb

@@ -0,0 +1,10 @@
+module Termtter::Client
+  register_command(
+    :name => 'ruby-v',
+    :author => 'ujihisa',
+    :help => ["ruby-v", "Post the Ruby version you are using"],
+    :exec_proc => lambda {|_|
+      result = Termtter::API.twitter.update("#{RUBY_DESCRIPTION} #termtterrubyversion")
+      puts "=> " << result.text
+  })
+end

data/lib/plugins/time_signal.rb

@@ -0,0 +1,21 @@
+config.plugins.time_signal.set_default(:minutes, [0])
+
+last_signal_time = nil
+
+Termtter::Client.add_task(:name => :time_signal, :interval => 10) do
+  begin
+    now = Time.now
+    if config.plugins.time_signal.minutes.include?(now.min)
+      hour = now.strftime('%H:%M')
+      unless hour == last_signal_time
+        print "\e[0G\e[2K"
+        puts "<on_green> #{hour} </on_green>".termcolor
+        Termtter::Client.notify 'time signal', hour
+        Readline.refresh_line
+        last_signal_time = hour
+      end
+    end
+  rescue Exception => e
+    Termtter::Client.handle_error(e)
+  end
+end

data/lib/plugins/tinyurl.rb

@@ -10,11 +10,14 @@ config.plugins.tinyurl.set_default(:ignore_regexp, %r{
     \Ahttp://bit\.ly/ | \Ahttp://tinyurl\.com/ | \Ahttp://is\.gd/
   | \Ahttp://ff\.im/ | \Ahttp://j\.mp/ | \Ahttp://goo\.gl/
   | \Ahttp://tr\.im/ | \Ahttp://short\.to/ | \Ahttp://ow\.ly/
-  | \Ahttp://u\.nu/ | \Ahttp://twurl\.nl/
+  | \Ahttp://u\.nu/ | \Ahttp://twurl\.nl/  | \Ahttp://icio\.us/
+  | \Ahttp://htn\.to/ | \Ahttp://cot\.ag/ | \Ahttp://ht\.ly/ | \Ahttp://p\.tl/
+  | \Ahttp://url4\.eu/ | |Ahttp://t\.co/
 }x )
 config.plugins.tinyurl.set_default(:tinyurl_hook_commands, [:update, :reply, :retweet])
-config.plugins.tinyurl.set_default(:uri_regexp,
-                                   /#{URI.regexp(%w(http https ftp))}\S*/ )
+config.plugins.tinyurl.set_default(
+  :uri_regexp,
+  /#{URI.regexp(%w(http https ftp))}\S*/ )
 
 module Termtter::Client
   register_hook(
@@ -53,7 +56,6 @@ module Termtter::Client
       nil
     end
   end
-
 end
 
 # tinyuri.rb

data/lib/plugins/train.rb

@@ -1,5 +1,5 @@
-# あ
 # -*- coding: utf-8 -*-
+# あ
 module Termtter::Client
   def self.train(length)
     text = "ε="

data/lib/plugins/translation.rb

@@ -6,6 +6,8 @@ require 'kconv'
 require 'uri'
 
 def translate(text, langpair)
+  text = Termtter::API.twitter.show(text)[:text] if /^\d+$/ =~ text
+
   req = Net::HTTP::Post.new('/translate_t')
   req.add_field('Content-Type', 'application/x-www-form-urlencoded')
   req.add_field('User-Agent', 'Mozilla/5.0')

data/lib/plugins/user_stream.rb

@@ -0,0 +1,122 @@
+module Termtter::Client
+  register_command(:"user_stream stop", :help => 'user_stream stop') do |arg|
+    logger.info 'stopping user stream'
+    if @user_stream_thread
+      @user_stream_thread.exit
+    end
+    @user_stream_thread = nil
+  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}"
+    begin
+      if data[:event]
+        if /list_/ =~ data[:event]
+          typable_id = Termtter::Client.data_to_typable_id(data.target.id)
+          puts "[%s] %s %s %s to %s]" %
+            [typable_id, data.source.screen_name, data.event, data.target.screen_name, data.target_object.uri]
+          return
+        end
+        if data[:target_object]
+          # target_object is status
+          source_user = data.source
+          status = data.target_object
+          typable_id = Termtter::Client.data_to_typable_id(status.id)
+          puts "[#{typable_id}] #{source_user.screen_name} #{data.event} #{status.user.screen_name}: #{status.text}"
+        else
+          # target is user
+          source_user = data.source
+          target_user = data.target
+          typable_id = Termtter::Client.data_to_typable_id(target_user.id)
+          puts "[#{typable_id}] #{source_user.screen_name} #{data.event} #{target_user.screen_name}"
+        end
+      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}"
+      else
+        output([data], Termtter::Event.new(:update_friends_timeline, :type => :main))
+        Termtter::API.twitter.store_status_cache(data)
+      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
+    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
+    }
+  end
+
+  register_hook(
+    :name => :user_stream_init,
+    :author => '?', # FIXME
+    :point => :initialize,
+    :exec => lambda {
+      execute('user_stream')
+    })
+end
+
+# user_stream.rb
+#
+# to use,
+#   > plug user_stream
+#   > user_stream
+#
+# to stop,
+#   > user_stream stop
+#
+# Specification
+#   http://apiwiki.twitter.com/ChirpUserStreams

data/lib/plugins/whale.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+module Termtter
+  class RubytterProxy
+    alias_method :error_html_message_orig, :error_html_message
+
+    def error_html_message_whale(e)
+      if %r'Twitter / Over capacity' =~ e.message
+        WHALE
+      else
+        error_html_message_orig(e)
+      end
+    end
+
+    alias_method :error_html_message, :error_html_message_whale
+  end
+
+  # first blank line is to skip prompt.
+  WHALE = <<'__WHALE__'
+
+　 ,......-..-—‐—--..r､_　　　,r:,         Twitter / Over capacity
+　ヾー-ﾟ､ :::::::::::::::::::::::::_￣ﾆ､く
+　　 ﾞ`ー-`ｰ'-ー'"￣　　　　`'
+__WHALE__
+end
+
+# whale.rb:
+#   print whale when twitter is over capacity.
+#   ASCII-Art from http://bhdaamov.hp.infoseek.co.jp/zukan/fish.html#kuji

data/lib/termtter/active_rubytter.rb

@@ -44,6 +44,10 @@ module Termtter
       end
     end
 
+    def destructize
+      self.to_hash
+    end
+
     def retweeted_status
       nil
     end

data/lib/termtter/api.rb

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
-config.set_default(:host, 'twitter.com')
+config.set_default(:host, 'api.twitter.com')
+config.set_default(:oauth_consumer_site, 'http://api.twitter.com')
 if ENV.has_key?('HTTP_PROXY')
   require 'uri'
   proxy = ENV['HTTP_PROXY']
@@ -30,47 +31,71 @@ module Termtter
     class << self
       attr_reader :connection, :twitter
       def setup
-        3.times do
-          begin
-            if twitter = try_auth
-              @twitter = twitter
-              # NOTE: for compatible
-              @connection = twitter.instance_variable_get(:@connection)
-              break
-            end
-          rescue Timeout::Error
-            puts TermColor.parse("<red>Time out :(</red>")
-            exit!
+        # NOTE: for compatible
+        @connection = twitter.instance_variable_get(:@connection)
+        if config.access_token.empty? || config.access_token_secret.empty?
+          if config.token_file &&
+               File.exist?(File.expand_path(config.token_file))
+            config.access_token, config.access_token_secret = File.read(File.expand_path(config.token_file)) \
+                                                                  .split(/\r?\n/).map(&:chomp)
+          else
+            self.authorize_by_oauth(true)
           end
         end
 
-        exit! unless twitter
+        access_token = OAuth::AccessToken.new(consumer, config.access_token, config.access_token_secret)
+        @twitter = RubytterProxy.new(access_token, twitter_option)
+
+        config.user_name = @twitter.verify_credentials[:screen_name]
       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
+
+        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
 
-      def try_auth
-        if config.user_name.empty? || config.password.empty?
-          puts 'Please enter your Twitter login:'
+        begin
+          open_browser(request_token.authorize_url)
+        rescue BrowserNotFound
+          puts "Browser not found. Please log in and/or grant access to get PIN via your browser at #{request_token.authorize_url}"
         end
+        sleep 2
 
         ui = create_highline
+        pin = ui.ask('3. Enter PIN: ')
+        puts ""
+        puts "4. Getting access_token..."
+        access_token = request_token.get_access_token(:oauth_verifier => pin)
 
-        if config.user_name.empty?
-          config.user_name = ui.ask('Username: ')
-        else
-          puts "Username: #{config.user_name}"
-        end
-        if config.password.empty?
-          config.password = ui.ask('Password: ') { |q| q.echo = false}
+        if put_to_config
+          config.access_token = access_token.token
+          config.access_token_secret = access_token.secret
         end
 
-        twitter = RubytterProxy.new(config.user_name, config.password, twitter_option)
-        begin
-          twitter.verify_credentials
-          return twitter
-        rescue Rubytter::APIError
-          config.__clear__(:password)
+        if save_to_token_file
+          puts "5. Saving to token file... (" + config.token_file + ")"
+          open(File.expand_path(config.token_file),"w") do |f|
+            f.puts access_token.token
+            f.puts access_token.secret
+          end
         end
-        return nil
+
+        puts "Authorize is successfully done."
+
+        return {:token  => access_token.token,
+                :secret => access_token.secret}
+      end
+
+      def consumer
+        @consumer ||= OAuth::Consumer.new(
+          Termtter::Crypt.decrypt(CONSUMER_KEY),
+          Termtter::Crypt.decrypt(CONSUMER_SECRET),
+          :site => config.oauth_consumer_site,
+          :proxy => ENV['http_proxy']
+        )
       end
 
       def twitter_option

data/lib/termtter/client.rb

@@ -17,7 +17,7 @@ module Termtter
     Thread.abort_on_exception = true
 
     class << self
-      attr_reader :commands
+      attr_reader :commands, :logger, :task_manager
 
       # plug :: Name -> (Hash) -> IO () where NAME = String | Symbol | [NAME]
       def plug(name, options = {})
@@ -30,8 +30,9 @@ module Termtter
 
         return if config.system.disable_plugins.include?(name.gsub('defaults/', ''))
 
+        name_sym = name.gsub(/-/, '_').to_sym
         options.each do |key, value|
-          config.plugins.__refer__(name.gsub(/-/, '_').to_sym).__assign__(key.to_sym, value)
+          config.plugins.__refer__(name_sym).__assign__(key.to_sym, value)
         end
         load "plugins/#{name}.rb"
       rescue Exception => e
@@ -42,6 +43,10 @@ module Termtter
         @public_storage ||= {}
       end
 
+      def memory_cache
+        @memory_cache ||= Termtter::MemoryCache.new
+      end
+
       def add_filter(&b)
         warn "add_filter method will be removed. Use Termtter::Client.register_hook(:name => ..., :point => :filter_for_output, :exec => ... ) instead."
         @filters << b
@@ -68,6 +73,10 @@ module Termtter
         @commands[command.name] = command
       end
 
+      def remove_command(name)
+        commands.delete(name.to_sym)
+      end
+
       def add_command(name)
         if block_given?
           command = Command.new(:name => name)
@@ -206,6 +215,10 @@ module Termtter
         @task_manager.add_task(*arg, &block)
       end
 
+      def delete_task(name)
+        @task_manager.delete_task(name)
+      end
+
       def exit
         puts 'finalizing...'
         call_hooks(:exit)
@@ -303,8 +316,8 @@ module Termtter
         parse_options
         config.__freeze__(:user_name) unless config.user_name.empty?
         show_splash
-        load_config
         setup_task_manager
+        load_config
         load_plugins
         eval_init_block
         config.__unfreeze__(:user_name)
@@ -331,7 +344,9 @@ module Termtter
       end
 
       def handle_error(e)
-        logger.error("#{e.class.to_s}: #{e.message}")
+        message = e.message
+        message = message[0..29] + " ..." if message.size >= 30 && !config.devel
+        logger.error("#{e.class.to_s}: #{message}")
         logger.error(e.backtrace.join("\n")) if (e.backtrace and config.devel)
         get_hooks(:on_error).each {|hook| hook.call(e) }
       end

data/lib/termtter/config_setup.rb

@@ -5,9 +5,8 @@ require 'erb'
 module Termtter
   module ConfigSetup
     module_function
+
     def run
-      ui = create_highline
-      user_name = ui.ask('your twitter user name: ')
 
       plugins = Dir.glob(File.expand_path(File.dirname(__FILE__) + "/../plugins/*.rb")).map  {|f|
         f.match(%r|lib/plugins/(.*?).rb$|)[1]
@@ -23,6 +22,15 @@ module Termtter
       }
 
       puts "generated: ~/.termtter/config"
+
+      token_and_secret = Termtter::API.authorize_by_oauth
+      token = token_and_secret[:token]
+      secret = token_and_secret[:secret]
+
+      puts "Setup is all over. enjoy!"
+    rescue OAuth::Unauthorized
+      puts 'failed to authentication!'
+      exit!
     end
   end
 end

data/lib/termtter/config_template.erb

@@ -1,6 +1,8 @@
 # -*- coding: utf-8 -*-
+# vim: filetype=ruby
+
+config.token_file = "~/.termtter/token"
 
-config.user_name = '<%= user_name %>'
 #config.update_interval = 120
 #config.timeout = 60
 #config.retry = 3
@@ -10,7 +12,7 @@ config.user_name = '<%= user_name %>'
 #config.proxy.user_name = 'proxy user'
 #config.proxy.password = 'proxy password'
 
-config.plugins.keyword.keywords = ["@<%= user_name %>"]
+#config.plugins.keyword.keywords = ["termtter"]
 config.confirm = true
 #config.plugins.stdout.colors = (31..36).to_a + (91..96).to_a
 

data/lib/termtter/crypt.rb

@@ -0,0 +1,13 @@
+require 'base64'
+
+module Termtter
+  module Crypt
+    def self.crypt(s)
+      Base64.encode64(s)
+    end
+
+    def self.decrypt(s)
+      Base64.decode64(s)
+    end
+  end
+end