termtter 1.8.0 → 1.9.0

data/lib/termtter/default_config.rb

@@ -2,11 +2,12 @@ config.set_default(:logger, nil)
 config.set_default(:update_interval, 120)
 config.set_default(:prompt, '> ')
 config.set_default(:devel, false)
+config.set_default(:token_file, "~/.termtter/token")
 config.set_default(:timeout, 60)
-config.set_default(:retry, 1)
+config.set_default(:retry, 3)
 config.set_default(:splash, <<SPLASH)
 
-   <cyan>&lt;(@)//_</cyan>  .  .      <on_green> #{(Time.now.year == 2010 && Time.now.month == 4 && Time.now.day == 1)?'Centertter':'Termtter'} <underline>#{Termtter::VERSION}</underline> </on_green>
+   <cyan>&lt;(@)//_</cyan>  .  .      <on_green> #{(Time.now.year == 2011 && Time.now.month == 4 && Time.now.day == 1)?'Centertter':'Termtter'} <underline>#{Termtter::VERSION}</underline> </on_green>
       <cyan>\\\\</cyan>           <on_green> http://termtter.org/ </on_green>
 
 SPLASH
@@ -16,3 +17,5 @@ config.system.set_default :run_commands, []
 config.system.set_default :load_plugins, []
 config.system.set_default :disable_plugins, []
 config.system.set_default :eval_scripts, []
+
+config.cache.set_default(:memcached_server, 'localhost:11211')

data/lib/termtter/hookable.rb

@@ -34,6 +34,10 @@ module Termtter
             hooks[hook.name] = hook
           end
 
+          def remove_hook(name)
+            hooks.delete(name.to_sym)
+          end
+
           def get_hook(name)
             hooks[name]
           end

data/lib/termtter/memory_cache.rb

@@ -1,32 +1,80 @@
 require 'delegate'
 
 module Termtter
-  class MemoryCache < SimpleDelegator
-    attr_reader :limit
 
-    def initialize(limit = 10000)
-      super(Hash.new)
-      @keys = []
-      @limit = limit
+  class MemoryCache
+    # delegate to storage class
+
+    def storage
+      @storage ||= storage_class.new(config.cache.memcached_server)
     end
 
-    def adjust(key)
-      unless @keys.include?(key)
-        @keys << key
-        while @keys.size > limit
-          delete(@keys.shift)
-        end
-      end
+    def method_missing(method, *args, &block)
+      storage.__send__(method, *args, &block)
     end
 
-    def []=(key, value)
-      super
-      adjust(key)
+    protected
+    def storage_class
+      can_use_memcache? ? MemCache : MemCacheMock
+    end
+
+    def can_use_memcache?
+      return unless config.cache.memcached_server
+      begin
+        require 'memcache'
+        MemCache.new(config.cache.memcached_server).stats # when server is wrong, die here.
+      rescue StandardError, LoadError
+        false
+      else
+        true
+      end
     end
 
-    def store(key, value)
-      super
-      adjust(key)
+    class MemCacheMock < SimpleDelegator
+      def initialize(dummy_server)
+        super(Hash.new)
+        @keys = []
+        @limit = 10000
+      end
+
+      def set(key, value, expiry = 0, raw = false)
+        self[key] = try_clone value
+        adjust(key)
+        self
+      end
+
+      def get(key, raw = false)
+        try_clone self[key]
+      end
+
+      def get_multi(*keys)
+        results = {}
+        keys.each{ |key|
+          results[key] = try_clone self[key]
+        }
+        results
+      end
+
+      def stats
+        { "total_items"=> length }
+      end
+
+      def flush_all(delay = 0)
+        clear
+      end
+
+      protected
+
+      def try_clone(a)
+        a.clone rescue a
+      end
+
+      def adjust(key)
+        return if @keys.include?(key)
+        @keys << key
+        delete(@keys.shift) while @keys.size > @limit
+      end
+
     end
   end
 end

data/lib/termtter/rubytter_proxy.rb

@@ -1,14 +1,25 @@
 # -*- coding: utf-8 -*-
-config.set_default(:memory_cache_size, 10000)
+begin
+  require 'nokogiri'
+rescue LoadError
+  begin
+    require 'hpricot'
+  rescue LoadError
+  end
+end
 
 module Termtter
+  class JSONError < StandardError; end
   class RubytterProxy
+    class FrequentAccessError < StandardError; end
+
     include Hookable
 
     attr_reader :rubytter
 
     def initialize(*args)
-      @rubytter = Rubytter.new(*args)
+      @rubytter = OAuthRubytter.new(*args)
+      @initial_args = args
     end
 
     def method_missing(method, *args, &block)
@@ -47,23 +58,6 @@ module Termtter
       end
     end
 
