termtter 1.1.3 → 1.2.0

data/lib/plugins/auto_reload.rb

@@ -4,5 +4,9 @@ module Termtter::Client
     call_commands('reload')
   end
 
-  call_commands('reload')
+  register_hook(
+    :name => :auto_reload_init,
+    :point => :initialize,
+    :exec => lambda { call_commands('reload') }
+  )
 end

data/lib/plugins/open_url.rb

@@ -23,8 +23,8 @@ module Termtter::Client
     :help      => ['open_url (TYPABLE|ID|@USER)', 'Open url'],
     :exec_proc => lambda {|arg|
       Thread.new(arg) do |arg|
-        if public_storage[:typable_id] && status = typable_id_status(arg)
-          status.text.gsub(URI.regexp) {|uri|
+        if status = Termtter::Client.typable_id_to_data(arg)
+          status.text.gsub(URI.regexp(['http', 'https'])) {|uri|
             open_uri(uri)
           }
         else
@@ -33,27 +33,23 @@ module Termtter::Client
             user = $1
             statuses = Termtter::API.twitter.user_timeline(user)
             return if statuses.empty?
-            statuses[0].text.gsub(URI.regexp) {|uri| open_uri(uri) }
+            statuses[0].text.gsub(URI.regexp(['http', 'https'])) {|uri| open_uri(uri) }
           when /^\d+/
-            Termtter::API.twitter.show(arg).text.gsub(URI.regexp) {|uri| open_uri(uri) }
+            Termtter::API.twitter.show(arg).text.gsub(URI.regexp(['http', 'https'])) {|uri| open_uri(uri) }
           end
         end
       end
     },
     :completion_proc => lambda {|cmd, arg|
-      if public_storage[:typable_id] && typable_id?(arg)
-        "#{cmd} #{typable_id_convert(arg)}"
-      else
-        case arg
-        when /@(.*)/
-          find_user_candidates $1, "#{cmd} @%s"
-        when /(\d+)/
-          find_status_ids(arg).map{|id| "#{cmd} #{$1}"}
-        end
+      case arg
+      when /@(.*)/
+        find_user_candidates $1, "#{cmd} @%s"
+      when /(\d+)/
+        find_status_ids(arg).map{|id| "#{cmd} #{$1}"}
       end
     }
   )
 end
 
 #Optional Setting
-#  config.plugins.open_url.browser = firefox
+#  config.plugins.open_url.browser = 'firefox'

data/lib/plugins/protected_filter.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+Termtter::Client.register_hook(
+  :name => :protected_filter,
+  :point => :filter_for_output,
+  :exec => lambda { |statuses, event|
+    statuses.select { |s| !s.user.protected }
+  }
+)

data/lib/plugins/standard_commands.rb

