draftcode-termtter 1.0.8

data/lib/plugins/yhara_filter.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+
+Termtter::Client.add_filter do |statuses, _|
+  statuses.select {|s| /^(?:\s|(y\s)|(?:hara\s))+\s*(?:y|(?:hara))(?:\?|!|\.)?\s*$/ =~ s.text }
+end
+
+# yhara_filter.rb
+#   select Yharian post only

data/lib/plugins/yonda.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+module Termtter::Client
+  register_command(:name => :yonda,
+                   :aliases => [:y],
+                   :exec_proc => lambda { |arg|
+                     public_storage[:unread_count] = 0
+                     print "\033[2J\033[H" # FIXME
+                     true
+                   },
+                   :help => ['yonda,y', 'Mark as read']
+  )
+
+  register_hook(:name => :yonda,
+                :points => [:post_exec__update_timeline],
+                :exec_proc => lambda { |cmd, arg, result|
+                  public_storage[:unread_count] ||= 0
+                  public_storage[:unread_count]  += result.size
+                }
+  )
+end

data/lib/termtter.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+$KCODE="u" unless Object.const_defined? :Encoding
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'json'
+require 'net/https'
+require 'open-uri'
+require 'cgi'
+require 'readline'
+require 'enumerator'
+require 'optparse'
+
+require 'termtter/config'
+require 'termtter/version'
+require 'termtter/optparse'
+require 'termtter/connection'
+require 'termtter/command'
+require 'termtter/hook'
+require 'termtter/task'
+require 'termtter/task_manager'
+require 'termtter/client'
+require 'termtter/api'
+require 'termtter/system_extensions'
+
+module Termtter
+  APP_NAME = 'termtter'
+
+  config.system.set_default :conf_dir, File.expand_path('~/.termtter')
+  CONF_DIR = config.system.conf_dir
+
+  config.system.set_default :conf_file, CONF_DIR + '/config'
+  CONF_FILE = config.system.conf_file
+  $:.unshift(Termtter::CONF_DIR)
+end

data/lib/termtter/api.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+gem 'rubytter', '>= 0.6.5'
+require 'rubytter'
+
+config.set_default(:host, 'twitter.com')
+config.proxy.set_default(:port, '8080')
+config.proxy.set_default(:host, nil)
+config.proxy.set_default(:port, nil)
+config.proxy.set_default(:user_name, nil)
+config.proxy.set_default(:password, nil)
+config.set_default(:enable_ssl, false)
+
+module Termtter
+  module API
+    class << self
+      attr_reader :connection, :twitter
+      def setup
+        @connection = Connection.new
+        @twitter = create_twitter(config.user_name, config.password)
+      end
+
+      def restore_user
+        @twitter = create_twitter(config.user_name, config.password)
+      end
+
+      def switch_user(username = nil)
+        highline = create_highline
+        username = highline.ask('your twitter username: ') if username.nil? || username.empty?
+        password = highline.ask('your twitter password: ') { |q| q.echo = false }
+        @twitter = create_twitter(username, password)
+      end
+
+      def create_twitter(user_name, password)
+        Rubytter.new(
+          user_name,
+          password,
+          {
+            :app_name => config.app_name.empty? ? Termtter::APP_NAME : config.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' => Termtter::VERSION
+            },
+            :enable_ssl => config.enable_ssl,
+            :proxy_host => config.proxy.host,
+            :proxy_port => config.proxy.port,
+            :proxy_user_name => config.proxy.user_name,
+            :proxy_password => config.proxy.password
+          }
+        )
+      end
+    end
+  end
+end
+# Termtter::API.connection, Termtter::API.twitter can be accessed.

data/lib/termtter/client.rb