-    def status_cache_store
-      # TODO: DB store とかにうまいこと切り替えられるようにしたい
-      @status_cache_store ||= MemoryCache.new(config.memory_cache_size)
-    end
-
-    def users_cache_store
-      @users_cache_store ||= MemoryCache.new(config.memory_cache_size)
-    end
-
-    def cached_user(screen_name)
-      users_cache_store[screen_name]
-    end
-
-    def cached_status(id)
-      status_cache_store[id.to_i]
-    end
-
     def call_rubytter_or_use_cache(method, *args, &block)
       case method
       when :show
@@ -72,6 +66,12 @@ module Termtter
           store_status_cache(status)
         end
         status
+      when :user
+        unless user = cached_user(args[0])
+          user = call_rubytter(method, *args, &block)
+          store_user_cache(user)
+        end
+        user
       when :home_timeline, :user_timeline, :friends_timeline, :search
         statuses = call_rubytter(method, *args, &block)
         statuses.each do |status|
@@ -83,27 +83,102 @@ module Termtter
       end
     end
 
+    def cached_user(screen_name_or_id)
+      user = Termtter::Client.memory_cache.get(['user', Termtter::Client.normalize_as_user_name(screen_name_or_id.to_s)].join('-'))
+      ActiveRubytter.new(user) if user
+    end
+
+    def cached_status(status_id)
+      status = Termtter::Client.memory_cache.get(['status', status_id].join('-'))
+      ActiveRubytter.new(status) if status
+    end
+
     def store_status_cache(status)
-      return if status_cache_store.key?(status.id)
-      status_cache_store[status.id] = status
+      Termtter::Client.memory_cache.set(['status', status.id].join('-'), status.to_hash, 3600 * 24 * 14)
       store_user_cache(status.user)
     end
 
     def store_user_cache(user)
-      return if users_cache_store.key?(user.screen_name)
-      users_cache_store[user.screen_name] = user
+      Termtter::Client.memory_cache.set(['user', user.id.to_i].join('-'), user.to_hash, 3600 * 24)
+      Termtter::Client.memory_cache.set(['user', Termtter::Client.normalize_as_user_name(user.screen_name)].join('-'), user.to_hash, 3600 * 24)
+    end
+
+    attr_accessor :safe_mode
+    def safe
+      new_instance = self.class.new(@rubytter)
+      new_instance.safe_mode = true
+      self.instance_variables.each{ |v|
+        new_instance.instance_variable_set(v, self.instance_variable_get(v))
+      }
+      new_instance
+    end
+
+    def current_limit
+      @limit_manager ||= LimitManager.new(@rubytter)
     end
 
     def call_rubytter(method, *args, &block)
-      config.retry.times do
+      raise FrequentAccessError if @safe_mode && !self.current_limit.safe?
+      config.retry.times do |now|
         begin
           timeout(config.timeout) do
             return @rubytter.__send__(method, *args, &block)
           end
-        rescue TimeoutError
+        rescue Rubytter::APIError => e
+          raise e
+        rescue JSON::ParserError => e
+          if message = error_html_message(e)
+            puts message
+            raise Rubytter::APIError.new(message)
+          else
+            raise e
+          end
+        rescue StandardError, TimeoutError => e
+          if now + 1 == config.retry
+            raise e
+          else
+            Termtter::Client.logger.debug("rubytter_proxy: retry (#{e.class.to_s}: #{e.message})")
+          end
+        end
+      end
+    end
+
+    if defined? Nokogiri
+      def error_html_message(e)
+        Nokogiri(e.message).at('title, h2').text rescue nil
+      end
+    elsif defined? Hpricot
+      def error_html_message(e)
+        Hpricot(e.message).at('title, h2').inner_text rescue nil
+      end
+    else
+      def error_html_message(e)
+        m = %r'<title>(.*?)</title>'.match(e.message) and m.captures[0] rescue nil
+      end
+    end
+    private :error_html_message
+
+    class LimitManager
+      def initialize(rubytter)
+        @rubytter = rubytter
+        @limit = nil
+        @count = 0
+      end
+
+      def get
+        @count += 1
+        if @count > 5 || !@limit
+          @count = 0
+          @limit = @rubytter.limit_status
         end
+        @limit
+      end
+
+      def safe?
+        limit = self.get
+        threshold = [(Time.parse(limit.reset_time) - Time.now) / 3600 - 0.1, 0.1].max * limit.hourly_limit
+        threshold < limit.remaining_hits
       end
-      raise TimeoutError, 'execution expired'
     end
   end
 end

data/lib/termtter/system_extensions.rb

