termtter 1.0.3 → 1.0.4

data/lib/plugins/stdout.rb

@@ -11,68 +11,49 @@ config.plugins.stdout.set_default(
   '<90><%=time%></90> <<%=status_color%>><%=status%></<%=status_color%>> <90><%=id%></90>')
 config.plugins.stdout.set_default(:search_highlihgt_format, '<on_magenta><white>\1</white></on_magenta>')
 
-$highline = HighLine.new
-
-def color(str, value)
-  return str if value == :none
-  case value
-  when String, Symbol
-    $highline.color(str, value)
-  else
-    "\e[#{value}m#{str}\e[0m"
-  end
-end
-
-module Termtter::Client
-
-  def self.print_statuses(statuses, sort = true, time_format = '%H:%M:%S')
-    (sort ? statuses.sort_by{ |s| s.id} : statuses).each do |s|
-      text = s.text
-      status_color = config.plugins.stdout.colors[s.user.screen_name.hash % config.plugins.stdout.colors.size]
-      status = "#{s.user.screen_name}: #{text}"
-      if s.in_reply_to_status_id
-        status += " (repl. to #{s.in_reply_to_status_id})"
-      end
-
-      time = "(#{Time.parse(s.created_at).strftime(time_format)})"
-      id = s.id
-      erbed_text = ERB.new(config.plugins.stdout.timeline_format).result(binding)
-      puts TermColor.parse(erbed_text)
+module Termtter
+  class StdOut < Hook
+    def initialize
+      super(:name => :stdout, :points => [:output])
     end
-  end
-
-  def self.print_statuses_with_date(statuses, sort = true)
-    print_statuses(statuses, sort, '%m-%d %H:%M')
-  end
 
-  def self.print_search_results(result, time_format = '%H:%M:%S')
-    result.results.sort_by{|r| r.created_at}.each do |r|
-      text = r.text.
-                gsub(/(\n|\r)/, '').
-                gsub(/(#{Regexp.escape(result.query)})/i, config.plugins.stdout.search_highlihgt_format)
-      status_color = config.plugins.stdout.colors[r.from_user_id.to_i.hash % config.plugins.stdout.colors.size]
-      status = "#{r.from_user}: #{text}"
-      time = "(#{Time.parse(r.created_at).strftime(time_format)})"
-      id = r.id
-      erbed_text = ERB.new(config.plugins.stdout.timeline_format).result(binding)
-      puts TermColor.parse(erbed_text)
+    def execute(statuses, event)
+      print_statuses(statuses)
     end
-  end
 
-  add_hook do |result, event|
-    case event
-    when :update_friends_timeline, :list_friends_timeline
-      print_statuses(result) unless result.empty?
-    when :list_user_timeline, :replies
-      print_statuses_with_date(result) unless result.empty?
-    when :show
-      print_statuses_with_date([result])
-    when :search
-      print_search_results(result)
+    def print_statuses(statuses, sort = true, time_format = nil)
+      return unless statuses
+      unless time_format
+        # 最初と最後の日付がちがうとき日付も出す
+        t1 = Time.parse(statuses.first[:created_at])
+        t2 = Time.parse(statuses.last[:created_at])
+        time_format = 
+          if [t1.year, t1.month, t1.day] == [t2.year, t2.month, t2.day]
+            '%H:%M:%S'
+          else
+            '%y/%m/%d %H:%M'
+          end
+      end
+      
+      statuses.each do |s|
+        text = s.text
+        status_color = config.plugins.stdout.colors[s.user.id.hash % config.plugins.stdout.colors.size]
+        status = "#{s.user.screen_name}: #{text}"
+        if s.in_reply_to_status_id
+          status += " (repl. to #{s.in_reply_to_status_id})"
+        end
+
+        time = "(#{Time.parse(s.created_at).strftime(time_format)})"
+        id = s.id
+        erbed_text = ERB.new(config.plugins.stdout.timeline_format).result(binding)
+        puts TermColor.parse(erbed_text)
+      end
     end
   end
 
+  Client.register_hook(StdOut.new)
 end
+
 # stdout.rb
 #   output statuses to stdout
 # example config

data/lib/plugins/storage.rb

@@ -8,40 +8,34 @@ require File.dirname(__FILE__) + '/storage/status'
 module Termtter::Client
   public_storage[:log] = []
 
-  add_hook do |statuses, event|
-    case event
-    when :pre_filter
+  register_hook(
+    :name => :storage,
+    :points => [:pre_filter],
+    :exec_proc => lambda {|statuses, event|
       statuses.each do |s|
         Termtter::Storage::Status.insert(
           :post_id => s.id,
           :created_at => Time.parse(s.created_at).to_i,
           :in_reply_to_status_id => s.in_reply_to_status_id,
           :in_reply_to_user_id => s.in_reply_to_user_id,
-          :post_text => s.text,
+          :post => s.text,
           :user_id => s.user.id,
-          :screen_name => s.user.screen_name)
+          :screen_name => s.user.screen_name
+        )
       end
-    end
-  end
+    }
+  )
 
   register_command(
-    :name => :search_storage, :aliases => [:ss],
+    :name => :search_storage,
+    :aliases => [:ss],
     :exec_proc => lambda {|arg|
       unless arg.strip.empty?
         key = arg.strip
-        Termtter::Storage::Status.search({ :post_text => key})
-=begin
-                       statuses = public_storage[:storage].search({ :post_text => key})
-
-                       statuses.each do |s|
-                         p s
-                       end
-                         call_hooks(statuses, :search)
-=end                       
-                     end
-
-                   },
-                   
-                   :help => [ 'search_storage WORD', 'Search storage for WORD' ]
-                   )
+        statuses = Termtter::Storage::Status.search({:text => key})
+        output(statuses, :search)
+      end
+    },
+    :help => [ 'search_storage WORD', 'Search storage for WORD' ]
+  )
 end

