termtter 0.8.3

data/lib/termtter/twitter.rb

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+
+require 'highline'
+require 'time'
+
+module Termtter
+  class Twitter
+
+    def initialize(user_name, password, connection, host = "twitter.com")
+      @user_name = user_name
+      @password = password
+      @connection = connection
+      @host = host
+    end
+
+    def update_status(status)
+      @connection.start(@host, @connection.port) do |http|
+        uri = '/statuses/update.xml'
+        http.request(post_request(uri), "status=#{CGI.escape(status)}&source=#{APP_NAME}")
+      end
+      status
+    end
+
+    def direct_message(user, status)
+      @connection.start(@host, @connection.port) do |http|
+        uri = '/direct_messages/new.xml'
+        http.request(post_request(uri), "user=#{CGI.escape(user)}&text=#{CGI.escape(status)}&source=#{APP_NAME}")
+      end
+      [user, status]
+    end
+
+    def get_user_profile(screen_name)
+      result = fetch_as_json(url_for("/users/show/#{screen_name}.json"))
+      return hash_to_user(result)
+    end
+
+    def get_friends_timeline(since_id = nil)
+      uri =  url_for("/statuses/friends_timeline.json")
+      uri << "?since_id=#{since_id}" if since_id
+      return get_timeline(uri)
+    end
+
+    def get_user_timeline(screen_name)
+      return get_timeline(url_for("/statuses/user_timeline/#{screen_name}.json"))
+    rescue OpenURI::HTTPError => e
+      puts "No such user: #{screen_name}"
+      nears = near_users(screen_name)
+      puts "near users: #{nears}" unless nears.empty?
+      return []
+    end
+
+    def search(query)
+      results = fetch_as_json(search_url_for("/search.json?q=#{CGI.escape(query)}"))['results']
+      return results.map do |s|
+        status = Status.new
+        status.id = s['id']
+        status.text = CGI.unescapeHTML(s['text']).gsub(/(\n|\r)/, '').gsub(/#{Regexp.escape(query)}/i, color(color('\0', 41), 37))
+        status.created_at = Time.parse(s["created_at"])
+        status.user_screen_name = s['from_user']
+        status
+      end
+    end
+
+    def show(id, rth = false)
+      get_status = lambda { get_timeline(url_for("/statuses/show/#{id}.json"))[0] }
+      statuses = []
+      statuses << status = Array(Client.public_storage[:log]).detect(get_status) {|s| s.id == id.to_i }
+      statuses << show(id, true) if rth && id = status.in_reply_to_status_id
+      statuses.flatten
+    end
+
+    def replies
+      return get_timeline(url_for("/statuses/replies.json"))
+    end
+
+    def followers
+      users = []
+      page = 0
+      begin
+        users += tmp = fetch_as_json(url_for("/statuses/followers.json?page=#{page+=1}"))
+      end until tmp.empty?
+      return users.map{|u| hash_to_user(u)}
+    end
+
+    def get_timeline(uri)
+      data = fetch_as_json(uri)
+      data = [data] unless data.instance_of? Array
+      return data.map do |s|
+        status = Status.new
+        status.created_at = Time.parse(s["created_at"])
+        %w(id text truncated in_reply_to_status_id in_reply_to_user_id in_reply_to_screen_name).each do |key|
+          status.__send__("#{key}=".to_sym, s[key])
+        end
+        %w(id name screen_name url profile_image_url).each do |key|
+          status.__send__("user_#{key}=".to_sym, s["user"][key])
+        end
+        status.text = CGI.unescapeHTML(status.text).gsub(/(\n|\r)/, '')
+        status
+      end
+    end
+
+    # note: APILimit.reset_time_in_seconds == APILimit.reset_time.to_i
+    APILIMIT = Struct.new("APILimit", :reset_time, :reset_time_in_seconds, :remaining_hits, :hourly_limit)
+    def get_rate_limit_status
+      data = fetch_as_json(url_for("/account/rate_limit_status.json"))
+      reset_time = Time.parse(data['reset_time'])
+      reset_time_in_seconds = data['reset_time_in_seconds'].to_i
+      
+      APILIMIT.new(reset_time, reset_time_in_seconds, data['remaining_hits'], data['hourly_limit'])
+    end
+
+    alias :api_limit :get_rate_limit_status
+
+    private
+
+    def hash_to_user(hash)
+      user = User.new
+      %w[ name favourites_count url id description protected utc_offset time_zone
+          screen_name notifications statuses_count followers_count friends_count
+          profile_image_url location following created_at
+      ].each do |attr|
+        user.__send__("#{attr}=".to_sym, hash[attr])
+      end
+      return user
+    end
+
+    def fetch_as_json(uri)
+      JSON.parse(open_uri(uri).read)
+    end
+
+    def open_uri(uri)
+      return open(uri, :http_basic_authentication => [user_name, password], :proxy => @connection.proxy_uri)
+    end
+
+    def url_for(path)
+      return "#{@connection.protocol}://#{@host}/#{path.sub(/^\//, '')}"
+    end
+
+    def search_url_for(path)
+      return "#{@connection.protocol}://search.#{@host}/#{path.sub(/^\//, '')}"
+    end
+
+    def user_name
+      unless @user_name.instance_of? String
+        Termtter::Client.create_highline.ask('your twitter username: ')
+      end
+      @user_name
+    end
+
+    def password
+      unless @password.instance_of? String
+        @password = Termtter::Client.create_highline.ask('your twitter password: ') { |q| q.echo = false }
+      end
+      @password
+    end
+
+    def near_users(screen_name)
+      Client::public_storage[:users].select {|user|
+        /#{user}/i =~ screen_name || /#{screen_name}/i =~ user
+      }.join(', ')
+    end
+
+    def post_request(uri)
+      req = Net::HTTP::Post.new(uri)
+      req.basic_auth(user_name, password)
+      req.add_field('User-Agent', 'Termtter http://github.com/jugyo/termtter')
+      req.add_field('X-Twitter-Client', 'Termtter')
+      req.add_field('X-Twitter-Client-URL', 'http://github.com/jugyo/termtter')
+      req.add_field('X-Twitter-Client-Version', '0.1')
+      req
+    end
+  end
+end

data/lib/termtter/user.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+module Termtter
+  class User
+    %w[ name favourites_count url id description protected utc_offset time_zone
+        screen_name notifications statuses_count followers_count friends_count
+        profile_image_url location following created_at
+    ].each do |attr|
+      attr_accessor attr.to_sym
+    end
+  end  
+end
+

data/lib/termtter/version.rb

@@ -0,0 +1,3 @@
+module Termtter
+  VERSION = '0.8.3'
+end

data/lib/termtter.rb

@@ -0,0 +1,157 @@
+# -*- coding: utf-8 -*-
+
+$:.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 'configatron'
+
+Thread.abort_on_exception = true
+
+configatron.set_default(:update_interval, 300)
+configatron.set_default(:prompt, '> ')
+configatron.set_default(:enable_ssl, false)
+configatron.proxy.set_default(:port, '8080')
+
+require 'termtter/twitter'
+require 'termtter/connection'
+require 'termtter/status'
+require 'termtter/user'
+require 'termtter/command'
+require 'termtter/hook'
+require 'termtter/task'
+require 'termtter/task_manager'
+require 'termtter/client'
+require 'termtter/api'
+require 'termtter/version'
+
+module Termtter
+  APP_NAME = 'termtter'
+  CONF_FILE = '~/.termtterrc' # still does not use
+  CONF_DIR = '~/.termtter' # still does not use
+end
+
+if RUBY_VERSION < '1.8.7'
+  class Array
+    def take(n) self[0...n] end
+  end
+end
+
+def win?
+  RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin/
+end
+
+if win?
+  require 'iconv'
+  require 'Win32API'
+  $wGetACP = Win32API.new('kernel32','GetACP','','I')
+
+  module Readline
+    $iconv_sj_to_u8 = Iconv.new('UTF-8', "CP#{$wGetACP.call()}")
+    alias :old_readline :readline
+    def readline(*a)
+      str = old_readline(*a)
+      out = ''
+      loop do
+        begin
+          out << $iconv_sj_to_u8.iconv(str)
+          break
+        rescue Iconv::Failure
+          out << "#{$!.success}?"
+          str = $!.failed[1..-1]
+        end
+      end
+      return out
+    end
+    module_function :old_readline, :readline
+  end
+
+  $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
+
+def plugin(s, init = {})
+  unless init.empty?
+    init.each do |key, value|
+      eval("configatron.plugins.#{s}").__send__("#{key}=", value)
+    end
+  end
+  require "plugin/#{s}"
+rescue => e
+  Termtter::Client.handle_error(e)
+end
+
+def filter(s)
+  load "filter/#{s}.rb"
+rescue => e
+  Termtter::Client.handle_error(e)
+else
+  Termtter::Client.public_storage[:filters] ||= []
+  Termtter::Client.public_storage[:filters] << s
+  true
+end
+
+$:.unshift(Termtter::CONF_DIR) # still does not use
+

data/spec/plugin/cool_spec.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+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'
+  end
+end

data/spec/plugin/fib_spec.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+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(:add_command).with(/^fib\s+(\d+)/)
+    Termtter::Client.should_receive(:add_command).with(/^fibyou\s(\w+)\s(\d+)/)
+    plugin 'fib'
+  end
+
+  it 'should define fib method' do
+    plugin 'fib'
+    (0..10).map {|i| fib i }.should == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+  end
+end

data/spec/plugin/filter_spec.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+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'
+    end
+
+    it 'should set public_storage[:filters]' do
+      plugin 'filter'
+      Client::public_storage.keys.should be_include(:filters)
+    end
+  end
+end
+

data/spec/plugin/plugin_spec.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../../lib/termtter'
+
+module Termtter
+  describe Client, 'when the plugin plugin is loaded' do
+    it 'should add command plugin and plugins' do
+      Termtter::Client.should_receive(:register_command).twice
+      plugin 'plugin'
+    end
+
+    it 'should set public_storage[:plugins]' do
+      plugin 'plugin'
+      Client::public_storage[:plugins].should_not be_empty
+    end
+
+    describe 'after the plugin plugin is loaded' do
+      before { plugin 'plugin' }
+
+      it 'should load the given plugin in the command plugin'
+      # hmm... How can I write it...?
+    end
+  end
+end
+

data/spec/plugin/shell_spec.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Termtter::Client, 'when the plugin shell is loaded' do
+  it 'should add command shell' do
+    Termtter::Client.should_receive(:register_command)
+    plugin 'shell'
+  end
+end

data/spec/plugin/spam_spec.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Termtter::Client, 'when the plugin spam is loaded' do
+  it 'should add command spam and post immediately' do
+    connection = mock('connection', :null_object => true)
+    t = Termtter::Twitter.new('a', 'b', connection)
+    Termtter::Twitter.should_receive(:new).and_return(t)
+    t.should_receive(:update_status).with('*super spam time*')
+
+    Termtter::Client.should_receive(:clear_commands)
+    Termtter::Client.should_receive(:add_command).with(/.+/)
+    plugin 'spam'
+  end
+end
+

data/spec/plugin/standard_plugins_spec.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+plugin 'standard_plugins'
+
+module Termtter
+  describe Client do
+    it 'shold return registerd commands' do
+      [
+        [:update,  [:u]],  [:direct,  [:d]],
+        [:profile, [:p]],  [:list,    [:l]],
+        [:search,  [:s]],  [:replies, [:r]],
+        [:show,    [  ]],  [:shows,   [  ]],
+        [:limit,   [:lm]], [:pause,   [  ]],
+        [:resume,  [  ]],  [:exit,    [:e]],
+      ].each do |name, aliases|
+        command = Client.get_command(name)
+        command.name.should == name
+        command.aliases.should == aliases
+      end
+    end
+
+    it 'should return candidates when call find_status_id_candidates' do
+      Client.public_storage[:status_ids] = %w[1 2 22 3 4 5]
+      Client.find_status_id_candidates("1", "%s").should == ["1"]
+      Client.find_status_id_candidates("2", "%s").should == ["2", "22"]
+      #TODO: more spec for like "jugyo:1113830"
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'termtter'

data/spec/termtter/client_spec.rb

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Termtter
+
+  describe Client do
+
+    it 'should take new_command' do
+      command = Command.new(:name => :test)
+      Client.register_command(command)
+      Client.get_command(:test).should == command
+    end
+
+    it 'should take command as Hash' do
+      Client.register_command(:name => :test)
+      Client.get_command(:test).name.should == :test
+    end
+
+    it 'should call new_command' do
+      command_arg = nil
+      command = Command.new(:name => :test, :exec_proc => lambda {|arg| command_arg = arg})
+      Client.register_command(command)
+      command_arg.should == nil
+
+      [
+        ['test',            ''],
+        ['test foo bar',    'foo bar'],
+        ['test  foo bar ',  'foo bar'],
+        ['test  foo  bar ', 'foo  bar'],
+      ].each do |input, args|
+        Client.call_commands(input, nil)
+        command_arg.should == args
+      end
+    end
+
+    it 'should take new_hook' do
+      hook = Hook.new(:name => :test)
+      Client.register_hook(hook)
+      Client.get_hook(:test).should == hook
+    end
+
+    it 'should take hook as Hash' do
+      Client.register_hook(:name => :test)
+      Client.get_hook(:test).name.should == :test
+    end
+
+    it 'should call new_hook' do
+      hook_called = false
+      Client.register_hook(:name => :test1, :points => [:point1], :exec_proc => lambda {hook_called = true})
+      hook_called.should == false
+      Client.call_new_hooks(:point1)
+      hook_called.should == true
+    end
+
+    it 'should call new_hook with args' do
+      arg1 = nil
+      arg2 = nil
+      Client.register_hook(:name => :test1, :points => [:point1], :exec_proc => lambda {|a1, a2| arg1 = a1; arg2 = a2})
+      arg1.should == nil
+      arg2.should == nil
+      Client.call_new_hooks(:point1, 'foo', 'bar')
+      arg1.should == 'foo'
+      arg2.should == 'bar'
+    end
+
+    it 'should return hooks when call get_hooks' do
+      hook1 = Client.register_hook(:name => :test1, :points => [:point1])
+      hook2 = Client.register_hook(:name => :test2, :points => [:point1])
+      hook3 = Client.register_hook(:name => :test3, :points => [:point2])
+
+      hooks = Client.get_hooks(:point1)
+      hooks.size.should == 2
+      hooks.include?(hook1).should == true
+      hooks.include?(hook2).should == true
+      hooks.include?(hook3).should == false
+    end
+
+    it 'should call decide_arg hooks' do
+      input_command = nil
+      input_arg = nil
+      decided_arg = nil
+      Client.register_hook( :name => :test1,
+                            :points => [:modify_arg_for_update],
+                            :exec_proc => lambda {|cmd, arg| input_command = cmd; input_arg = arg; arg.upcase})
+      Client.register_hook( :name => :test2,
+                            :points => [:pre_exec_update],
+                            :exec_proc => lambda {|cmd, arg| decided_arg = arg})
+      Client.register_command(:name => :update, :aliases => [:u])
+
+      input_command.should == nil
+      input_arg.should == nil
+      decided_arg.should == nil
+      Client.call_commands('u foo')
+      input_command.should == 'u'
+      input_arg.should == 'foo'
+      decided_arg.should == 'FOO'
+    end
+
+    it 'should call pre_exec hooks' do
+      hook_called = false
+      Client.register_hook( :name => :test,
+                            :points => [:pre_exec_update],
+                            :exec_proc => lambda {|cmd, arg| hook_called = true})
+      Client.register_command(:name => :update)
+
+      hook_called.should == false
+      Client.call_commands('update foo')
+      hook_called.should == true
+    end
+
+    it 'should able to cancel exec command' do
+      command_called = false
+      Client.register_hook( :name => :test,
+                            :points => [:pre_exec_update],
+                            :exec_proc => lambda {|cmd, arg| false})
+      Client.register_command(:name => :update, :exec_proc => lambda {|cmd, arg| command_called = true})
+
+      command_called.should == false
+      Client.call_commands('update foo')
+      command_called.should == false
+    end
+
+    it 'should call post_exec hooks' do
+      command_result = nil
+      Client.register_hook( :name => :test,
+                            :points => [:post_exec_update],
+                            :exec_proc => lambda {|cmd, arg, result| command_result = result })
+      Client.register_command(:name => :update, :exec_proc => lambda {|arg| 'foo'})
+
+      command_result.should == nil
+      Client.call_commands('update foo')
+      command_result.should == 'foo'
+    end
+
+    it 'should call exit hooks' do
+      hook_called = false
+      Client.register_hook(
+        :name => :test,
+        :points => [:exit],
+        :exec_proc => lambda { hook_called = true }
+      )
+
+      hook_called.should == false
+      Client.exit
+      hook_called.should == true
+    end
+
+    it 'should call plural hooks' do
+      hook1_called = false
+      hook2_called = false
+      Client.register_hook(:name => :hook1, :points => [:exit], :exec_proc => lambda {hook1_called = true})
+      Client.register_hook(:name => :hook2, :points => [:exit], :exec_proc => lambda {hook2_called = true})
+
+      hook1_called.should == false
+      hook2_called.should == false
+      Client.exit
+      hook1_called.should == true
+      hook2_called.should == true
+    end
+
+    it 'should able to override hooks' do
+      hook1_called = false
+      hook2_called = false
+      Client.register_hook(:name => :hook, :points => [:exit], :exec_proc => lambda {hook1_called = true})
+      Client.register_hook(:name => :hook, :points => [:exit], :exec_proc => lambda {hook2_called = true})
+
+      hook1_called.should == false
+      hook2_called.should == false
+      Client.exit
+      hook1_called.should == false
+      hook2_called.should == true
+    end
+  end
+end