jugyo-termtter 1.1.3 → 1.3.0

data/lib/termtter/client.rb

@@ -14,7 +14,6 @@ module Termtter
     @commands = {}
     @filters = []
     @since_id = nil
-    @input_thread = nil
     @task_manager = Termtter::TaskManager.new
 
     config.set_default(:logger, nil)
@@ -28,11 +27,14 @@ module Termtter
 
       attr_reader :commands, :hooks
 
+      # plug :: Name -> (Hash) -> IO () where NAME = String | Symbol | [NAME]
       def plug(name, options = {})
-        unless options.empty?
-          options.each do |key, value|
-            config.plugins.__refer__(name.to_sym).__assign__(key.to_sym, value)
-          end
+        if Array === name # Obviously `name.respond_to?(:each)` is better, but for 1.8.6 compatibility we cannot.
+          name.each {|i| plug(i, options) }
+          return
+        end
+        options.each do |key, value|
+          config.plugins.__refer__(name.gsub(/-/, '_').to_sym).__assign__(key.to_sym, value)
         end
         load "plugins/#{name}.rb"
       rescue Exception => e
@@ -52,14 +54,19 @@ module Termtter
         @filters.clear
       end
 
-      def register_hook(arg)
+      def register_hook(arg, opts = {}, &block)
         hook = case arg
           when Hook
             arg
           when Hash
             Hook.new(arg)
+          when String, Symbol
+            options = { :name => arg }
+            options.merge!(opts)
+            options[:exec_proc] = block
+            Hook.new(options)
           else
-            raise ArgumentError, 'must be given Termtter::Hook or Hash'
+            raise ArgumentError, 'must be given Termtter::Hook, Hash, String or Symbol'
           end
         @hooks[hook.name] = hook
       end
@@ -69,23 +76,39 @@ module Termtter
       end
 
       def get_hooks(point)
+        # TODO: sort by alphabet
         @hooks.values.select do |hook|
           hook.match?(point)
         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, Symbol
+            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(Symbol) 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
@@ -117,14 +140,14 @@ module Termtter
       def output(statuses, event)
         return if statuses.nil? || statuses.empty?
 
-        statuses = statuses.sort_by{|s|s.id}
+        statuses = statuses.sort_by(&: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|
@@ -136,10 +159,9 @@ module Termtter
       end
 
       def apply_filters_for_hook(hook_name, statuses, event)
-        get_hooks(hook_name).each do |hook|
-          statuses = hook.call(statuses, event)
-        end
-        statuses
+        get_hooks(hook_name).inject(statuses) {|s, hook|
+          hook.call(s, event)
+        }
       end
 
       # return last hook return value
@@ -153,36 +175,41 @@ module Termtter
       end
 
       def call_commands(text)
-        return if text.empty?
-
-        commands = find_commands(text)
-        raise CommandNotFound, text if commands.empty?
-
-        commands.each do |command|
-          command_found = true
-          command_str, command_arg = Command.split_command_line(text)
-
-          modified_arg = call_hooks(
-                            "modify_arg_for_#{command.name.to_s}",
-                            command_str,
-                            command_arg) || command_arg || ''
+        @task_manager.invoke_and_wait do
+          call_hooks("pre_command", text)
+          # FIXME: This block can become Maybe Monad
+          get_hooks("pre_command").each {|hook|
+            break if text == nil # interrupt if hook returns nil
+            text = hook.call(text)
+          }
+          return if text.empty?
+
+          commands = find_commands(text)
+          raise CommandNotFound, text if commands.empty?
+
+          commands.each do |command|
+            command_str, command_arg = Command.split_command_line(text)
+
+            modified_arg = command_arg
+            # FIXME: This block can become Maybe Monad
+            get_hooks("modify_arg_for_#{command.name.to_s}").each {|hook|
+              break if modified_arg == false # interrupt if hook return false
+              modified_arg = hook.call(command_str, modified_arg)
+            }
 
-          @task_manager.invoke_and_wait do
             begin
               call_hooks("pre_exec_#{command.name.to_s}", command, modified_arg)
-              # exec command
-              result = command.call(command_str, modified_arg, text)
-              if result
-                call_hooks("post_exec_#{command.name.to_s}", command_str, modified_arg, result)
-              end
+              result = command.call(command_str, modified_arg, text) # exec command
+              call_hooks("post_exec_#{command.name.to_s}", command_str, modified_arg, result)
             rescue CommandCanceled
             end
           end
+          call_hooks("post_command", text)
         end
       end
 
       def find_commands(text)
-        @commands.values.select { |command| command.match?(text) }
+        @commands.values.select {|command| command.match?(text) }
       end
 
       def pause
@@ -199,10 +226,8 @@ module Termtter
 
       def exit
         puts 'finalizing...'
-
         call_hooks(:exit)
         @task_manager.kill
-        @input_thread.kill if @input_thread
       end
 
       def load_config
@@ -233,56 +258,6 @@ module Termtter
           Termtter::CONF_FILE)
       end
 
