atig 0.0.1

data/lib/atig/command/status.rb

@@ -0,0 +1,41 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'atig/command/command'
+begin
+  require 'jcode'
+rescue LoadError
+end
+
+module Atig
+  module Command
+    class Status < Atig::Command::Command
+      def initialize(*args); super end
+      def command_name; %w(status) end
+
+      def action(target, mesg, command, args)
+        if args.empty?
+          yield "/me #{command} blah blah"
+          return
+        end
+        text = mesg.split(" ", 2)[1]
+        previous,*_ = db.statuses.find_by_user( db.me, :limit => 1)
+        if previous and
+            ((::Time.now - ::Time.parse(previous.status.created_at)).to_i < 60*60*24 rescue true) and
+            text.strip == previous.status.text.strip
+          yield "You can't submit the same status twice in a row."
+          return
+        end
+        q = gateway.output_message(:status => text)
+
+        if q[:status].each_char.to_a.size > 140 then
+          yield "You can't submit the status over 140 chars"
+          return
+        end
+
+        api.delay(0, :retry=>3) do|t|
+          ret = t.post("statuses/update", q)
+          gateway.update_status ret,target
+        end
+      end
+    end
+  end
+end

data/lib/atig/command/thread.rb

@@ -0,0 +1,44 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'atig/command/command'
+require 'atig/command/info'
+
+module Atig
+  module Command
+    class Thread < Atig::Command::Command
+      def initialize(*args)
+        super
+      end
+
+      def command_name; %w(thread) end
+
+      def action(target, mesg, command, args)
+        if args.empty?
+          yield "/me #{command} <ID> [<NUM>]"
+          return
+        end
+
+        tid, num = args
+        count = 10 unless (1..20).include?(count = num.to_i)
+
+        if entry = Info.find_status(db, tid) then
+          chain(entry,count){|x|
+            gateway[target].message x, Net::IRC::Constants::NOTICE
+          }
+        else
+          yield "No such ID : #{tid}"
+        end
+      end
+
+      def chain(entry,count, &f)
+        if count <= 0 then
+          return
+        elsif id = entry.status.in_reply_to_status_id then
+          Info.status(db, api, id){|next_|
+            chain(next_, count - 1, &f)
+          }
+        end
+        f.call entry
+      end
+    end
+  end
+end

data/lib/atig/command/time.rb

@@ -0,0 +1,32 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'time'
+require 'atig/command/command'
+
+module Atig
+  module Command
+    class Time < Atig::Command::Command
+      def command_name; %w(time) end
+
+      def action(target, mesg, command, args)
+        if args.empty?
+          yield "/me #{command} <NICK>"
+          return
+        end
+        nick, *_ = args
+        Info.user(db, api, nick){|user|
+          offset = user.utc_offset
+          time   = "TIME :%s%s (%s)" %  [
+                                         (::Time.now + offset).utc.iso8601[0, 19],
+                                         "%+.2d:%.2d" % (offset/60).divmod(60),
+                                         user.time_zone
+                                        ]
+          entry = TwitterStruct.make('user'   => user,
+                                     'status' => { 'text' =>
+                                       Net::IRC.ctcp_encode(time) })
+          gateway[target].message entry, Net::IRC::Constants::NOTICE
+        }
+      end
+    end
+  end
+end

data/lib/atig/command/uptime.rb

@@ -0,0 +1,32 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/command/command'
+
+module Atig
+  module Command
+    class Uptime < Atig::Command::Command
+      def initialize(*args)
+        super
+        @time = ::Time.now
+      end
+
+      def command_name; "uptime" end
+
+      def action(target, mesg, command, args)
+        yield format(::Time.now - @time)
+      end
+
+      def format(x)
+        day , y   = x.divmod(60*60*24)
+        hour, z   = y.divmod(60*60)
+        min , sec = z.divmod(60)
+
+        s = ""
+        s += "#{day} days " if day > 0
+        s += "%02d:" % hour if hour > 0
+        s += "%02d:%02d" % [min,sec]
+        s
+      end
+    end
+  end
+end

data/lib/atig/command/user.rb

@@ -0,0 +1,42 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'time'
+require 'atig/command/command'
+
+module Atig
+  module Command
+    class User < Atig::Command::Command
+      def initialize(*args); super end
+      def command_name; %w(user u) end
+
+      def action(target, mesg, command, args)
+        if args.empty?
+          yield "/me #{command} <NICK> [<NUM>]"
+          return
+        end
+        nick, num,*_ = args
+
+        count = 20 unless (1..200).include?(count = num.to_i)
+        api.delay(0) do|t|
+          begin
+            statuses = t.get("statuses/user_timeline",
+                             { :count => count, :screen_name => nick})
+            statuses.reverse_each do|status|
+              db.statuses.transaction do|d|
+                d.add :status => status, :user => status.user, :source => :user
+              end
+            end
+
+            db.statuses.
+              find_by_screen_name(nick, :limit=>count).
+              reverse_each do|entry|
+              gateway[target].message entry, Net::IRC::Constants::NOTICE
+            end
+          rescue Twitter::APIFailed => e
+            yield e.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/atig/command/user_info.rb