data/lib/plugins/storage/status.rb

@@ -7,42 +7,45 @@ module Termtter::Storage
   class Status
     KEYS = %w[post_id created_at in_reply_to_status_id in_reply_to_user_id post_text user_id screen_name]
 
-    def size
+    def self.size
       DB.instance.db.get_first_value("select count(*) from post").to_i
     end
 
     def self.search(query)
       raise "query must be Hash(#{query}, #{query.class})" unless query.kind_of? Hash
-
-      DB.instance.db.execute("select created_at, screen_name, post_text, in_reply_to_status_id, post_id from post inner join user on post.user_id = user.id where post_text like '%' || ? || '%' ", query[:post_text]) do |created_at, screen_name, post_text, in_reply_to_status_id, post_id|
-
-#      DB.instance.db.execute("select created_at, screen_name, post_text, in_reply_to_status_id, post_id from post inner join user on post.user_id = user.id where post_text like '%of%' ", query[:post_text]) do |created_at, screen_name, post_text, in_reply_to_status_id, post_id|
-        p [created_at, screen_name, post_text, in_reply_to_status_id, post_id]
+      result = []
+      DB.instance.db.execute("select created_at, screen_name, post_text, in_reply_to_status_id, post_id, user_id from post inner join user on post.user_id = user.id where post_text like '%' || ? || '%' ",
+                             query[:text]) do |created_at, screen_name, post_text, in_reply_to_status_id, post_id, user_id|
+        created_at = Time.at(created_at).to_s
+        result << {
+          :id => post_id,
+          :created_at => created_at,
+          :text => post_text,
+          :in_reply_to_status_id => in_reply_to_status_id,
+          :in_reply_to_user_id => nil,
+          :user => {
+            :id => user_id,
+            :screen_name => screen_name
+          }
+        }
       end
+      Rubytter.json_to_struct(result)
     end
 
     def self.insert(data)
-      raise "data must be Hash(#{data}, #{data.class})" unless data.kind_of? Hash
-      # 条件しぼりたいけどやりかたがうまくわからない
-      #      raise "unko" unless data.keys.all?{|c| KEYS.include? c}
-      begin
       DB.instance.db.execute(
                              "insert into post values(?,?,?,?,?,?)",
                              data[:post_id],
                              data[:created_at],
                              data[:in_reply_to_status_id],
                              data[:in_reply_to_user_id],
-                             data[:post_text],
+                             data[:text],
                              data[:user_id])