-      def setup_readline
-        if Readline.respond_to?(:basic_word_break_characters=)
-          Readline.basic_word_break_characters= "\t\n\"\\'`><=;|&{("
-        end
-        Readline.completion_proc = lambda {|input|
-          begin
-            @commands.map {|name, command| command.complement(input) }.flatten.compact
-          rescue => e
-            handle_error(e)
-          end
-        }
-        vi_or_emacs = config.editing_mode
-        unless vi_or_emacs.empty?
-          Readline.__send__("#{vi_or_emacs}_editing_mode")
-        end
-      end
-
-      def trap_setting()
-        begin
-          stty_save = `stty -g`.chomp
-          trap("INT") do
-            begin
-              system "stty", stty_save
-            ensure
-              exit
-            end
-          end
-        rescue Errno::ENOENT
-        end
-      end
-
-      def start_input_thread
-        setup_readline()
-        trap_setting()
-        @input_thread = Thread.new do
-          while buf = Readline.readline(ERB.new(config.prompt).result(API.twitter.__send__(:binding)), true)
-            Readline::HISTORY.pop if buf.empty?
-            begin
-              call_commands(buf)
-            rescue CommandNotFound => e
-              warn "Unknown command \"#{e}\""
-              warn 'Enter "help" for instructions'
-            rescue => e
-              handle_error e
-            end
-          end
-        end
-        @input_thread.join
-      end
-
       def logger
         @logger
       end
@@ -293,7 +268,7 @@ module Termtter
 
       def default_logger
         logger = Logger.new(STDOUT)