@@ -0,0 +1,27 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/command/command'
+
+module Atig
+  module Command
+    class UserInfo < Atig::Command::Command
+      def initialize(*args); super end
+      def command_name; %w(bio userinfo) end
+
+      def action(target, mesg, command,args)
+        if args.empty?
+          yield "/me #{command} <ID>"
+          return
+        end
+        nick,*_ = args
+
+        Info.user(db, api, nick)do|user|
+          entry = TwitterStruct.make('user'   => user,
+                                     'status' => { 'text' =>
+                                       Net::IRC.ctcp_encode(user.description) })
+          gateway[target].message entry, Net::IRC::Constants::NOTICE
+        end
+      end
+    end
+  end
+end

data/lib/atig/command/version.rb

@@ -0,0 +1,49 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/twitter'
+require 'atig/command/command'
+
+module Atig
+  module Command
+    class Version  < Atig::Command::Command
+      def command_name; %w(version) end
+
+      def action(target, mesg, command,args)
+        if args.empty?
+          yield "/me #{command} <ID>"
+          return
+        end
+        nick,*_ = args
+
+        entries = db.statuses.find_by_screen_name(nick, :limit => 1)
+        if entries && !entries.empty? then
+          entry = TwitterStruct.make('user'   => entries.first.user,
+                                     'status' => { 'text' =>
+                                       format(entries.first.status.source) })
+          gateway[target].message entry, Net::IRC::Constants::NOTICE
+        else
+          api.delay(0) do|t|
+            begin
+              user = t.get("users/show", { :screen_name => nick})
+              db.statuses.transaction do|d|
+                d.add :user => user, :status => user.status, :source => :version
+                entry = TwitterStruct.make('user'   => user,
+                                           'status' => { 'text' =>
+                                             format(user.status.source) })
+                gateway[target].message entry, Net::IRC::Constants::NOTICE
+              end
+            rescue Twitter::APIFailed => e
+              yield e.to_s
+            end
+          end
+        end
+      end
+
+      def format(source)
+        version = source.gsub(/<[^>]*>/, "").strip
+        version << " <#{$1}>" if source =~ / href="([^"]+)/
+        Net::IRC.ctcp_encode version
+      end
+    end
+  end
+end

data/lib/atig/command/whois.rb

@@ -0,0 +1,39 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'atig/command/info'
+require 'time'
+module Atig
+  module Command
+    class Whois < Atig::Command::Command
+      def command_name; %w(whois) end
+
+      def action(target, mesg, command,args)
+        if args.empty?
+          yield "/me #{command} <ID>"
+          return
+        end
+        nick,*_ = args
+
+        Atig::Command::Info::user(db, api, nick) do|user|
+          id = "id=#{user.id}"
+          host = "twitter.com"
+          host += "/protected" if user.protected
+          desc      = user.name
+          desc      = "#{desc} / #{user.description}".gsub(/\s+/, " ") if user.description and not user.description.empty?
+          signon_at = ::Time.parse(user.created_at).to_i rescue 0
+          idle_sec  = (::Time.now - (user.status ? ::Time.parse(user.status.created_at) : signon_at)).to_i rescue 0
+          location  = user.location
+          location  = "SoMa neighborhood of San Francisco, CA" if location.nil? or location.empty?
+
+          send Net::IRC::Constants::RPL_WHOISUSER,   nick, id, host, "*", desc
+          send Net::IRC::Constants::RPL_WHOISSERVER, nick, host, location
+          send Net::IRC::Constants::RPL_WHOISIDLE,   nick, "#{idle_sec}", "#{signon_at}", "seconds idle, signon time"
+          send Net::IRC::Constants::RPL_ENDOFWHOIS,  nick, "End of WHOIS list"
+        end
+      end
+
+      def send(command,nick,*params)
+        gateway.post gateway.server_name, command, db.me.screen_name, nick, *params
+      end
+    end
+  end
+end

data/lib/atig/db/db.rb

