termtter 0.8.3

data/lib/termtter/client.rb

@@ -0,0 +1,399 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class CommandNotFound < StandardError; end
+
+  module Client
+
+    class << self
+
+      def init
+        @@hooks = []
+        @@new_hooks = {}
+        @@commands = {}
+        @@new_commands = {}
+        @@completions = []
+        @@filters = []
+        @@helps = []
+        @@since_id = nil
+        @@main_thread = nil
+        @@input_thread = nil
+        @@task_manager = Termtter::TaskManager.new
+      end
+
+      def public_storage
+        @@public_storage ||= {}
+      end
+
+      %w[hook completion filter].each do |n|
+        eval <<-EOF
+          def add_#{n}(&b)
+            @@#{n}s << b
+          end
+        EOF
+      end
+
+      # Deprecated
+      # FIXME: delete when become unnecessary
+      def add_command(regex, &block)
+        warn "Termtter:Client.add_command method will be removed. Use Termtter::Client.register_command() instead. (#{caller.first})"
+        @@commands[regex] = block
+      end
+
+      def register_hook(arg)
+        hook = case arg
+          when Hook
+            arg
+          when Hash
+            Hook.new(arg)
+          else
+            raise ArgumentError, 'must be given Termtter::Hook or Hash'
+          end
+        @@new_hooks[hook.name] = hook
+      end
+
+      def get_hook(name)
+        @@new_hooks[name]
+      end
+
+      def get_hooks(point)
+        @@new_hooks.values.select do |hook|
+          hook.match?(point)
+        end
+      end
+
+      def register_command(arg)
+        command = case arg
+          when Command
+            arg
+          when Hash
+            Command.new(arg)
+          else
+            raise ArgumentError, 'must be given Termtter::Command or Hash'
+          end
+        @@new_commands[command.name] = command
+      end
+
+      def get_command(name)
+        @@new_commands[name]
+      end
+
+      def register_macro(name, macro, options = {})
+        command = {
+          :name => name.to_sym,
+          :exec_proc => lambda {|arg| call_commands(macro % arg)}
+        }.merge(options)
+        register_command(command)
+      end
+
+      def add_help(name, desc)
+        @@helps << [name, desc]
+      end
+
+      %w[hooks commands completions helps filters].each do |n|
+        eval <<-EOF
+          def clear_#{n}
+            @@#{n}.clear
+          end
+        EOF
+      end
+
+      # memo: each filter must return Array of Status
+      def apply_filters(statuses)
+        filtered = statuses.map{|s| s.dup }
+        @@filters.each do |f|
+          filtered = f.call(filtered)
+        end
+        filtered
+      rescue => e
+        handle_error(e)
+        statuses
+      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
+      end
+
+      # return last hook return value
+      def call_new_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)
+        }
+        return result
+      rescue => e
+        if point.to_sym == :on_error
+          raise
+        else
+          handle_error(e)
+        end
+      end
+
+      # TODO: delete argument "tw" when unnecessary
+      def call_hooks(statuses, event, tw = nil)
+        do_hooks(statuses, :pre_filter)
+        do_hooks(apply_filters(statuses), event)
+      end
+
+      def call_commands(text, tw = nil)
+        return if text.empty?
+
+        command_found = false
+        @@commands.each do |key, command|
+          if key =~ text
+            command_found = true
+            @@task_manager.invoke_and_wait do
+              command.call($~, Termtter::API.twitter)
+            end
+          end
+        end
+
+        @@new_commands.each do |key, command|
+          command_info = command.match?(text)
+          if command_info
+            command_found = true
+            input_command, arg = *command_info
+
+            modified_arg = call_new_hooks("modify_arg_for_#{command.name.to_s}", input_command, arg) || arg || ''
+
+            @@task_manager.invoke_and_wait do
+              pre_exec_hook_result = call_new_hooks("pre_exec_#{command.name.to_s}", input_command, 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}", input_command, modified_arg, result)
+              end
+            end
+          end
+        end
+
+        raise CommandNotFound unless command_found
+      end
+
+      def pause
+        @@task_manager.pause
+      end
+
+      def resume
+        @@task_manager.resume
+      end
+
+      def 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
+        @@main_thread.kill if @@main_thread
+        @@input_thread.kill if @@input_thread
+      end
+
+      def load_default_plugins
+        plugin 'standard_plugins'
+        plugin 'stdout'
+        configatron.set_default(:devel, false)
+        if configatron.devel
+          plugin 'devel'
+        end
+      end
+
+      def load_config
+        conf_file = File.expand_path('~/.termtter')
+        if File.exist? conf_file
+          wrap_require do
+            load conf_file
+          end
+        else
+          ui = create_highline
+          username = ui.ask('your twitter username: ')
+          password = ui.ask('your twitter password: ') { |q| q.echo = false }
+
+          File.open(File.expand_path('~/.termtter'), 'w') {|io|
+            plugins = Dir.glob(File.dirname(__FILE__) + "/../lib/plugin/*.rb").map  {|f|
+              f.match(%r|lib/plugin/(.*?).rb$|)[1]
+            }
+            plugins -= %w[stdout standard_plugins]
+            plugins.each do |p|
+              io.puts "#plugin '#{p}'"
+            end
+
+            io.puts
+            io.puts "configatron.user_name = '#{username}'"
+            io.puts "configatron.password = '#{password}'"
+            io.puts "#configatron.update_interval = 120"
+            io.puts "#configatron.proxy.host = 'proxy host'"
+            io.puts "#configatron.proxy.port = '8080'"
+            io.puts "#configatron.proxy.user_name = 'proxy user'"
+            io.puts "#configatron.proxy.password = 'proxy password'"
+            io.puts
+            io.puts "# vim: set filetype=ruby"
+          }
+          puts "generated: ~/.termtter"
+          puts "enjoy!"
+          wrap_require do
+            load conf_file
+          end
+        end
+      end
+
+      def setup_readline
+        Readline.basic_word_break_characters= "\t\n\"\\'`><=;|&{("
+        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
+          rescue => e
+            handle_error(e)
+          end
+        }
+        vi_or_emacs = configatron.editing_mode
+        unless vi_or_emacs.empty?
+          Readline.__send__("#{vi_or_emacs}_editing_mode")
+        end
+      end
+
+      def setup_update_timeline_task()
+        register_command(
+          :name => :_update_timeline,
+          :exec_proc => lambda {|arg|
+            begin
+              statuses = Termtter::API.twitter.get_friends_timeline(@@since_id)
+              unless statuses.empty?
+                @@since_id = statuses[0].id
+              end
+              print "\e[1K\e[0G" if !statuses.empty? && !win?
+              call_hooks(statuses, :update_friends_timeline)
+              @@input_thread.kill if @@input_thread && !statuses.empty?
+            rescue OpenURI::HTTPError => e
+              if e.message == '401 Unauthorized'
+                puts 'Could not login'
+                puts 'plese check your account settings'
+                exit!
+              end
+            end
+          }
+        )
+
+        add_task(:name => :update_timeline, :interval => configatron.update_interval) do
+          call_commands('_update_timeline')
+        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()
+        @@main_thread = Thread.new do
+          loop do
+            @@input_thread = create_input_thread()
+            @@input_thread.join
+          end
+        end
+        @@main_thread.join
+      end
+
+      def run
+        puts 'initializing...'
+
+        load_default_plugins()
+        load_config()
+        Termtter::API.setup()
+
+        call_hooks([], :initialize)
+        call_new_hooks(:initialize)
+
+        setup_update_timeline_task()
+        call_commands('_update_timeline')
+
+        @@task_manager.run()
+        start_input_thread()
+      end
+
+      def create_input_thread()
+        Thread.new do
+          while buf = Readline.readline(ERB.new(configatron.prompt).result(API.twitter.__send__(:binding)), true)
+            Readline::HISTORY.pop if /^(u|update)\s+(.+)$/ =~ buf
+            begin
+              call_commands(buf)
+            rescue CommandNotFound => e
+              puts "Unknown command \"#{buf}\""
+              puts 'Enter "help" for instructions'
+            end
+          end
+          exit # exit when press Control-D
+        end
+      end
+
+      def create_highline
+        HighLine.track_eof = false
+        if $stdin.respond_to?(:getbyte) # for ruby1.9
+          require 'delegate'
+          stdin_for_highline = SimpleDelegator.new($stdin)
+          def stdin_for_highline.getc
+            getbyte
+          end
+        else
+          stdin_for_highline = $stdin
+        end
+        return HighLine.new(stdin_for_highline)
+      end
+
+      def handle_error(e)
+        call_new_hooks("on_error", e)
+      rescue => e
+        puts "Error: #{e}"
+        puts e.backtrace.join("\n")
+      end
+
+      def wrap_require
+        # FIXME: delete this method after the major version up
+        alias original_require require
+        def require(s)
+          if %r|^termtter/(.*)| =~ s
+            puts "[WARNING] use plugin '#{$1}' instead of require"
+            puts "  Such a legacy .termtter file will not be supported until version 1.0.0"
+            s = "plugin/#{$1}"
+          end
+          original_require s
+        end
+        yield
+        alias require original_require
+      end
+      private :wrap_require
+    end
+  end
+end
+
+Termtter::Client.init

