draftcode-termtter 1.0.8

data/lib/termtter/command.rb

@@ -0,0 +1,80 @@
+# -*- 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)
+      args[:exec_proc] ||= args[:exec]
+      args[:completion_proc] ||= args[:completion]
+      args[:aliases] ||= [args[:alias]].compact
+
+      cfg = {
+        :aliases        => [],
+        :exec_proc      => lambda {|arg| },
+        :comletion_proc => lambda {|command, arg| [] }
+      }.merge(args)
+
+      set cfg
+    end
+
+    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]
+    end
+
+    def complement(input)
+      if match?(input) && input =~ /^[^\s]+\s/
+        if completion_proc
+          command_str, command_arg = Command.split_command_line(input)
+          [completion_proc.call(command_str, command_arg || '')].flatten.compact
+        else
+          []
+        end
+      else
+        [name.to_s, aliases.to_s].grep(/^#{Regexp.quote(input)}/)
+      end
+    end
+
+    def call(cmd = nil, arg = nil, original_text = nil)
+      arg = case arg
+        when nil
+          ''
+        when String
+          arg
+        else
+          raise ArgumentError, 'arg should be String or nil'
+        end
+      exec_proc.call(arg)
+    end
+
+    def match?(input)
+      (pattern =~ input) != nil
+    end
+
+    def pattern
+      commands_regex = commands.map {|name| Regexp.quote(name.to_s) }.join('|')
+      /^((#{commands_regex})|(#{commands_regex})\s+(.*?))\s*$/
+    end
+
+    def commands
+      [name] + aliases
+    end
+
+    def self.split_command_line(line)
+      line.strip.split(/\s+/, 2)
+    end
+  end
+end

data/lib/termtter/config.rb

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*-
+#
+module Termtter
+  class Config
+    def initialize
+      @store = Hash.new(:undefined)
+    end
+
+    def inspect
+      @store.inspect
+    end
+
+    # set_default :: (Symbol | String) -> a -> IO ()
+    def set_default(name, value)
+      match_p, init, last = *name.to_s.match(/^(.+)\.([^\.]+)$/)
+      if match_p
+        tmp = eval(init)
+        if tmp.__refer__(last.to_sym).empty?
+          tmp.__assign__(last.to_sym, value)
+        end
+      else
+        __assign__(name.to_sym, value) if __refer__(name.to_sym).empty?
+      end
+    end
+
+    # empty? :: Boolean
+    def empty?
+      @store.empty?
+    end
+
+    def method_missing(name, *args)
+      case name.to_s
+      when /(.*)=$/
+        __assign__($1.to_sym, args.first)
+      else
+        __refer__(name.to_sym)
+      end
+    end
+
+    # __assign__ :: Symbol -> a -> IO ()
+    def __assign__(name, value)
+      @store[name] = value
+    end
+
+    # __refer__ :: Symbol -> IO a
+    def __refer__(name)
+      @store[name] == :undefined ? @store[name] = Termtter::Config.new : @store[name]
+    end
+
+    def __values__
+      @store.dup
+    end
+
+    __instance = self.new
+    (class << self; self end).
+      __send__(:define_method, :instance) { __instance }
+  end
+end
+
+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

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  module ConfigSetup
+    module_function
+    def run
+      ui = create_highline
+      username = ui.ask('your twitter username: ')
+      password = ui.ask('your twitter password: ') { |q| q.echo = false }
+
+      Dir.mkdir(Termtter::CONF_DIR) unless File.exists?(Termtter::CONF_DIR)
+      File.open(Termtter::CONF_FILE, 'w') {|io|
+        io.puts '# -*- coding: utf-8 -*-'
+
+        io.puts
+        io.puts "config.user_name = '#{username}'"
+        io.puts "config.password = '#{password}'"
+        io.puts "#config.update_interval = 120"
+        io.puts "#config.proxy.host = 'proxy host'"
+        io.puts "#config.proxy.port = '8080'"
+        io.puts "#config.proxy.user_name = 'proxy user'"
+        io.puts "#config.proxy.password = 'proxy password'"
+        io.puts
+        plugins = Dir.glob(File.expand_path(File.dirname(__FILE__) + "/../plugins/*.rb")).map  {|f|
+          f.match(%r|lib/plugins/(.*?).rb$|)[1]
+        }
+        plugins -= %w[stdout standard_plugins]
+        plugins.each do |p|
+          io.puts "#plugin '#{p}'"
+        end
+        io.puts
+        io.puts "# vim: set filetype=ruby"
+      }
+      puts "generated: ~/.termtter/config"
+      puts "enjoy!"
+    end
+  end
+end

data/lib/termtter/connection.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Connection
+    attr_reader :protocol, :port, :proxy_uri
+
+    def initialize
+      unless config.proxy.empty?
+        @proxy_host = config.proxy.host
+        @proxy_port = config.proxy.port
+        @proxy_user = config.proxy.user_name
+        @proxy_password = config.proxy.password
+        @proxy_uri = nil
+        @enable_ssl = config.enable_ssl
+      end
+      @protocol = "http"
+      @port = 80
+
+      if @proxy_host
+        @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,31 @@
+# -*- 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[:point]].compact
+      @exec_proc = args[:exec_proc] || args[:exec] || lambda {}
+    end
+
+    def match?(point)
+      !points.select{|pt|
+        case pt
+        when String, Symbol
+          pt.to_s == point.to_s
+        when Regexp
+          (pt =~ point.to_s) ? true : false
+        else
+          false
+        end
+      }.empty?
+    end
+
+    def call(*args)
+      self.exec_proc.call(*args)
+    end
+  end
+end

data/lib/termtter/optparse.rb

@@ -0,0 +1,14 @@
+OptionParser.new { |opt|
+  opt.on('-f', '--file config_file', 'Set path to configfile') do |val|
+    config.system.__assign__(:conf_file, val)
+  end
+  opt.on('-t', '--termtter-directory directory', 'Set termtter directory') do |val|
+    config.system.__assign__(:conf_dir, val)
+  end
+  opt.on('-d', '--devel', 'Start in developer mode') do |flg|
+    config.system.__assign__(:devel, true) if flg
+  end
+
+  Version = Termtter::VERSION
+  opt.parse!(ARGV)
+}

data/lib/termtter/system_extensions.rb

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+
+def plugin(name, init = {})
+  unless init.empty?
+    init.each do |key, value|
+      config.plugins.__refer__(name.to_sym).__assign__(key.to_sym, value)
+    end
+  end
+  load "plugins/#{name}.rb"
+rescue Exception => e
+  Termtter::Client.handle_error(e)
+end
+
+def filter(name, init = {})
+  warn "filter method will be removed. Use plugin instead."
+  plugin(name, init)
+end
+
+def win?
+  RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+end
+
+if win?
+  require 'iconv'
+  require 'Win32API'
+  $wGetACP = Win32API.new('kernel32','GetACP','','I')
+
+  $wSetConsoleTextAttribute = Win32API.new('kernel32','SetConsoleTextAttribute','II','I')
+  $wGetConsoleScreenBufferInfo = Win32API.new("kernel32", "GetConsoleScreenBufferInfo", ['l', 'p'], 'i')
+  $wGetStdHandle = Win32API.new('kernel32','GetStdHandle','I','I')
+  $wGetACP = Win32API.new('kernel32','GetACP','','I')
+
+  $hStdOut = $wGetStdHandle.call(0xFFFFFFF5)
+  lpBuffer = ' ' * 22
+  $wGetConsoleScreenBufferInfo.call($hStdOut, lpBuffer)
+  $oldColor = lpBuffer.unpack('SSSSSssssSS')[4]
+
+  $colorMap = {
+     0 => 0x07|0x00|0x00|0x00, # black/white
+    37 => 0x08|0x00|0x00|0x00, # white/intensity
+    31 => 0x04|0x08|0x00|0x00, # red/red
+    32 => 0x02|0x08|0x00|0x00, # green/green
+    33 => 0x06|0x08|0x00|0x00, # yellow/yellow
+    34 => 0x01|0x08|0x00|0x00, # blue/blue
+    35 => 0x05|0x08|0x00|0x00, # magenta/purple
+    36 => 0x03|0x08|0x00|0x00, # cyan/aqua
+    39 => 0x07,                # default
+    40 => 0x00|0x00|0xf0|0x00, # background:white
+    41 => 0x07|0x00|0x40|0x00, # background:red
+    42 => 0x07|0x00|0x20|0x00, # background:green
+    43 => 0x07|0x00|0x60|0x00, # background:yellow
+    44 => 0x07|0x00|0x10|0x00, # background:blue
+    45 => 0x07|0x00|0x50|0x80, # background:magenta
+    46 => 0x07|0x00|0x30|0x80, # background:cyan
+    47 => 0x07|0x00|0x70|0x80, # background:gray
+    49 => 0x70,                # default
+    90 => 0x07|0x00|0x00|0x00, # erase/white
+  }
+  $iconv_u8_to_sj = Iconv.new("CP#{$wGetACP.call()}", 'UTF-8')
+  def print(str)
+    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]/
+        # do nothing
+      else
+        loop do
+          begin
+            STDOUT.print $iconv_u8_to_sj.iconv(token)
+            break
+          rescue Iconv::Failure
+            STDOUT.print "#{$!.success}?"
+            token = $!.failed[1..-1]
+          end
+        end
+      end
+    end
+    $wSetConsoleTextAttribute.call $hStdOut, $oldColor
+    $iconv_u8_to_sj.iconv(nil)
+  end
+  def puts(str)
+    print str
+    STDOUT.puts
+  end
+end
+
+unless Array.instance_methods.include?('take')
+  class Array
+    def take(n) self[0...n] end
+  end
+end
+
+unless Symbol.instance_methods.include?('to_proc')
+  class Symbol
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end
+
+require 'highline'
+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
+  HighLine.new(stdin_for_highline)
+end

data/lib/termtter/task.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class Task
+    attr_accessor :name, :exec_at, :exec_proc, :interval, :work
+    def initialize(args = {}, &block)
+      @name = args[:name]
+      @exec_at = Time.now + (args[:after] || 0)
+      @interval = args[:interval]
+      @exec_proc = block || lambda {}
+      @work = true
+    end
+    def execute
+      exec_proc.call(self) if work
+    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 Exception => 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.work && 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