@@ -11,37 +11,27 @@ module Termtter::Client
 
   register_command(
     :name => :reload,
-    :exec_proc => lambda {|arg|
-      begin
-        args = @since_id ? [{:since_id => @since_id}] : []
-        statuses = Termtter::API.twitter.friends_timeline(*args)
-        unless statuses.empty?
-          print "\e[1K\e[0G" unless win?
-          @since_id = statuses[0].id
-          output(statuses, :update_friends_timeline)
-          Readline.refresh_line
-        end
-      rescue OpenURI::HTTPError => e
-        if e.message == '401 Unauthorized'
-          puts 'Could not login'
-          puts 'plese check your account settings'
-          exit!
-        end
-      rescue => e
-        handle_error(e)
+    :exec => lambda {|arg|
+      args = @since_id ? [{:since_id => @since_id}] : []
+      statuses = Termtter::API.twitter.friends_timeline(*args)
+      unless statuses.empty?
+        print "\e[1K\e[0G" unless win?
+        @since_id = statuses[0].id
+        output(statuses, :update_friends_timeline)
+        Readline.refresh_line
       end
     }
   )
 
   register_command(
-    :name => :update, :aliases => [:u],
-    :exec_proc => lambda {|arg|
+    :name => :update, :alias => :u,
+    :exec => lambda {|arg|
       unless arg.empty?
         result = Termtter::API.twitter.update(arg)
         puts TermColor.parse("updated => #{result.text} <90>#{result.id}</90>")
       end
     },
-    :completion_proc => lambda {|cmd, args|
+    :completion => lambda {|cmd, args|
       if /(.*)@([^\s]*)$/ =~ args
         find_user_candidates $2, "#{cmd} #{$1}@%s"
       end
@@ -184,9 +174,13 @@ module Termtter::Client
   register_command(
     :name => :replies, :aliases => [:r],
     :exec_proc => lambda {|arg|
-      output(Termtter::API.twitter.replies, :replies)
+      res = Termtter::API.twitter.replies
+      unless arg.empty?
+        res = res.map {|e| e.user.screen_name == arg ? e : nil }.compact
+      end
+      output(res, :replies)
     },
-    :help => ["replies,r", "List the most recent @replies for the authenticating user"]
+    :help => ["replies,r", "List the replies"]
   )
 
   register_command(
@@ -268,7 +262,11 @@ module Termtter::Client
         word = $1
         raise "Not implemented yet."
       else
-        return
+        if public_storage[:typable_id] && typable_id?(arg)
+          id = typable_id_convert(arg)
+        else
+          return
+        end
       end
 
       r = Termtter::API.twitter.favorite id
@@ -281,10 +279,14 @@ module Termtter::Client
       when /(\d+)/
         find_status_ids(arg).map{|id| "#{cmd} #{id}"}
       else
-        %w(favorite).grep(/^#{Regexp.quote arg}/)
+        if data = Termtter::Client.typable_id_to_data(arg)
+          "#{cmd} #{data}"
+        else
+          %w(favorite).grep(/^#{Regexp.quote arg}/)
+        end
       end
     },
-    :help => ['favorite,fav (ID|@USER|/WORD)', 'Mark a status as a favorite']
+    :help => ['favorite,fav (ID|@USER|TYPABLE|/WORD)', 'Mark a status as a favorite']
   )
 
   def self.show_settings(conf, level = 0)
@@ -417,7 +419,7 @@ module Termtter::Client
         public_storage[:plugins].sort
       end
     },
-    :help      => ['plugin FILE', 'Load a plugin']
+    :help      => ['plug FILE', 'Load a plugin']
   )
 
   register_command(
@@ -453,7 +455,7 @@ module Termtter::Client
       when /^\s*(\d+)\s+(.+)$/
         s = Termtter::API.twitter.show($1) rescue nil
         if s
-          update_with_user_and_id($2, s.user.screen_name, id)
+          update_with_user_and_id($2, s.user.screen_name, s.id)
         end
       when /^\s*@(\w+)/
         in_reply_to_status_id = Termtter::API.twitter.user($1).status.id rescue nil

data/lib/plugins/stdout.rb

@@ -7,14 +7,51 @@ require 'tempfile'
 config.plugins.stdout.set_default(:colors, (31..36).to_a + (91..96).to_a)
 config.plugins.stdout.set_default(
   :timeline_format,
-  '<90><%=time%></90> <<%=color%>><%=s.user.screen_name%>: <%=text%></<%=color%>> ' +
-  '<90><%=reply_to ? reply_to + " " : ""%><%=s.id%> <%=source%></90>'
+  '<90><%=time%> [<%=status_id%>]</90> <<%=color%>><%=s.user.screen_name%>: <%=text%></<%=color%>> ' +
+  '<90><%=reply_to_status_id ? " (reply_to [#{reply_to_status_id}]) " : ""%><%=source%></90>'
 )
 config.plugins.stdout.set_default(:enable_pager, true)
 config.plugins.stdout.set_default(:pager, 'less -R -f +G')
 config.plugins.stdout.set_default(:window_height, 50)
+config.plugins.stdout.set_default(:typable_ids, ('aa'..'zz').to_a)
+config.plugins.stdout.set_default(:typable_id_prefix, '$')
 
 module Termtter
+  class TypableIdGenerator
+    def initialize(ids)
+      if not ids.kind_of?(Array)
+        raise ArgumentError, 'ids should be an Array'
+      elsif ids.empty?
+        raise ArgumentError, 'ids should not be empty'
+      end
+      @ids = ids
+      @table = {}
+    end
+
+    def next(data)
+      id = @ids.shift
+      @ids.push id
+      @table[id] = data
+      id
+    end
+
+    def get(id)
+      @table[id]
+    end
+  end
+
+  module Client
+    @typable_id_generator = TypableIdGenerator.new(config.plugins.stdout.typable_ids)
+
+    def self.data_to_typable_id(data)
+      id = config.plugins.stdout.typable_id_prefix + @typable_id_generator.next(data)
+    end
+
+    def self.typable_id_to_data(id)
+      @typable_id_generator.get(id)
+    end
+  end
+
   class StdOut < Hook
     def initialize
       super(:name => :stdout, :points => [:output])
@@ -43,7 +80,14 @@ module Termtter
       statuses.each do |s|
         text = TermColor.escape(s.text)
         color = config.plugins.stdout.colors[s.user.id.to_i % config.plugins.stdout.colors.size]
-        reply_to = s.in_reply_to_status_id ? "(reply to #{s.in_reply_to_status_id})" : nil
+        status_id = Termtter::Client.data_to_typable_id(s.id)
+        reply_to_status_id =
+          if s.in_reply_to_status_id.nil?
+            nil
+          else
+            Termtter::Client.data_to_typable_id(s.in_reply_to_status_id)
+          end
+
         time = "(#{Time.parse(s.created_at).strftime(time_format)})"
         source =
           case s.source
@@ -68,10 +112,26 @@ module Termtter
   end
 
   Client.register_hook(StdOut.new)
+
+  Client.register_hook(
+    :name => :stdout_typable_id,
+    :point => /^modify_arg_for_.*/,
+    :exec => lambda { |cmd, arg|
+      if arg
+        prefix = config.plugins.stdout.typable_id_prefix
+        arg.gsub(/#{Regexp.quote(prefix)}\w+/) do |id|
+          Termtter::Client.typable_id_to_data(id[1..-1]) || id
+        end
+      else
+        arg
+      end
+    }
+  )
 end
 
 # stdout.rb
 #   output statuses to stdout
 # example config
 #   config.plugins.stdout.colors = [:none, :red, :green, :yellow, :blue, :magenta, :cyan]
-#   config.plugins.stdout.timeline_format = '<90><%=time%></90> <<%=status_color%>><%=status%></<%=status_color%>> <90><%=id%></90>'
+#   config.plugins.stdout.timeline_format = '<90><%=time%> [<%=status_id%>]</90> <<%=color%>><%=s.user.screen_name%>: <%=text%></<%=color%>> ' +
+#                                           '<90><%=reply_to_status_id ? " (reply_to [#{reply_to_status_id}]) " : ""%><%=source%></90>'

data/lib/plugins/uri-open.rb

@@ -8,39 +8,43 @@ module Termtter::Client
     :points => [:output],
     :exec_proc => lambda {|statuses, event|
       statuses.each do |s|
-        public_storage[:uris] += s[:text].scan(%r|https?://[^\s]+|)
+        public_storage[:uris] = s[:text].scan(%r|https?://[^\s]+|) + public_storage[:uris]
       end
     }
   )
 
   def self.open_uri(uri)
-    unless config.plugins.uri_open.browser.empty?
-      system config.plugins.uri_open.browser, uri
-    else
-      case RUBY_PLATFORM
-      when /linux/
-        system 'firefox', uri
-      when /mswin(?!ce)|mingw|bccwin/
-        system 'explorer', uri
+    cmd =
+      unless config.plugins.uri_open.browser.empty?
+        config.plugins.uri_open.browser
       else
-        system 'open', uri
+        case RUBY_PLATFORM
+        when /linux/; 'firefox'
+        when /mswin(?!ce)|mingw|bccwin/; 'explorer'
+        else; 'open'
+        end
       end
-    end
+    system cmd, uri
   end
 
   register_command(
     :name => :'uri-open', :aliases => [:uo],
-    :exec_proc => lambda{|arg|
+    :exec_proc => lambda {|arg|
       case arg
-      when /^\s+$/
-        public_storage[:uris].each do |uri|
-          open_uri(uri)
-        end
-        public_storage[:uris].clear
+      when ''
+        open_uri public_storage[:uris].shift
+      when /^\s*all\s*$/
+        public_storage[:uris].
+          each {|uri| open_uri(uri) }.
+          clear
       when /^\s*list\s*$/
-        public_storage[:uris].each_with_index do |uri, index|
-          puts "#{index}: #{uri}"
-        end
+        public_storage[:uris].
+          enum_for(:each_with_index).
+          to_a.
+          reverse.
+          each  do |uri, index|
+            puts "#{index}: #{uri}"
+          end
       when /^\s*delete\s+(\d+)\s*$/
         puts 'delete'
         public_storage[:uris].delete_at($1.to_i)
@@ -48,19 +52,20 @@ module Termtter::Client
         public_storage[:uris].clear
         puts "clear uris"
       when /^\s*(\d+)\s*$/
-        open_uri(public_storage[:uris][$1.to_i])
-        public_storage[:uris].delete_at($1.to_i)
+        open_uri(public_storage[:uris].delete_at($1.to_i))
+      else
+        puts "**parse error in uri-open**"
       end
     },
-    :completion_proc => lambda{|cmd, arg|
-      %w(list delete clear).grep(/^#{Regexp.quote arg}/).map{|a| "#{cmd} #{a}"}
+    :completion_proc => lambda {|cmd, arg|
+      %w(all list delete clear).grep(/^#{Regexp.quote arg}/).map {|a| "#{cmd} #{a}" }
     }
   )
 end
-# ~/.termtter
+# ~/.termtter/config
 # plugin 'uri-open'
 #
-# see also: http://ujihisa.nowa.jp/entry/c3dd00c4e0
+# see also: http://ujihisa.blogspot.com/2009/05/fixed-uri-open-of-termtter.html
 #
 # KNOWN BUG
-# * In Debian, exit or C-c in the termtter kills your firefox.
+# * In Debian, exit or C-c in the termtter would kill your firefox.

data/lib/termtter/client.rb

@@ -21,6 +21,9 @@ module Termtter
     config.set_default(:update_interval, 300)
     config.set_default(:prompt, '> ')
     config.set_default(:devel, false)
+    config.set_default(:stdout, true)
+    config.set_default(:standard_commands, true)
+    config.set_default(:auto_reload, true)
 
     Thread.abort_on_exception = true
 
@@ -74,18 +77,33 @@ module Termtter
         end
       end
 
-      def register_command(arg)
+      def register_command(arg, opts = {}, &block)
         command = case arg
           when Command
             arg
           when Hash
             Command.new(arg)
+          when String
+            options = { :name => arg }
+            options.merge!(opts)
+            options[:exec_proc] = block
+            Command.new(options)
           else
-            raise ArgumentError, 'must be given Termtter::Command or Hash'
+            raise ArgumentError, 'must be given Termtter::Command, Hash or String with block'
           end
         @commands[command.name] = command
       end
 
+      def add_command(name)
+        if block_given?
+          command = Command.new(:name => name)
+          yield command
+          @commands[command.name] = command
+        else
+          raise ArgumentError, 'must be given block to set parameters'
+        end
+      end
+
       def clear_command
         @commands.clear
       end
@@ -120,11 +138,11 @@ module Termtter
         statuses = statuses.sort_by{|s|s.id}
         call_hooks(:pre_filter, statuses, event)
 
-        filtered = statuses.map(&:dup)
+        filtered = apply_filters_for_hook(:filter_for_output, statuses.map(&:dup), event)
+
         @filters.each do |f|  # TODO: code for compatibility. delete someday.
-          statuses = f.call(statuses, event)
+          filtered = f.call(filtered, event)
         end
-        apply_filters_for_hook(:filter_for_output, statuses, event)
 
         call_hooks(:post_filter, filtered, event)
         get_hooks(:output).each do |hook|
@@ -325,12 +343,9 @@ module Termtter
 
         @init_block.call(self) if @init_block
 
-        unless @init_block  # compatibility for old style config file
-          plug 'stdout'
-          plug 'standard_commands'
-          plug 'auto_reload'
-        end
-
+        plug 'stdout' if config.stdout
+        plug 'standard_commands' if config.standard_commands
+        plug 'auto_reload' if config.auto_reload
         plug 'devel' if config.devel
 
         config.system.load_plugins.each do |plugin|

data/lib/termtter/command.rb

@@ -1,19 +1,18 @@
 # -*- coding: utf-8 -*-
 
 module Termtter
-
   class Command
-
     attr_accessor :name, :aliases, :exec_proc, :completion_proc, :help
 
     # args
-    #   name:            Symbol as command name
+    #   name:            (required) Symbol as command name
     #   aliases:         Array of command alias (ex. ['u', 'up'])
     #   exec_proc:       Proc for procedure of the command. If need the proc must return object for hook.
     #   completion_proc: Proc for input completion. The proc must return Array of candidates (Optional)
     #   help:            help text for the command (Optional)
     def initialize(args)
       raise ArgumentError, ":name is not given." unless args.has_key?(:name)
+      args = args.dup
       args[:exec_proc] ||= args[:exec]
       args[:completion_proc] ||= args[:completion]
       args[:aliases] ||= [args[:alias]].compact
@@ -27,14 +26,16 @@ module Termtter
       set cfg
     end
 
+    # set :: Hash -> ()
     def set(cfg)
-      @name            = cfg[:name].to_sym
-      @aliases         = cfg[:aliases].map {|e| e.to_sym }
-      @exec_proc       = cfg[:exec_proc]
-      @completion_proc = cfg[:completion_proc]
-      @help            = cfg[:help]
+      self.name            = cfg[:name].to_sym
+      self.aliases     = cfg[:aliases]
+      self.exec_proc       = cfg[:exec_proc]
+      self.completion_proc = cfg[:completion_proc]
+      self.help            = cfg[:help]
     end
 
+    # complement :: String -> [String]
     def complement(input)
       if match?(input) && input =~ /^[^\s]+\s/
         if completion_proc
@@ -48,6 +49,7 @@ module Termtter
       end
     end
 
+    # call :: ???
     def call(cmd = nil, arg = nil, original_text = nil)
       arg = case arg
         when nil
@@ -60,19 +62,32 @@ module Termtter
       exec_proc.call(arg)
     end
 
+    # match? :: String -> Boolean
     def match?(input)
-      (pattern =~ input) != nil
+      !(pattern !~input)
     end
 
+    # pattern :: Regexp
     def pattern
       commands_regex = commands.map {|name| Regexp.quote(name.to_s) }.join('|')
       /^((#{commands_regex})|(#{commands_regex})\s+(.*?))\s*$/
     end
 
+    # commands :: [Symbol]
     def commands
       [name] + aliases
     end
 
+    def aliases=(as)
+      @aliases = as.map { |a| a.to_sym }
+    end
+
+    # alias= :: Symbol -> ()
+    def alias=(a)
+      self.aliases = [a]
+    end
+
+    # split_command_line :: String -> (String, String)
     def self.split_command_line(line)
       line.strip.split(/\s+/, 2)
     end

data/lib/termtter/config.rb

@@ -51,6 +51,10 @@ module Termtter
       @store.dup
     end
 
+    def __clear__
+      @store.clear
+    end
+
     __instance = self.new
     (class << self; self end).
       __send__(:define_method, :instance) { __instance }

data/lib/termtter/config_template.erb

@@ -9,10 +9,7 @@ config.password = '<%= password %>'
 #config.proxy.password = 'proxy password'
 
 Termtter::Client.init do |t|
-  <%- standard_plugins.each do |plugin| -%>
-  t.plug '<%= plugin %>'
-  <%- end -%>
   <%- (plugins - standard_plugins).each do |plugin| -%>
-  # t.plug '<%= plugin %>'
+#  t.plug '<%= plugin %>'
   <%- end -%>
 end

data/lib/termtter/version.rb

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 module Termtter
-  VERSION = '1.1.3'
+  VERSION = '1.2.0'
 end

data/spec/termtter/client_spec.rb

@@ -21,6 +21,47 @@ module Termtter
       Client.get_command(:test).name.should == :test
     end
 
+    it 'should take register_command as block' do
+      process = lambda {}
+      Client.register_command('test', &process)
+      command = Client.get_command(:test)
+      command.name.should == :test
+      command.exec_proc.should == process
+    end
+
+    it 'should take register_command as block with options' do
+      process = lambda {}
+      Client.register_command('test', :help => 'help', &process)
+      command = Client.get_command(:test)
+      command.name.should == :test
+      command.exec_proc.should == process
+      command.help.should == 'help'
+    end
+
+    it 'should take add_command as block' do
+      Client.add_command('test') do |c|
+        c.aliases = ['t']
+        c.help = 'test command is a test'
+      end
+      command = Client.get_command(:test)
+      command.name.should == :test
+      command.aliases.should == [:t]
+      command.help.should == 'test command is a test'
+    end
+
+    it 'should take add_command as block without past config' do
+      Client.add_command('past') do |c|
+        c.help = 'past help'
+      end
+      Client.get_command(:past).help.should == 'past help'
+      Client.add_command('new') {}
+      Client.get_command(:new).help.should_not == 'past help'
+    end
+
+    it 'raises ArgumentError when call add_command without block' do
+      lambda { Client.add_command('past') }.should raise_error(ArgumentError)
+    end
+
     it 'should call command' do
       command_arg = nil
       command = Command.new(:name => :test, :exec_proc => lambda {|arg| command_arg = arg})

data/spec/termtter/command_spec.rb

@@ -3,52 +3,73 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 module Termtter
+  describe 'Command#initialize' do
+    it 'requires the name element in the argument hash' do
+      lambda { Command.new(:nama => 1) }.should raise_error(ArgumentError)
+      lambda { Command.new(:name => 1) }.should_not raise_error(ArgumentError)
+    end
 
-  describe Command do
+    it 'does not destroy the argument hash' do
+      hash = {
+        :name => 1,
+        :exec => 3
+      }
+      Command.new hash
+
+      hash.should eql(hash)
+      hash[:name].should == 1
+      hash[:exec].should == 3
+      hash[:exec_proc].should be_nil
+    end
+  end
 
+  describe Command do
     before do
       params =  {
-          :name            => 'update',
-          :aliases         => ['u', 'up'],
-          :exec_proc       => lambda {|arg| arg },
-          :completion_proc => lambda {|command, arg| ['complete1', 'complete2'] },
-          :help            => ['update,u TEXT', 'test command']
+        :name            => 'update',
+        :aliases         => ['u', 'up'],
+        :exec_proc       => lambda {|arg| arg },
+        :completion_proc => lambda {|command, arg| %w[complete1 complete2] },
+        :help            => ['update,u TEXT', 'test command']
       }
       @command = Command.new(params)
     end
 
-    it 'should return command regex' do
-      @command.pattern.should == /^((update|u|up)|(update|u|up)\s+(.*?))\s*$/
+    describe '#pattern' do
+      it 'returns command regex' do
+        @command.pattern.
+          should == /^((update|u|up)|(update|u|up)\s+(.*?))\s*$/
+      end
     end
 
-    it 'should be given name as String or Symbol' do
+    it 'is given name as String or Symbol' do
       Command.new(:name => 'foo').name.should == :foo
       Command.new(:name => :foo).name.should == :foo
     end
 
-    it 'should return name' do
+    it 'returns name' do
       @command.name.should == :update
     end
 
-    it 'should return aliases' do
+    it 'returns aliases' do
       @command.aliases.should == [:u, :up]
     end
 
-    it 'should return commands' do
+    it 'returns commands' do
       @command.commands.should == [:update, :u, :up]
     end
 
-    it 'should return help' do
+    it 'returns help' do
       @command.help.should == ['update,u TEXT', 'test command']
     end
 
-    it 'should return candidates for completion' do
+    it 'returns candidates for completion' do
       # complement
       [
         ['upd',       ['update']],
         [' upd',      []],
         [' upd ',     []],
-        ['update a',    ['complete1', 'complete2']],
+        ['update a',  ['complete1', 'complete2']],
         [' update  ', []],
         ['u foo',     ['complete1', 'complete2']],
       ].each do |input, comp|
@@ -56,7 +77,7 @@ module Termtter
       end
     end
 
-    it 'should return command_info when call method "match?"' do
+    it 'returns command_info when call method "match?"' do
       [
         ['update',       true],
         ['up',           true],
@@ -75,33 +96,45 @@ module Termtter
       end
     end
 
-    it 'should raise ArgumentError when constructor arguments are deficient' do
-      lambda { Command.new }.should raise_error(ArgumentError)
-      lambda { Command.new(:exec_proc => lambda {|args|}) }.should raise_error(ArgumentError)
-      lambda { Command.new(:aliases => ['u']) }.should raise_error(ArgumentError)
-    end
-
-    it 'should call exec_proc when call method "call"' do
+    it 'calls exec_proc when call method "call"' do
       @command.call('foo', 'test', 'foo test').should == 'test'
       @command.call('foo', ' test', 'foo  test').should == ' test'
       @command.call('foo', ' test ', 'foo  test ').should == ' test '
       @command.call('foo', 'test test', 'foo test test').should == 'test test'
     end
 
-    it 'should raise ArgumentError at call' do
-      lambda { @command.call('foo', nil, 'foo') }.should_not raise_error(ArgumentError)
-      lambda { @command.call('foo', 'foo', 'foo') }.should_not raise_error(ArgumentError)
-      lambda { @command.call('foo', false, 'foo') }.should raise_error(ArgumentError)
-      lambda { @command.call('foo', Array.new, 'foo') }.should raise_error(ArgumentError)
+    it 'raises ArgumentError at call' do
+      lambda { @command.call('foo', nil, 'foo') }.
+        should_not raise_error(ArgumentError)
+      lambda { @command.call('foo', 'foo', 'foo') }.
+        should_not raise_error(ArgumentError)
+      lambda { @command.call('foo', false, 'foo') }.
+        should raise_error(ArgumentError)
+      lambda { @command.call('foo', Array.new, 'foo') }.
+        should raise_error(ArgumentError)
     end
 
-    it 'split command line' do
-      Command.split_command_line('test foo bar').should == ['test', 'foo bar']
-      Command.split_command_line('test   foo bar').should == ['test', 'foo bar']
-      Command.split_command_line('test   foo  bar').should == ['test', 'foo  bar']
-      Command.split_command_line(' test   foo  bar').should == ['test', 'foo  bar']
-      Command.split_command_line(' test   foo  bar ').should == ['test', 'foo  bar']
+    describe '#alias=' do
+      it 'wraps aliases=' do
+        a = :ujihisa
+        @command.should_receive(:aliases=).with([a])
+        @command.alias = a
+      end
+    end
+
+    describe '.split_command_line' do
+      it 'splits from a command line string to the command name and the arg' do
+        Command.split_command_line('test foo bar').
+          should == ['test', 'foo bar']
+        Command.split_command_line('test   foo bar').
+          should == ['test', 'foo bar']
+        Command.split_command_line('test   foo  bar').
+          should == ['test', 'foo  bar']
+        Command.split_command_line(' test   foo  bar').
+          should == ['test', 'foo  bar']
+        Command.split_command_line(' test   foo  bar ').
+          should == ['test', 'foo  bar']
+      end
     end
   end
 end
-

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: termtter
 version: !ruby/object:Gem::Version 
-  version: 1.1.3
+  version: 1.2.0
 platform: ruby
 authors: 
 - jugyo
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-30 00:00:00 +09:00
+date: 2009-05-17 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -114,6 +114,7 @@ files:
 - lib/plugins/post_exec_hook_sample.rb
 - lib/plugins/pre_exec_hook_sample.rb
 - lib/plugins/primes.rb
+- lib/plugins/protected_filter.rb
 - lib/plugins/quicklook.rb
 - lib/plugins/random.rb
 - lib/plugins/reblog.rb