@@ -25,9 +25,11 @@ module Readline
       pathes = Array(ENV['TERMTTER_EXT_LIB'] || [
         '/usr/lib64/libreadline.so',
         '/usr/local/lib64/libreadline.so',
+        '/usr/local/lib/libreadline.dylib',
         '/opt/local/lib/libreadline.dylib',
         '/usr/lib/libreadline.so',
         '/usr/local/lib/libreadline.so',
+        Dir.glob('/lib/libreadline.so*')[-1] || '', # '' is dummy
         File.join(Gem.bindir, 'readline.dll')
       ])
       dlload(pathes.find { |path| File.exist?(path)})
@@ -46,7 +48,7 @@ module Readline
     end
   rescue Exception
     def self.rl_parse_and_bind(str);end
-    def self.refresh_line;end
+    def self.refresh_line;end unless Readline::NATIVE_REFRESH_LINE_METHOD
   end
 end
 
@@ -60,25 +62,27 @@ def create_highline
   HighLine.new($stdin)
 end
 
+class BrowserNotFound < StandardError; end
+
 def open_browser(url)
-  if ENV['KDE_FULL_SESSION'] == 'true'
-    system 'kfmclient', 'exec', url
-  elsif ENV['GNOME_DESKTOP_SESSION_ID']
-    system 'gnome-open', url
-  elsif !(/not found/ =~ `which exo-open`)
-    # FIXME: is fungible system('exo-open').nil? for lambda {...}
-    system 'exo-open', url
+  found = case RUBY_PLATFORM.downcase
+  when /linux/
+    [['xdg-open'], ['x-www-browser'], ['firefox'], ['w3m', '-X']]
+  when /darwin/
+    [['open']]
+  when /mswin(?!ce)|mingw|bccwin/
+    [['start']]
   else
-    case RUBY_PLATFORM.downcase
-    when /linux/
-      system 'firefox', url
-    when /darwin/
-      system 'open', url
-    when /mswin(?!ce)|mingw|bccwin/
-      system 'start', url
-    else
-      system 'firefox', url
-    end
+    [['xdg-open'], ['firefox'], ['w3m', '-X']]
+  end.find do |cmd|
+    system *(cmd.dup << url)
+    $?.exitstatus != 127
+  end
+  if found
+    # Kernel::__method__ is not suppoted in Ruby 1.8.6 or earlier.
+    eval %{ def open_browser(url); system *(#{found}.dup << url); end }
+  else
+    raise BrowserNotFound
   end
 end
 

data/lib/termtter.rb

@@ -14,16 +14,17 @@ require 'net/https'
 require 'open-uri'
 require 'optparse'
 require 'readline'
-gem 'rubytter', '>= 0.11.0'
 require 'rubytter'
 require 'notify'
 require 'timeout'
+require 'oauth'
 
 module Termtter
   VERSION = File.read(File.join(File.dirname(__FILE__), '../VERSION')).strip
   APP_NAME = 'termtter'
 
   require 'termtter/config'
+  require 'termtter/crypt'
   require 'termtter/default_config'
   require 'termtter/optparse'
   require 'termtter/command'
@@ -43,4 +44,7 @@ module Termtter
   CONF_DIR = File.expand_path('~/.termtter') unless defined? CONF_DIR
   CONF_FILE = File.join(Termtter::CONF_DIR, 'config') unless defined? CONF_FILE
   $:.unshift(CONF_DIR)
+
+  CONSUMER_KEY = 'eFFLaGJ3M0VMZExvNmtlNHJMVndsQQ=='
+  CONSUMER_SECRET = 'cW8xbW9JT3dyT0NHTmVaMWtGbHpjSk1tN0lReTlJYTl0N0trcW9Fdkhr'
 end

data/spec/termtter/crypt_spec.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'termtter/crypt'
+
+module Termtter
+  describe Crypt do
+    it '.crypt crypts string' do
+      Crypt.crypt('hi').should be_kind_of(String)
+    end
+    it '.decrypt decrypts string' do
+      a = Crypt.crypt('hi')
+      Crypt.decrypt(a).should == 'hi'
+    end
+  end
+end

data/spec/termtter/rubytter_proxy_spec.rb

@@ -76,5 +76,19 @@ module Termtter
       @rubytter_mock.should_receive(:show).exactly(0)
       @twitter.show(1).should == "status"
     end
+
+    it 'has safe mode' do
+      safe_twitter = @twitter.safe
+      safe_twitter.should be_kind_of(RubytterProxy)
+      safe_twitter.safe_mode.should be_true
+      safe_twitter.rubytter.should == @twitter.rubytter
+    end
+
+    it 'dies when LimitManager.safe? is false' do
+      safe_twitter = @twitter.safe
+      safe_twitter.current_limit.stub!(:safe?).and_return(false)
+
+      lambda{ safe_twitter.call_rubytter(:update, 'test') }.should raise_error(Termtter::RubytterProxy::FrequentAccessError)
+    end
   end
 end