jugyo-termtter 0.7.6 → 0.7.7

data/lib/termtter/client.rb

@@ -0,0 +1,298 @@
+module Termtter
+  class CommandNotFound < StandardError; end
+
+  module Client
+
+    @@hooks = []
+    @@commands = {}
+    @@new_commands = {}
+    @@completions = []
+    @@filters = []
+    @@helps = []
+
+    class << self
+      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
+
+      def add_command(regex, &block)
+        @@commands[regex] = block
+      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 add_macro(r, s)
+        add_command(r) do |m, t|
+          call_commands(s % m.to_a[1..-1])
+        end
+      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
+
+      # 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
+            begin
+              command.call($~, Termtter::API.twitter)
+            rescue => e
+              handle_error(e)
+            end
+          end
+        end
+
+        @@new_commands.each do |key, command|
+          command_info = command.match?(text)
+          # TODO: call hook for before command here.
+          if command_info
+            command_found = true
+            result = command.execute(command_info[1])
+            if result
+              # TODO: call hook for after command with result.
+            end
+          end
+        end
+
+        raise CommandNotFound unless command_found
+      end
+
+      def pause
+        @@pause = true
+      end
+
+      def resume
+        @@pause = false
+        @@update_thread.run
+      end
+
+      def exit
+        call_hooks([], :exit)
+        @@main_thread.kill
+        @@update_thread.kill
+        @@input_thread.kill
+      end
+
+      def load_default_plugins
+        plugin 'standard_plugins'
+        plugin 'stdout'
+      end
+
+      def load_config
+        conf_file = File.expand_path('~/.termtter')
+        if File.exist? conf_file
+          wrap_require do
+            load conf_file
+          end
+        else
+          HighLine.track_eof = false
+          ui = HighLine.new
+          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 = proc {|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_api()
+        Termtter::API.setup()
+      end
+
+      def run
+        load_default_plugins()
+        load_config()
+        setup_readline()
+        setup_api()
+
+        puts 'initializing...'
+        initialized = false
+        @@pause = false
+        call_hooks([], :initialize)
+
+        @@input_thread = nil
+        @@update_thread = Thread.new do
+          since_id = nil
+          loop do
+            begin
+              Thread.stop if @@pause
+
+              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)
+              initialized = true
+              @@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
+            ensure
+              sleep configatron.update_interval
+            end
+          end
+        end
+
+        until initialized; end
+
+        begin
+          stty_save = `stty -g`.chomp
+          trap("INT") { system "stty", stty_save; exit }
+        rescue Errno::ENOENT
+        end
+
+        @@main_thread = Thread.new do
+          loop do
+            @@input_thread = create_input_thread()
+            @@input_thread.join
+          end
+        end
+        @@main_thread.join
+      end
+
+      def create_input_thread()
+        Thread.new do
+          erb = ERB.new(configatron.prompt)
+          while buf = Readline.readline(erb.result(Termtter::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 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
+

data/lib/termtter/command.rb

@@ -0,0 +1,67 @@
+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] || []
+      @exec_proc = args[:exec_proc] || proc {|arg|}
+      @completion_proc = args[:completion_proc] || proc {|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)
+      exec_proc.call(arg)
+    end
+
+    def pattern
+      commands_regex = commands.map {|i| Regexp.quote(i) }.join('|')
+      /^\s*((#{commands_regex})|(#{commands_regex})\s+(.*?))\s*$/
+    end
+
+    def commands
+      aliases.unshift(name.to_s)
+    end
+  end
+end
+

data/lib/termtter/connection.rb

@@ -0,0 +1,37 @@
+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/status.rb

@@ -0,0 +1,24 @@
+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/twitter.rb

@@ -0,0 +1,138 @@
+require 'highline'
+
+module Termtter
+  class Twitter
+
+    def initialize(user_name, password, connection)
+      @user_name = user_name
+      @password = password
+      @connection = connection
+    end
+
+    def update_status(status)
+      @connection.start("twitter.com", @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("twitter.com", @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)
+      uri = "#{@connection.protocol}://twitter.com/users/show/#{screen_name}.json"
+      return JSON.parse(open(uri, :http_basic_authentication => [user_name, password], :proxy => @connection.proxy_uri).read)
+    end
+
+    def get_friends_timeline(since_id = nil)
+      uri =  "#{@connection.protocol}://twitter.com/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("#{@connection.protocol}://twitter.com/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 = JSON.parse(open("#{@connection.protocol}://search.twitter.com/search.json?q=" + CGI.escape(query)).read, :proxy => @connection.proxy_uri)['results']
+      return results.map do |s|
+        status = Status.new
+        status.id = s['id']
+        status.text = CGI.unescapeHTML(s['text']).gsub(/(\n|\r)/, '').gsub(query, color(color(query, 41), 37))
+        status.created_at = Time.utc(*ParseDate::parsedate(s["created_at"])).localtime
+        status.user_screen_name = s['from_user']
+        status
+      end
+    end
+
+    def show(id, rth = false)
+      get_status = lambda { get_timeline("#{@connection.protocol}://twitter.com/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("#{@connection.protocol}://twitter.com/statuses/replies.json")
+    end
+
+    def get_timeline(uri)
+      data = JSON.parse(open(uri, :http_basic_authentication => [user_name, password], :proxy => @connection.proxy_uri).read)
+      data = [data] unless data.instance_of? Array
+      return data.map do |s|
+        status = Status.new
+        status.created_at = Time.utc(*ParseDate::parsedate(s["created_at"])).localtime
+        %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
+      uri = 'http://twitter.com/account/rate_limit_status.json'
+      data = JSON.parse(open(uri, :http_basic_authentication => [user_name, password], :proxy => @connection.proxy_uri).read)
+
+      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 user_name
+      unless @user_name.instance_of? String
+        HighLine.track_eof = false
+        @user_name = HighLine.new.ask('your twitter username: ')
+      end
+      @user_name
+    end
+
+    def password
+      unless @password.instance_of? String
+        HighLine.track_eof = false
+        @password = HighLine.new.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
+