-        begin
-          DB.instance.db.execute(
-                                 "insert into user values(?,?)",
-                                 data[:user_id],
-                                 data[:screen_name])
-        rescue # FIXME: specify exceptions here
-        end
-        rescue # FIXME: specify exceptions here
-      end
+      DB.instance.db.execute(
+                             "insert into user values(?,?)",
+                             data[:user_id],
+                             data[:screen_name])
+    rescue SQLite3::SQLException
     end
   end
 end

data/lib/plugins/update_editor.rb

@@ -8,7 +8,7 @@ module Termtter::Client
   else
     config.plugins.update_editor.set_default('editor', 'vi')
   end
-  config.plugins.update_editor.set_default('add_completion', false)
+  config.plugins.update_editor.set_default('add_completion', true)
 
   
   def self.input_editor

data/lib/plugins/uri-open.rb

@@ -3,13 +3,15 @@
 module Termtter::Client
   public_storage[:uris] = []
 
-  add_hook do |statuses, event, t|
-    if event == :update_friends_timeline
+  register_hook(
+    :name => :uri_open,
+    :points => [:post_filter],
+    :exec_proc => lambda {|statuses, event|
       statuses.each do |s|
-        public_storage[:uris] += s.text.scan(%r|https?://[^\s]+|)
+        public_storage[:uris] += s[:post_text].scan(%r|https?://[^\s]+|)
       end
-    end
-  end
+    }
+  )
 
   def self.open_uri(uri)
     unless config.plugins.uri_open.browser.empty?

data/lib/plugins/url_addspace.rb

@@ -1,9 +1,9 @@
 # -*- coding: utf-8 -*-
 
 module Termtter::Client
-  add_filter do |statuses|
+  add_filter do |statuses, event|
     statuses.each do |s|
-      s.text.gsub!(/(\S)(https?:\/\/)/, '\1 \2')
+      s[:post_text].gsub!(/(\S)(https?:\/\/)/, '\1 \2')
     end
     statuses
   end

data/lib/termtter/api.rb

@@ -19,12 +19,13 @@ module Termtter
                     config.user_name,
                     config.password,
                     {
+                      :app_name => Termtter::APP_NAME,
                       :host => config.host,
                       :header => {
                         'User-Agent' => 'Termtter http://github.com/jugyo/termtter',
                         'X-Twitter-Client' => 'Termtter',
                         'X-Twitter-Client-URL' => 'http://github.com/jugyo/termtter',
-                        'X-Twitter-Client-Version' => '0.1'
+                        'X-Twitter-Client-Version' => Termtter::VERSION
                       },
                       :enable_ssl => config.enable_ssl,
                       :proxy_host => config.proxy.host,

data/lib/termtter/client.rb

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 require 'fileutils'
+require 'logger'
 
 module Termtter
   APP_NAME = 'termtter'
@@ -18,15 +19,14 @@ module Termtter
     class << self
 
       def init
-        @@hooks = []
-        @@new_hooks = {}
-        @@new_commands = {}
-        @@completions = []
-        @@filters = []
-        @@helps = []
-        @@since_id = nil
-        @@input_thread = nil
-        @@task_manager = Termtter::TaskManager.new
+        @hooks = {}
+        @commands = {}
+        @filters = []
+        @since_id = nil
+        @input_thread = nil
+        @task_manager = Termtter::TaskManager.new
+        config.log.set_default(:logger, nil)
+        config.log.set_default(:level, nil)
         config.set_default(:update_interval, 300)
         config.set_default(:prompt, '> ')
         config.set_default(:devel, false)
@@ -34,15 +34,15 @@ module Termtter
       end
 
       def public_storage
-        @@public_storage ||= {}
+        @public_storage ||= {}
       end
 
-      %w[hook completion filter].each do |n|
-        eval <<-EOF
-          def add_#{n}(&b)
-            @@#{n}s << b
-          end
-        EOF
+      def add_filter(&b)
+        filters << b
+      end
+
+      def clear_filter
+        filters.clear
       end
 
       def register_hook(arg)
@@ -54,15 +54,15 @@ module Termtter
           else
             raise ArgumentError, 'must be given Termtter::Hook or Hash'
           end
-        @@new_hooks[hook.name] = hook
+        @hooks[hook.name] = hook
       end
 
       def get_hook(name)
-        @@new_hooks[name]
+        @hooks[name]
       end
 
       def get_hooks(point)
-        @@new_hooks.values.select do |hook|
+        @hooks.values.select do |hook|
           hook.match?(point)
         end
       end
@@ -76,11 +76,11 @@ module Termtter
           else
             raise ArgumentError, 'must be given Termtter::Command or Hash'
           end
-        @@new_commands[command.name] = command
+        @commands[command.name] = command
       end
 
       def get_command(name)
-        @@new_commands[name]
+        @commands[name]
       end
 
       def register_macro(name, macro, options = {})
@@ -91,58 +91,44 @@ module Termtter
         register_command(command)
       end
 
-      def add_help(name, desc)
-        @@helps << [name, desc]
-      end
-
-      %w[hooks completions helps filters].each do |n|
-        eval <<-EOF
-          def clear_#{n}
-            @@#{n}.clear
-          end
-        EOF
+      # statuses => [status, status, ...]
+      # status => {
+      #             :id => status id,
+      #             :created_at => created time,
+      #             :user_id => user id,
+      #             :name => user name,
+      #             :screen_name => user screen_name,
+      #             :source => source,
+      #             :reply_to => reply_to status id,
+      #             :text => status,
+      #             :original_data => original data,
+      #           }
+      def output(statuses, event)
+        return if statuses.nil? || statuses.empty?
+
+        statuses = statuses.sort_by{|s|s.id}
+        call_hooks(:pre_filter, statuses, event)
+        filtered = apply_filters(statuses, event)
+        call_hooks(:post_filter, filtered, event)
+        call_hooks(:output, filtered, event)
       end
 
-      # memo: each filter must return Array of Status
-      def apply_filters(result, event = nil)
-        case event
-        when :show
-          result
-        when :search
-          filtered = result.results.map(&:dup)
-          @@filters.each do |f|
-            filtered = f.call(filtered, event)
-          end
-          result.results = filtered
-          result
-        else
-          filtered = result.map(&:dup)
-          @@filters.each do |f|
+      def apply_filters(statuses, event)
+          filtered = statuses.map(&:dup)
+          @filters.each do |f|
             filtered = f.call(filtered, event)
           end
           filtered
-        end
-      rescue => e
-        handle_error(e)
-        result
-      end
-
-      def do_hooks(statuses, event)
-        @@hooks.each do |h|
-          begin
-            h.call(statuses.dup, event, Termtter::API.twitter)
-          rescue => e
-            handle_error(e)
-          end
-        end
+        rescue => e
+          handle_error(e)
       end
 
       # return last hook return value
-      def call_new_hooks(point, *args)
+      def call_hooks(point, *args)
         result = nil
         get_hooks(point).each {|hook|
           break if result == false # interrupt if hook return false
-          result = hook.exec_proc.call(*args)
+          result = hook.execute(*args)
         }
         result
       rescue => e
@@ -153,36 +139,29 @@ module Termtter
         end
       end
 
-      # TODO: delete argument "tw" when unnecessary
-      def call_hooks(statuses, event, tw = nil)
-        do_hooks(statuses, :pre_filter)
-        filtered = apply_filters(statuses, event)
-        do_hooks(filtered, :post_filter)
-        do_hooks(filtered, event)
-      end
-
       def call_commands(text, tw = nil)
         return if text.empty?
 
         command_found = false
-        @@new_commands.each do |key, command|
+        @commands.each do |key, command|
+          # match? メソッドがなんかきもちわるいので変える予定
           command_str, command_arg = command.match?(text)
           if command_str
             command_found = true
 
-            modified_arg = call_new_hooks(
+            modified_arg = call_hooks(
                               "modify_arg_for_#{command.name.to_s}",
                               command_str,
                               command_arg) || command_arg || ''
 
-            @@task_manager.invoke_and_wait do
+            @task_manager.invoke_and_wait do
 
-              pre_exec_hook_result = call_new_hooks("pre_exec_#{command.name.to_s}", command_str, modified_arg)
+              pre_exec_hook_result = call_hooks("pre_exec_#{command.name.to_s}", command_str, modified_arg)
               next if pre_exec_hook_result == false
               # exec command
               result = command.execute(modified_arg)
               if result
-                call_new_hooks("post_exec_#{command.name.to_s}", command_str, modified_arg, result)
+                call_hooks("post_exec_#{command.name.to_s}", command_str, modified_arg, result)
               end
 
             end
@@ -193,24 +172,23 @@ module Termtter
       end
 
       def pause
-        @@task_manager.pause
+        @task_manager.pause
       end
 
       def resume
-        @@task_manager.resume
+        @task_manager.resume
       end
 
       def add_task(*arg, &block)
-        @@task_manager.add_task(*arg, &block)
+        @task_manager.add_task(*arg, &block)
       end
 
       def exit
         puts 'finalizing...'
 
-        call_hooks([], :exit)
-        call_new_hooks(:exit)
-        @@task_manager.kill
-        @@input_thread.kill if @@input_thread
+        call_hooks(:exit)
+        @task_manager.kill
+        @input_thread.kill if @input_thread
       end
 
       def load_default_plugins
@@ -246,7 +224,7 @@ module Termtter
           Termtter::CONF_FILE)
       end
 
-      def pre_config_load()
+      def post_config_load()
         if config.system.devel
           plugin 'devel'
         end
@@ -258,14 +236,7 @@ module Termtter
         end
         Readline.completion_proc = lambda {|input|
           begin
-            # FIXME: when migrate to Termtter::Command
-            completions = @@completions.map {|completion|
-              completion.call(input)
-            }
-            completions += @@new_commands.map {|name, command|
-              command.complement(input)
-            }
-            completions.flatten.compact
+            @commands.map {|name, command| command.complement(input) }.flatten.compact
           rescue => e
             handle_error(e)
           end
@@ -276,19 +247,20 @@ module Termtter
         end
       end
 
+      # TODO: Make pluggable
       def setup_update_timeline_task()
         register_command(
           :name => :_update_timeline,
           :exec_proc => lambda {|arg|
             begin
-              args = @@since_id ? [{:since_id => @@since_id}] : []
+              args = @since_id ? [{:since_id => @since_id}] : []
               statuses = Termtter::API.twitter.friends_timeline(*args)
               unless statuses.empty?
-                @@since_id = statuses[0].id
+                print "\e[1K\e[0G" unless win?
+                @since_id = statuses[0].id
+                output(statuses, :update_friends_timeline)
+                Readline.refresh_line
               end
-              call_hooks(statuses, :update_friends_timeline)
-              Readline.refresh_line
-              statuses
             rescue OpenURI::HTTPError => e
               if e.message == '401 Unauthorized'
                 puts 'Could not login'
@@ -299,9 +271,11 @@ module Termtter
           }
         )
 
-        add_task(:name => :update_timeline, :interval => config.update_interval) do
+        add_task(:name => :update_timeline, :interval => config.update_interval, :after => config.update_interval) do
           call_commands('_update_timeline')
         end
+
+        call_commands('_update_timeline')
       end
 
       def trap_setting()
@@ -321,9 +295,9 @@ module Termtter
       def start_input_thread
         setup_readline()
         trap_setting()
-        @@input_thread = Thread.new do
+        @input_thread = Thread.new do
           while buf = Readline.readline(ERB.new(config.prompt).result(API.twitter.__send__(:binding)), true)
-            Readline::HISTORY.pop if /^(u|update)\s+(.+)$/ =~ buf
+            Readline::HISTORY.pop if buf.empty?
             begin
               call_commands(buf)
             rescue CommandNotFound => e
@@ -334,29 +308,35 @@ module Termtter
             end
           end
         end
-        @@input_thread.join
+        @input_thread.join
       end
 
-      def run
-        puts 'initializing...'
+      def logger
+        @logger
+      end
 
+      def setup_logger
+        @logger = config.log.logger || Logger.new(STDOUT)
+        @logger.level = config.log.level || Logger::WARN
+      end
+
+      def run
         load_default_plugins()
         load_config()
         Termtter::API.setup()
-        pre_config_load()
+        setup_logger()
+        post_config_load()
 
-        call_hooks([], :initialize)
-        call_new_hooks(:initialize)
+        call_hooks(:initialize)
 
         setup_update_timeline_task()
-        call_commands('_update_timeline')
 
-        @@task_manager.run()
+        @task_manager.run()
         start_input_thread()
       end
 
       def handle_error(e)
-        call_new_hooks("on_error", e)
+        call_hooks("on_error", e)
       rescue => e
         puts "Error: #{e}"
         puts e.backtrace.join("\n")