@@ -0,0 +1,324 @@
+# -*- coding: utf-8 -*-
+require 'fileutils'
+require 'logger'
+require 'termcolor'
+
+module Termtter
+
+  class CommandNotFound < StandardError; end
+  class CommandCanceled < StandardError; end
+
+  module Client
+
+    class << self
+
+      def init
+        @hooks = {}
+        @commands = {}
+        @filters = []
+        @since_id = nil
+        @task_manager = Termtter::TaskManager.new
+        config.set_default(:logger, nil)
+        config.set_default(:update_interval, 300)
+        config.set_default(:prompt, '> ')
+        config.set_default(:devel, false)
+        Thread.abort_on_exception = true
+      end
+
+      def public_storage
+        @public_storage ||= {}
+      end
+
+      def add_filter(&b)
+        @filters << b
+      end
+
+      def clear_filter
+        @filters.clear
+      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
+        @hooks[hook.name] = hook
+      end
+
+      def get_hook(name)
+        @hooks[name]
+      end
+
+      def get_hooks(point)
+        @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
+        @commands[command.name] = command
+      end
+
+      def get_command(name)
+        @commands[name]
+      end
+
+      def get_command_completion_proc()
+        lambda {|input|
+          begin
+            @commands.map {|name, command| command.complement(input) }.flatten.compact
+          rescue => e
+            handle_error(e)
+          end
+        }
+      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
+
+      # 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)
+        get_hooks(:output).each do |hook|
+          filtered_for_hook = apply_filters_for_hook(filtered, hook.name)
+          hook.call(filtered_for_hook, event)
+        end
+      end
+
+      def apply_filters(statuses, event)
+          filtered = statuses.map(&:dup)
+          @filters.each do |f|
+            filtered = f.call(filtered, event)
+          end
+          filtered
+      end
+
+      def apply_filters_for_hook(statuses, hook_name)
+        # TODO
+        filtered = statuses.map(&:dup)
+        filtered
+      end
+
+      # return last hook return value
+      def call_hooks(point, *args)
+        result = nil
+        get_hooks(point).each {|hook|
+          break if result == false # interrupt if hook return false
+          result = hook.call(*args)
+        }
+        result
+      end
+
+      def call_commands(text, tw = nil)
+        return if text.empty?
+
+        command_found = false
+        @commands.each do |key, command|
+          next unless command.match?(text)
+          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
+            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
+            rescue CommandCanceled
+            end
+          end
+        end
+
+        raise CommandNotFound, text 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)
+        @task_manager.kill
+      end
+
+      def load_default_plugins
+        plugin 'standard_plugins'
+        plugin 'stdout'
+      end
+
+      def load_config
+        legacy_config_support() if File.exist? Termtter::CONF_DIR
+        unless File.exist?(Termtter::CONF_FILE)
+          require 'termtter/config_setup'
+          ConfigSetup.run
+        end
+        load Termtter::CONF_FILE
+      end
+
+      def legacy_config_support
+        case File.ftype(File.expand_path('~/.termtter'))
+        when 'directory'
+          # nop
+        when 'file'
+          move_legacy_config_file
+        end
+      end
+
+      def move_legacy_config_file
+        FileUtils.mv(
+          Termtter::CONF_DIR,
+          File.expand_path('~/.termtter___'))
+        Dir.mkdir(Termtter::CONF_DIR)
+        FileUtils.mv(
+          File.expand_path('~/.termtter___'),
+          Termtter::CONF_FILE)
+      end
+
+      def post_config_load()
+        if config.devel
+          plugin 'devel'
+        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}] : []
+              statuses = Termtter::API.twitter.friends_timeline(*args)
+              unless statuses.empty?
+                @since_id = statuses[0].id
+                output(statuses, :update_friends_timeline)
+              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)
+            end
+          }
+        )
+
+        add_task(:name => :update_timeline, :interval => config.update_interval, :after => config.update_interval) do
+          call_commands('_update_timeline')
+        end
+      end
+
+      def logger
+        @logger
+      end
+
+      def setup_logger
+        @logger = config.logger || default_logger
+      end
+
+      def default_logger
+        logger = Logger.new(STDOUT)
+        logger.formatter = lambda { |severity, time, progname, message|
+          color =
+            case severity
+            when /^DEBUG/
+              'blue'
+            when /^INFO/
+              'cyan'
+            when /^WARN/
+              'magenta'
+            when /^ERROR/
+              'red'
+            when /^FATAL/
+              'on_red'
+            else
+              'white'
+            end
+          TermColor.parse("<#{color}>" + TermColor.escape("[#{severity}] #{message}\n") + "</#{color}>")
+        }
+        logger
+      end
+
+      def run
+        load_default_plugins()
+        load_config()
+        Termtter::API.setup()
+        setup_logger()
+        post_config_load()
+
+        call_hooks(:initialize)
+        setup_update_timeline_task()
+        call_commands('_update_timeline')
+        @task_manager.run()
+        call_hooks(:before_task_thread_run)
+      end
+
+      def handle_error(e)
+        if logger
+          logger.error("#{e.class.to_s}: #{e.message}")
+          logger.error(e.backtrace.join("\n")) if config.devel
+        else
+          raise e
+        end
+        get_hooks(:on_error).each {|hook| hook.call(e) }
+      rescue Exception => e
+        puts "Error: #{e}"
+        puts e.backtrace.join("\n")
+      end
+    end
+  end
+end
+
+Termtter::Client.init