@@ -0,0 +1,60 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/db/followings'
+require 'atig/db/statuses'
+require 'atig/db/lists'
+require 'atig/util'
+require 'thread'
+require 'set'
+require 'fileutils'
+require 'tmpdir'
+
+module Atig
+  module Db
+    class Db
+      include Util
+      attr_reader :followings, :statuses, :dms, :lists
+      attr_accessor :me
+      Path = ::Dir.tmpdir
+      VERSION = 4
+
+      def initialize(context, opt={})
+        @log        = context.log
+        @me         = opt[:me]
+
+        @followings = Followings.new dir('following')
+        @statuses   = Statuses.new   dir('status')
+        @dms        = Statuses.new   dir('dm')
+        @lists      = Lists.new      dir('lists.%s')
+
+        log :info, "initialize"
+      end
+
+      def dir(id)
+        dir = File.expand_path "atig/#{@me.screen_name}/", Path
+        log :debug, "db(#{id}) = #{dir}"
+        FileUtils.mkdir_p dir
+        File.expand_path "#{id}.#{VERSION}.db", dir
+      end
+
+      def transaction(&f)
+        @followings.transaction do|_|
+          @statuses.transaction do|_|
+            @dms.transaction do|_|
+              @lists.transaction do|_|
+                f.call self
+              end
+            end
+          end
+        end
+      end
+
+      def cleanup
+        transaction do
+          @statuses.cleanup
+          @dms.cleanup
+        end
+      end
+    end
+  end
+end

data/lib/atig/db/followings.rb

@@ -0,0 +1,131 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/db/listenable'
+require 'atig/db/transaction'
+require 'atig/db/sql'
+
+module Atig
+  module Db
+    class Followings
+      include Listenable
+      include Transaction
+
+      def initialize(name)
+        @db = Sql.new name
+
+        unless File.exist? name then
+          @db.execute do|db|
+            db.execute %{create table users (
+                          id integer primary key,
+                          screen_name text,
+                          user_id text,
+                          protected bool,
+                          only bool,
+                          data blob);}
+            db.execute %{
+              create index users_screen on users (screen_name);
+            }
+          end
+        end
+
+        @users = []
+        @on_invalidated = lambda{}
+      end
+
+      def size
+        @db.execute do|db|
+          db.get_first_value('SELECT COUNT(*) FROM users').to_i
+        end
+      end
+
+      def empty?
+        @db.execute do|db|
+          db.get_first_value('SELECT * FROM users LIMIT 1') == nil
+        end
+      end
+
+      def invalidate
+        @on_invalidated.call
+      end
+
+      def on_invalidated(&f)
+        @on_invalidated = f
+      end
+
+      def users
+        @db.execute{|db|
+          db.execute("SELECT data FROM users").map{|data|
+            @db.load data[0]
+          }
+        }
+      end
+
+      def exists?(db, templ, *args)
+        db.get_first_value("SELECT * FROM users WHERE #{templ} LIMIT 1",*args) != nil
+      end
+
+      def may_notify(mode, xs)
+        unless xs.empty? then
+          notify mode, xs
+        end
+      end
+
+      def update(users)
+        @db.execute do|db|
+          may_notify :join, users.select{|u|
+            not exists?(db,
+                        "screen_name = ?",
+                        u.screen_name)
+          }
+
+          names = users.map{|u| u.screen_name.inspect }.join(",")
+          parts =
+          may_notify :part, db.execute(%{SELECT screen_name,data FROM users
+                                         WHERE screen_name NOT IN (#{names})}).map{|_,data|
+            @db.load(data)
+          }
+          db.execute(%{DELETE FROM users
+                       WHERE screen_name NOT IN (#{names})})
+
+          may_notify :mode, users.select{|u|
+            exists?(db,
+                    "screen_name = ? AND (protected != ? OR only != ?)",
+                    u.screen_name, u.protected, u.only)
+          }
+
+          users.each do|user|
+            id = db.get_first_value('SELECT id FROM users WHERE user_id = ? LIMIT 1', user.id)
+            if id then
+              db.execute("UPDATE users SET screen_name = ?, protected = ?, only = ?, data = ? WHERE id = ?",
+                         user.screen_name,
+                         user.protected,
+                         user.only,
+                         @db.dump(user),
+                         id)
+            else
+              db.execute("INSERT INTO users
+                          VALUES(NULL, :screen_name, :user_id, :protected, :only, :data)",
+                         :screen_name => user.screen_name,
+                         :user_id     => user.id,
+                         :protected   => user.protected,
+                         :only        => user.only,
+                         :data        => @db.dump(user))
+            end
+          end
+        end
+      end
+
+      def find_by_screen_name(name)
+        @db.execute do|db|
+          @db.load db.get_first_value('SELECT data FROM users WHERE screen_name = ? LIMIT 1', name)
+        end
+      end
+
+      def include?(user)
+        @db.execute do|db|
+          exists? db,'user_id = ?', user.id
+        end
+      end
+    end
+  end
+end