data/lib/termtter/command.rb

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Command
+    attr_accessor :name, :aliases, :exec_proc, :completion_proc, :help
+
+    # args
+    #   name:            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)
+      @name = args[:name].to_sym
+      @aliases = args[:aliases] ? args[:aliases].map {|i| i.to_sym } : []
+      @exec_proc = args[:exec_proc] || lambda {|arg|}
+      @completion_proc = args[:completion_proc] || lambda {|command, arg| [] }
+      @help = args[:help]
+    end
+
+    def complement(input)
+      command_info = match?(input)
+      if command_info
+        [completion_proc.call(command_info[0], command_info[1] || '')].flatten.compact
+      else
+        [name.to_s].grep(/^#{Regexp.quote(input)}/)
+      end
+    end
+
+    # MEMO: Termtter:Client からはこのメソッドを呼び出すことになると思う。
+    def exec_if_match(input)
+      command_info = match?(input)
+      if command_info
+        result = execute(command_info[1])
+        unless result.nil?
+          return result
+        else
+          return true
+        end
+      else
+        return nil
+      end
+    end
+
+    # return array like [command, arg]
+    def match?(input)
+      if pattern =~ input
+        [$2 || $3, $4]  # $2 or $3 => command, $4 => argument
+      else
+        nil
+      end
+    end
+
+    def execute(arg)
+      arg = case arg
+        when nil
+          ''
+        when String
+          arg
+        else
+          raise ArgumentError, 'arg should be String or nil'
+        end
+      exec_proc.call(arg)
+    end
+
+    def pattern
+      commands_regex = commands.map {|i| Regexp.quote(i.to_s) }.join('|')
+      /^((#{commands_regex})|(#{commands_regex})\s+(.*?))\s*$/
+    end
+
+    def commands
+      aliases.unshift(name)
+    end
+  end
+end
+

data/lib/termtter/connection.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Connection
+    attr_reader :protocol, :port, :proxy_uri
+
+    def initialize
+      @proxy_host = configatron.proxy.host
+      @proxy_port = configatron.proxy.port
+      @proxy_user = configatron.proxy.user_name
+      @proxy_password = configatron.proxy.password
+      @proxy_uri = nil
+      @enable_ssl = configatron.enable_ssl
+      @protocol = "http"
+      @port = 80
+
+      unless @proxy_host.empty?
+        @http_class = Net::HTTP::Proxy(@proxy_host, @proxy_port,
+                                       @proxy_user, @proxy_password)
+        @proxy_uri =  "http://" + @proxy_host + ":" + @proxy_port + "/"
+      else
+        @http_class = Net::HTTP
+      end
+
+      if @enable_ssl
+        @protocol = "https"
+        @port = 443
+      end
+    end
+
+    def start(host, port, &block)
+      http = @http_class.new(host, port)
+      http.use_ssl = @enable_ssl
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE if http.use_ssl?
+      http.start(&block)
+    end
+  end
+end
+

data/lib/termtter/hook.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Hook
+    attr_accessor :name, :points, :exec_proc
+
+    def initialize(args)
+      raise ArgumentError, ":name is not given." unless args.has_key?(:name)
+      @name = args[:name].to_sym
+      @points = args[:points] ? args[:points].map {|i| i.to_sym } : []
+      @exec_proc = args[:exec_proc] || lambda {}
+    end
+
+    def match?(point)
+      points.include?(point.to_sym)
+    end
+  end
+end

data/lib/termtter/status.rb

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Status
+    %w(
+      id text created_at truncated
+      in_reply_to_status_id in_reply_to_user_id in_reply_to_screen_name
+      user_id user_name user_screen_name user_url user_profile_image_url
+    ).each do |attr|
+      attr_accessor attr.to_sym
+    end
+
+    def eql?(other); self.id == other.id end
+    def hash; self.id end
+
+    def english?
+      self.class.english?(self.text)
+    end
+
+    # english? :: String -> Boolean
+    def self.english?(message)
+      /[一-龠]+|[ぁ-ん]+|[ァ-ヴー]+|[ａ-ｚＡ-Ｚ０-９]+/ !~ message
+    end
+  end
+end
+

data/lib/termtter/task.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Task
+    attr_accessor :name, :exec_at, :exec_proc, :interval
+    def initialize(args = {}, &block)
+      @name = args[:name]
+      @exec_at = Time.now + (args[:after] || 0)
+      @interval = args[:interval]
+      @exec_proc = block || lambda {}
+    end
+    def execute
+      exec_proc.call
+    end
+  end
+end

data/lib/termtter/task_manager.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class TaskManager
+
+    INTERVAL = 1
+
+    def initialize()
+      @tasks = {}
+      @work = true
+      @mutex = Mutex.new
+      @pause = false
+    end
+
+    def pause
+      @pause = true
+    end
+
+    def resume
+      @pause = false
+    end
+
+    def kill
+      @work = false
+    end
+
+    def run
+      Thread.new do
+        while @work
+          step unless @pause
+          sleep INTERVAL
+        end
+      end
+    end
+
+    def step
+      pull_due_tasks().each do |task|
+        invoke_and_wait do
+          task.execute
+        end
+      end
+    end
+
+    def invoke_later
+      Thread.new do
+        invoke_and_wait do
+          yield
+        end
+      end
+    end
+
+    def invoke_and_wait(&block)
+      synchronize do
+        begin
+          yield
+        rescue => e
+          Termtter::Client.handle_error(e)
+        end
+      end
+    end
+
+    def add_task(args = {}, &block)
+      synchronize do
+        task = Task.new(args, &block)
+        @tasks[task.name || task.object_id] = task
+      end
+    end
+
+    def get_task(key)
+      synchronize do
+        @tasks[key]
+      end
+    end
+
+    def delete_task(key)
+      synchronize do
+        @tasks.delete(key)
+      end
+    end
+
+    private
+
+    def synchronize
+      unless Thread.current == @thread_in_sync
+        @mutex.synchronize do
+          @thread_in_sync = Thread.current
+          yield
+        end
+      else
+        yield
+      end
+    end
+
+    def pull_due_tasks()
+      synchronize do
+        time_now = Time.now
+        due_tasks = []
+        @tasks.delete_if do |key, task|
+          if task.exec_at <= time_now
+            due_tasks << task
+            if task.interval
+              task.exec_at = time_now + task.interval
+              false
+            else
+              true
+            end
+          else
+            false
+          end
+        end
+        return due_tasks
+      end
+    end
+
+  end
+end