-        logger.formatter = lambda { |severity, time, progname, message|
+        logger.formatter = lambda {|severity, time, progname, message|
           color =
             case severity
             when /^DEBUG/
@@ -325,17 +300,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 'defaults'
         plug 'devel' if config.devel
-
-        config.system.load_plugins.each do |plugin|
-          plug plugin
-        end
+        plug config.system.load_plugins
 
         config.system.eval_scripts.each do |script|
           begin
@@ -345,12 +312,12 @@ module Termtter
           end
         end
 
-        config.system.run_commands.each { |cmd| call_commands(cmd) }
+        config.system.run_commands.each {|cmd| call_commands(cmd) }
 
         unless config.system.cmd_mode
-          call_hooks(:initialize)
           @task_manager.run()
-          start_input_thread()
+          call_hooks(:initialize)
+          call_hooks(:launched)
         end
       end
 
@@ -366,6 +333,27 @@ module Termtter
         puts "Error: #{e}"
         puts e.backtrace.join("\n")
       end
+
+      def confirm(message, default_yes = true, &block)
+        pause # TODO: TaskManager から呼ばれるならこれいらないなぁ
+
+        result = # Boolean in duck typing
+          if default_yes
+            prompt = "\"#{message}".strip + "\" [Y/n] "
+            /^y?$/i =~ Readline.readline(prompt, false)
+          else
+            prompt = "\"#{message}".strip + "\" [N/y] "
+            /^n?$/i =~ Readline.readline(prompt, false)
+          end
+
+        if result && block
+          block.call
+        end
+
+        result
+      ensure
+        resume # TODO: TaskManager から呼ばれるならこれいらないなぁ
+      end
     end
   end
 end

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

@@ -19,7 +19,10 @@ module Termtter
           tmp.__assign__(last.to_sym, value)
         end
       else
-        __assign__(name.to_sym, value) if __refer__(name.to_sym).empty?
+        current_value = __refer__(name.to_sym)
+        if current_value.kind_of?(self.class) && current_value.empty?
+          __assign__(name.to_sym, value)
+        end
       end
     end
 
@@ -51,6 +54,10 @@ module Termtter
       @store.dup
     end
 
+    def __clear__
+      @store.clear
+    end
+
     __instance = self.new
     (class << self; self end).
       __send__(:define_method, :instance) { __instance }
@@ -61,8 +68,3 @@ def config
   Termtter::Config.instance
 end
 
-def configatron
-  # remove this method until Termtter-1.2.0
-  warn "configatron method will be removed. Use config instead. (#{caller.first})"
-  Termtter::Config.instance
-end

data/lib/termtter/config_setup.rb

@@ -19,7 +19,7 @@ module Termtter
       config = ERB.new(template, nil, '-').result(binding) # trim_mode => '-'
 
       Dir.mkdir(Termtter::CONF_DIR) unless File.exists?(Termtter::CONF_DIR)
-      File.open(Termtter::CONF_FILE, 'w') {|io|
+      File.open(Termtter::CONF_FILE, 'w', 0600) {|io|
         io << config
       }
 

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/hook.rb

@@ -12,7 +12,7 @@ module Termtter
     end
 
     def match?(point)
-      !points.select{|pt|
+      points.any? {|pt|
         case pt
         when String, Symbol
           pt.to_s == point.to_s
@@ -21,7 +21,7 @@ module Termtter
         else
           false
         end
-      }.empty?
+      }
     end
 
     def call(*args)

data/lib/termtter/optparse.rb

@@ -10,7 +10,7 @@ OptionParser.new { |opt|
   end
 
   opt.on('-d', '--devel', 'Start in developer mode') do |flg|
-    config.system.__assign__(:devel, true) if flg
+    config.__assign__(:devel, true) if flg
   end
 
   config.system.cmd_mode = false
@@ -33,6 +33,19 @@ OptionParser.new { |opt|
     config.system.eval_scripts << script
   end
 
+  config.system.eval_scripts = []
+  opt.on('-m', '--monochrome', 'No shell escapes for color highlightings') do |script|
+    require 'termcolor'
+    module TermColor
+      class << self
+        alias parse_orig parse
+        def parse(o)
+          o.gsub(/<.+?>(.*?)<\/.+?>/, '\1')
+        end
+      end
+    end
+  end
+
   opt.version = Termtter::VERSION
   opt.parse!(ARGV)
 }

data/lib/termtter/system_extensions.rb

@@ -108,8 +108,9 @@ if win?
     str.to_s.gsub("\xef\xbd\x9e", "\xe3\x80\x9c").split(/(\e\[\d*[a-zA-Z])/).each do |token|
       case token
       when /\e\[(\d+)m/
-        $wSetConsoleTextAttribute.call $hStdOut, $colorMap[$1.to_i].to_i
-	  when /\e\[\d*[a-zA-Z]/
+        color = $1.to_i > 90 ? ($1.to_i % 60) : $1.to_i
+        $wSetConsoleTextAttribute.call $hStdOut, $colorMap[color].to_i
+      when /\e\[\d*[a-zA-Z]/
         # do nothing
       else
         loop do

data/lib/termtter/task_manager.rb

@@ -51,11 +51,7 @@ module Termtter
 
     def invoke_and_wait(&block)
       synchronize do
-        begin
-          yield
-        rescue Exception => e
-          Termtter::Client.handle_error(e)
-        end
+        yield
       end
     end
 

data/lib/termtter/version.rb

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

data/spec/plugins/cool_spec.rb

@@ -5,6 +5,6 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe Termtter::Client, 'when the plugin cool is loaded' do
   it 'should add something about cool' do
     Termtter::Client.should_receive(:register_macro)
-    plugin 'cool'
+    Termtter::Client.plug 'cool'
   end
 end

data/spec/plugins/curry_spec.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Termtter::Client, 'when the plugin curry is loaded' do
+  it 'should add command curry' do
+    Termtter::Client.should_receive(:register_command).twice
+    Termtter::Client.should_receive(:register_hook).twice
+    Termtter::Client.plug 'curry'
+  end
+end
+
+# FIXME: Lack of specs

data/spec/plugins/db_spec.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'db' do
+  DB_PATH = '/tmp/termtter.db'
+
+  before(:each) do
+    File.delete(DB_PATH) if File.exists?(DB_PATH)
+    config.plugins.db.path = DB_PATH
+    load 'plugins/db.rb'
+  end
+
+  after do
+    File.delete(DB_PATH) if File.exists?(DB_PATH)
+  end
+
+  it 'should created db file' do
+    File.exists?(DB_PATH)
+  end
+
+  it 'saves statuses' do
+    now = Time.now.to_s
+    Status << {:user_id => 1, :text => 'foo', :created_at => now}
+    dataset = Status.all
+    dataset.size.should == 1
+    dataset[0].user_id.should == 1
+    dataset[0].text.should == 'foo'
+    dataset[0].created_at.should == now
+  end
+
+  it 'saves users' do
+    User << {:screen_name => 'jugyo'}
+    dataset = User.all
+    dataset.size.should == 1
+    dataset[0].screen_name.should == 'jugyo'
+  end
+
+  it 'calls hook' do
+    user_struct = Struct.new(:id, :screen_name)
+    user_1 = user_struct.new(1, 'jugyo')
+    user_2 = user_struct.new(2, 'oyguj')
+
+    status_struct = Struct.new(:id, :text, :source, :user, :in_reply_to_status_id,
+      :in_reply_to_user_id, :created_at)
+    statuses = []
+    statuses << status_struct.new(1, 'foo', 'termtter', user_1, 100, Time.now.to_s)
+    statuses << status_struct.new(2, 'bar', 'termtter', user_1, nil, nil, Time.now.to_s)
+    statuses << status_struct.new(3, 'xxx', 'web', user_2, nil, nil, Time.now.to_s)
+
+    Termtter::Client.hooks[:collect_statuses_for_db].call(statuses, :update_friends_timeline)
+
+    dataset = User.all
+    dataset.size.should == 2
+
+    dataset = Status.all
+    dataset.size.should == 3
+
+    User[:id => 1].statuses.size.should == 2
+    Status[:id => 1].user.id.should == 1
+  end
+end

data/spec/plugins/english_spec.rb

@@ -5,7 +5,7 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe Termtter do
   it 'english? method' do
     Termtter::Client.should_receive(:add_filter)
-    plugin 'english'
+    Termtter::Client.plug 'english'
     Termtter::English.english?('This is a pen.').should be_true
     Termtter::English.english?('これはペンです.').should be_false
     Termtter::English.english?('これはpenです.').should be_false
@@ -13,7 +13,7 @@ describe Termtter do
 
   it 'apply filter english only update_friends_timeline'
   # NOTE: when below code is evaluated,
-  #     plugin 'english', :only => [:update_friends_timeline]
+  #     t.plug 'english', :only => [:update_friends_timeline]
   #   in update_friends_timeline there are English posts only but in replies there are both Japanese posts and English posts.
   #   It's too difficult for me to write that spec, so this spec is pending now. Please write this spec, hey, you, a cool hacker!
 end

data/spec/plugins/fib_spec.rb

@@ -5,11 +5,11 @@ require File.dirname(__FILE__) + '/../spec_helper'
 describe Termtter::Client, 'when the plugin fib is loaded' do
   it 'should add command fib' do
     Termtter::Client.should_receive(:register_command).twice
-    plugin 'fib'
+    Termtter::Client.plug 'defaults/fib'
   end
 
   it 'should define fib method' do
-    plugin 'fib'
+    Termtter::Client.plug 'defaults/fib'
     (0..10).map {|i| fib i }.should == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
   end
 end

data/spec/plugins/filter_spec.rb

@@ -6,11 +6,11 @@ module Termtter
   describe Client, 'when the filter plugin is loaded' do
     it 'should add command filter, filters and unfilter' do
       Termtter::Client.should_receive(:register_command).exactly(3)
-      plugin 'filter'
+      Termtter::Client.plug 'filter'
     end
 
     it 'should set public_storage[:filters]' do
-      plugin 'filter'
+      Termtter::Client.plug 'filter'
       Client::public_storage.keys.should be_include(:filters)
     end
   end