termtter 1.6.0 → 1.7.0

data/lib/plugins/confirm.rb

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+warn '"confirm" plugin is deprecated. You can use "config.confirm" option instead it.'
+
 config.plugins.confirm.set_default(:commands, [:update, :reply, :direct, :retweet])
 config.plugins.confirm.set_default(
   :conditions,

data/lib/plugins/crypt.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+
+require 'openssl'
+
+config.plugins.crypt.set_default(:salt, 'No Termtter, No Life.')
+
+def encrypt(msg, salt)
+  encoder = OpenSSL::Cipher::DES.new
+  encoder.encrypt
+  encoder.pkcs5_keyivgen(salt)
+  (encoder.update(msg) + encoder.final).unpack('H*').to_s
+end
+
+def decrypt(msg, salt)
+  decoder = OpenSSL::Cipher::DES.new
+  decoder.decrypt
+  decoder.pkcs5_keyivgen(salt)
+  decoder.update([msg].pack('H*')) + decoder.final
+end
+
+Termtter::Client.register_command(
+  :name => :crypt,
+  :help => ['crypt TEXT', 'Post a encrypted message'],
+  :exec_proc => lambda {|arg|
+    msg = arg
+    prefix = '{DES}'
+    status = prefix + encrypt(msg, config.plugins.crypt.salt)
+    Termtter::API.twitter.update(status)
+    puts "=> #{status}"
+    status
+  }
+  )
+
+Termtter::Client::register_hook(
+  :name => :decrypt_message,
+  :point => :filter_for_output,
+  :exec_proc => lambda do |statuses, event|
+    statuses.each do |s|
+      s.text.gsub!(/^\{DES\}(.*)/) do |m|
+        "{decrypt}" + decrypt($1, config.plugins.crypt.salt)
+      end
+    end
+  end
+)

data/lib/plugins/defaults/auto_reload.rb

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 auto_reload_proc = lambda do
   begin
-    Termtter::Client.call_commands('reload -r')
+    Termtter::Client.execute('reload -r')
   rescue TimeoutError
     # do nothing
   rescue Exception => e

data/lib/plugins/defaults/command_line.rb

@@ -31,7 +31,7 @@ module Termtter
       Client.get_hooks('prepare_command').each {|hook|
         command_text = hook.call(command_text)
       }
-      Client.call_commands(command_text)
+      Client.execute(command_text)
     rescue TimeoutError
       puts TermColor.parse("<red>Time out :(</red>")
     end
@@ -62,30 +62,47 @@ module Termtter
       @input_thread.join
     end
 
+    def do_completion(input)
+      input = input.sub(/^\s*/, '')
+
+      words = []
+
+      words = Client.commands.values.
+                inject([]) {|array, command| array + [command.name] + command.aliases}.
+                map(&:to_s).
+                grep(/^\s*#{Regexp.quote(input)}/)
+
+      if words.empty?
+        command = Client.find_command(input)
+        words = command ? command.complement(input) : []
+      end
+
+      if words.empty?
+        Client.get_hooks(:completion).each do |hook|
+          words << hook.call(input) rescue nil
+        end
+      end
+
+      words.flatten.compact
+    rescue Exception => e
+      Client.handle_error(e)
+    end
+
     def setup_readline
       if Readline.respond_to?(:basic_word_break_characters=)
         Readline.basic_word_break_characters= "\t\n\"\\'`><=;|&{("
       end
+
       Readline.completion_case_fold = true
-      Readline.completion_proc = lambda {|input|
-        begin
-          words = Client.commands.map {|name, command| command.complement(input) }.flatten.compact
-
-          if words.empty?
-            Client.get_hooks(:completion).each do |hook|
-              words << hook.call(input) rescue nil
-            end
-          end
 
-          words.flatten.compact
-        rescue Exception => e
-          Client.handle_error(e)
-        end
-      }
+      Readline.completion_proc = lambda {|input| do_completion(input) }
+
       vi_or_emacs = config.editing_mode
       unless vi_or_emacs.empty?
         Readline.__send__("#{vi_or_emacs}_editing_mode")
       end
+
+      Readline.rl_parse_and_bind('TAB: menu-complete')
     end
 
     def trap_setting()
@@ -95,7 +112,7 @@ module Termtter
           begin
             system "stty", stty_save
           ensure
-            Client.call_commands('exit')
+            Client.execute('exit')
           end
         end
         trap("CONT") do
@@ -107,7 +124,7 @@ module Termtter
     end
   end
 
-  Client.register_hook(:initialize_command_line, :point => :launched) do
+  Client.register_hook(:initialize_command_line, :point => :init_command_line) do
     CommandLine.start
   end
 

data/lib/plugins/defaults/confirm.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+config.set_default(:confirm, false)
+
+def confirm(message)
+  if config.confirm && !Termtter::Client.confirm(message)
+    raise Termtter::CommandCanceled
+  end
+end
+
+Termtter::RubytterProxy.register_hook(:confirm_update, :point => :pre_update) do |*args|
+  confirm("update #{args.first}")
+  args
+end
+
+Termtter::RubytterProxy.register_hook(:confirm_direct_message, :point => :pre_direct_message) do |*args|
+  confirm("direct #{args[0]} #{args[1]}")
+  args
+end
+
+Termtter::RubytterProxy.register_hook(:confirm_retweet, :point => :pre_retweet) do |*args|
+  status = Termtter::API.twitter.show(args.first)
+  confirm("retweet #{status.text}")
+  args
+end
+
+Termtter::RubytterProxy.register_hook(:confirm_delete, :point => :pre_remove_status) do |*args|
+  status = Termtter::API.twitter.show(args.first)
+  confirm("delete #{status.text}")
+  args
+end

data/lib/plugins/defaults/hashtag.rb

@@ -12,7 +12,7 @@ module Termtter::Client
   register_command(:raw_update) do |args|
     temp = public_storage[:hashtags]
     public_storage[:hashtags].clear
-    call_commands "update #{args}"
+    execute "update #{args}"
     public_storage[:hashtags] = temp
   end
 

data/lib/plugins/defaults/irb.rb

@@ -0,0 +1,30 @@
+require 'irb'
+
+module IRB
+  def self.start_session(binding)
+    unless @__irb_initialized
+      IRB.setup(nil)
+      @__irb_initialized = true
+    end
+
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+Termtter::Client.register_command(:irb) do |arg|
+  begin
+    completion_proc = Readline.completion_proc
+    IRB.start_session(binding)
+  ensure
+    Readline.completion_proc = completion_proc
+  end
+end

data/lib/plugins/defaults/keyword.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+require 'set'
+
+config.plugins.keyword.set_default(
+  :highlight_patterns,
+  [
+    ['on_cyan', 'white'],
+    ['on_green', 'white'],
+    ['on_magenta', 'white'],
+    ['on_red', 'white'],
+    ['on_blue', 'white'],
+    ['on_black', 'white'],
+    ['on_white', 'white'],
+    ['on_yellow', 'white'],
+  ]
+)
+
+config.plugins.keyword.set_default(:keywords, [])
+
+module Termtter::Client
+  public_storage[:keywords] ||= Set.new(config.plugins.keyword.keywords)
+
+  register_hook :highlight_keywords, :point => :pre_coloring do |text, event|
+    public_storage[:keywords].each_with_index do |keyword, index|
+      highlight_pattern = config.plugins.keyword.highlight_patterns[index % config.plugins.keyword.highlight_patterns.size]
+      text = text.gsub(
+                /(#{Regexp.quote(keyword)})/i,
+                "<#{highlight_pattern[0]}><#{highlight_pattern[1]}>" +
+                "\\1" +
+                "</#{highlight_pattern[1]}></#{highlight_pattern[0]}>"
+              )
+    end
+    text
+  end
+
+  register_command(
+    'keyword add',
+    :help => ['keyword add KEYWORD', 'Add a highlight keyword']
+  ) do |args|
+    args.split(/\s+/).each do |arg|
+      public_storage[:keywords] << arg
+    end
+  end
+
+  register_command(
+    'keyword clear',
+    :help => ['keyword clear', 'Clear highlight keywords']
+  ) do |args|
+    public_storage[:keywords].clear
+  end
+
+  register_command(
+    'keyword list',
+    :help => ['keyword list', 'List highlight keywords']
+  ) do |args|
+    p public_storage[:keywords].to_a
+  end
+end

data/lib/plugins/defaults/list.rb

@@ -0,0 +1,155 @@
+module Termtter::Client
+  public_storage[:lists] = []
+
+  register_hook(:fetch_my_lists, :point => :launched) do
+    begin
+      public_storage[:lists] +=
+        Termtter::API.twitter.lists(config.user_name).lists.map(&:full_name)
+    rescue TimeoutError
+      # do nothing
+    rescue Exception => e
+      Termtter::Client.handle_error(e)
+    end
+  end
+
+  register_command(
+    :name => :list, :aliases => [:l],
+    :exec_proc => lambda {|arg|
+      if arg =~ /\-([\d]+)/
+        options = {:count => $1}
+        arg = arg.gsub(/\-([\d]+)/, '')
+      else
+        options = {}
+      end
+
+      last_error = nil
+      if arg.empty?
+        event = :list_friends_timeline
+        statuses = Termtter::API.twitter.home_timeline(options)
+      else
+        event = :list_user_timeline
+        statuses = []
+        Array(arg.split).each do |user|
+          if user =~ /\/\w+/
+            user_name, slug = *user.split('/')
+            user_name = config.user_name if user_name.empty?
+            user_name = normalize_as_user_name(user_name)
+            options[:per_page] = options[:count]
+            options.delete(:count)
+            statuses += Termtter::API.twitter.list_statuses(user_name, slug, options)
+          else
+            begin
+              if user =~ /^\d+$/
+                profile = Termtter::API.twitter.user(nil, :screen_name => user) rescue nil
+                unless profile
+                  status  = Termtter::API.twitter.show(user) rescue nil
+                  user    = status.user.screen_name if status
+                end
+              end
+              user_name = normalize_as_user_name(user.sub(/\/$/, ''))
+              statuses += Termtter::API.twitter.user_timeline(user_name, options)
+            rescue Rubytter::APIError => e
+              last_error = e
+            end
+          end
+        end
+      end
+      output(statuses, event)
+      raise last_error if last_error
+    },
+    :help => ["list,l [USERNAME]/[SLUG] [-COUNT]", "List the posts"]
+  )
+
+  register_command(
+    :name => 'list list',
+    :exec => lambda {|arg|
+      unless arg.empty?
+        user_name = normalize_as_user_name(arg)
+      else
+        user_name = config.user_name
+      end
+      # TODO: show more information of lists
+      lists = Termtter::API.twitter.lists(user_name).lists
+      public_storage[:lists] += lists.map(&:full_name)
+      puts lists.map{|i| i.full_name}.join("\n")
+    },
+    :help => ["lists [USERNAME]", "Show Lists"]
+  )
+
+  register_command(
+    :name => %s{list follow},
+    :alias => %s{list add},
+    :exec => lambda { |arg|
+      list_name, *users = arg.split(' ')
+      slug = list_name_to_slug(list_name)
+      users.each{ |screen_name|
+        begin
+          user = Termtter::API.twitter.cached_user(screen_name) || Termtter::API.twitter.user(screen_name)
+          Termtter::API.twitter.add_member_to_list(slug, user.id)
+          puts "#{slug} + #{screen_name}"
+        rescue => e
+          handle_error(e)
+        end
+      }
+    },
+    :help => ["list follow SLUG USERNAME", "Follow users to the list"]
+    )
+
+  register_command(
+    :name => %s{list remove},
+    :exec => lambda { |arg|
+      list_name, *users = arg.split(' ')
+      slug = list_name_to_slug(list_name)
+      users.each{ |screen_name|
+        begin
+          user = Termtter::API.twitter.cached_user(screen_name) || Termtter::API.twitter.user(screen_name)
+          Termtter::API.twitter.remove_member_from_list(slug, user.id)
+          puts "#{slug} - #{screen_name}"
+        rescue => e
+          handle_error(e)
+        end
+      }
+    },
+    :help => ["list remove SLUG USERNAME", "Remove user(s) from the list"]
+    )
+
+  register_command(
+    :name => %s{list create},
+    :exec => lambda { |arg|
+      slug, *options = arg.split(' ')
+      param = { }
+
+      OptionParser.new {|opt|
+        opt.on('--description VALUE') {|v| param[:description] = v }
+        opt.on('--private') {|v| param[:mode] = 'private' }
+        opt.parse(options)
+      }
+      list = Termtter::API.twitter.create_list(slug, param)
+      public_storage[:lists] << list.full_name
+      p [list.full_name, param]
+    },
+    :help => ["list create SLUG [--description VALUE] [--private]", "Create list"]
+    )
+
+  register_command(
+    :name => %s{list delete},
+    :exec => lambda { |arg|
+      return unless confirm("Are you sure?")
+      arg.split(' ').each{ |list_name|
+        begin
+          slug = list_name_to_slug(list_name)
+          list = Termtter::API.twitter.delete_list(slug)
+          public_storage[:lists].delete(list.full_name)
+          puts "#{list.full_name} deleted"
+        rescue => e
+          handle_error(e)
+        end
+      }
+    },
+    :help => ["list delete SLUG", "Delete list"]
+  )
+
+  def self.list_name_to_slug(list_name)
+    list_name[/([^\/]*)$/]
+  end
+end

data/lib/plugins/defaults/plugin.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+
+module Termtter::Client
+  register_command('plugin edit') do |arg|
+    if /\-s/ =~ arg
+      arg = arg.sub('-s', '').strip
+      include_system_plugins = true
+    end
+
+    if path = search_plugin_file(arg, include_system_plugins)
+      open_editor(path)
+      plug(arg)
+      puts "reload => #{arg}"
+    else
+      puts TermColor.parse('<red>Plugin not found :(</red>')
+    end
+  end
+
+  register_command('plugin show') do |arg|
+    if path = search_plugin_file(arg, true)
+      puts IO.read(path)
+    else
+      puts TermColor.parse('<red>Plugin not found :(</red>')
+    end
+  end
+
+  register_command('plugin create') do |arg|
+    path = "#{Termtter::CONF_DIR}/plugins/#{arg}.rb"
+    unless File.exists?(path)
+      FileUtils.mkdir_p(File.dirname(path))
+      # TODO: insert plugin template to plugin file
+      open_editor(path)
+      plug(arg)
+      puts "load => #{arg}"
+    else
+      puts TermColor.parse('<red>The plugin already exists :(</red>')
+    end
+  end
+
+  def self.open_editor(path)
+    # TODO: change to common method or use launchy
+    system ENV['EDITOR'] || 'vim', path
+  end
+
+  def self.search_plugin_file(name, include_system_plugins = false)
+    regex = /#{Regexp.quote(name + '.rb')}$/
+    plugin_files(include_system_plugins).detect {|f| regex =~ f}
+  end
+
+  def self.plugin_files(include_system_plugins = false)
+    files = Dir["#{Termtter::CONF_DIR}/plugins/*.rb"]
+    files += Dir["#{File.expand_path(File.dirname(__FILE__))}/*.rb"] if include_system_plugins
+    files
+  end
+
+  # TODO: rename command 'plug' to 'plugin load' and define 'plug' as alias
+  # TODO: completion for plugin names
+end
+