atig 0.0.1

data/lib/atig/db/listenable.rb

@@ -0,0 +1,22 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'forwardable'
+
+module Atig
+  module Db
+    module Listenable
+      SingleThread = false
+      def listen(&f)
+        @listeners ||= []
+        @listeners.push f
+      end
+
+      private
+      def notify(*args)
+        @listeners ||= []
+        @listeners.each{|f|
+          f.call(*args)
+        }
+      end
+    end
+  end
+end

data/lib/atig/db/lists.rb

@@ -0,0 +1,76 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'atig/db/listenable'
+require 'atig/db/transaction'
+module Atig
+  module Db
+    class Lists
+      include Listenable
+      include Transaction
+
+      def initialize(name)
+        @name    = name
+        @lists   = {}
+        @on_invalidated = lambda{|*_| }
+        @members = nil
+      end
+
+      def update(lists)
+        @members = Hash.new{|hash,key|
+          hash[key] = []
+        }
+
+        (lists.keys  - @lists.keys).each do|name|
+          list = Followings.new(@name % name)
+          list.listen{|kind,users|
+            notify kind,name,users
+          }
+          @lists[name] = list
+          notify :new, name
+        end
+
+        (@lists.keys - lists.keys).each do|x|
+          @lists.delete x
+          notify :del,x
+        end
+
+        lists.each do|name,users|
+          @lists[name].update users
+        end
+
+        lists.each do|list, users|
+          users.each do|user|
+            @members[user.screen_name] << list
+          end
+        end
+      end
+
+      def [](name)
+        @lists[name]
+      end
+
+      def invalidate(name)
+        @on_invalidated.call name
+      end
+
+      def on_invalidated(&f)
+        @on_invalidated = f
+      end
+
+      def find_by_screen_name(name)
+        return [] unless @members
+        @members[name]
+      end
+
+      def find_by_list_name(name)
+        @lists[name].users
+      end
+
+      def each(&f)
+        @lists.each do|name,users|
+          f.call name,users.users
+        end
+      end
+    end
+  end
+end

data/lib/atig/db/roman.rb

@@ -0,0 +1,30 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+module Atig
+  module Db
+    class Roman
+      Seq = %w[
+	  a   i   u   e   o  ka  ki  ku  ke  ko  sa shi  su  se  so
+	 ta chi tsu  te  to  na  ni  nu  ne  no  ha  hi  fu  he  ho
+	 ma  mi  mu  me  mo  ya      yu      yo  ra  ri  ru  re  ro
+	 wa              wo   n
+	 ga  gi  gu  ge  go  za  ji  zu  ze  zo  da          de  do
+	 ba  bi  bu  be  bo  pa  pi  pu  pe  po
+	kya     kyu     kyo sha     shu     sho cha     chu     cho
+	nya     nyu     nyo hya     hyu     hyo mya     myu     myo
+	rya     ryu     ryo
+	gya     gyu     gyo  ja      ju      jo bya     byu     byo
+	pya     pyu     pyo
+      ].freeze
+
+      def make(n)
+        ret = []
+        begin
+          n, r = n.divmod(Seq.size)
+          ret << Seq[r]
+        end while n > 0
+        ret.reverse.join
+      end
+    end
+  end
+end

data/lib/atig/db/sized_uniq_array.rb

@@ -0,0 +1,62 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'forwardable'
+
+module Atig
+  module Db
+    class SizedUniqArray
+      extend Forwardable
+      include Enumerable
+      def_delegators :@xs,:[]
+
+      attr_reader :size
+
+      def initialize(capacity)
+        @size     = 0
+        @index    = 0
+        @capacity = capacity
+        @xs       = Array.new(capacity, nil)
+      end
+
+      def each(&f)
+        if @size < @capacity then
+          0.upto(@size - 1) {|i|
+            f.call @xs[i]
+          }
+        else
+          0.upto(@size - 1){|i|
+            f.call @xs[ (i + @index) % @capacity ]
+          }
+        end
+      end
+
+      def reverse_each(&f)
+        if @size < @capacity then
+          (@size - 1).downto(0) {|i|
+            f.call @xs[i]
+          }
+        else
+          (@size - 1).downto(0){|i|
+            f.call @xs[ (i + @index) % @capacity ]
+          }
+        end
+      end
+
+      def include?(item)
+        self.any?{|x|
+          x.id == item.id
+        }
+      end
+
+      def push(item)
+        return nil if include? item
+        i = @index
+        @xs[i] = item
+        @size = [ @size + 1, @capacity ].min
+        @index = ( @index + 1 ) % @capacity
+        i
+      end
+      alias_method :<<, :push
+    end
+  end
+end

data/lib/atig/db/sql.rb

@@ -0,0 +1,35 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+require 'sqlite3'
+
+module Atig
+  module Db
+    class Sql
+      def initialize(name)
+        @name = name
+      end
+
+      def dump(obj)
+        [Marshal.dump(obj)].pack('m')
+      end
+
+      def load(text)
+        if text == nil then
+          nil
+        else
+          Marshal.load(text.unpack('m').first)
+        end
+      end
+
+      def execute(&f)
+        db = SQLite3::Database.new @name
+        begin
+          res = f.call db
+        ensure
+          db.close
+        end
+        res
+      end
+    end
+  end
+end

data/lib/atig/db/statuses.rb

@@ -0,0 +1,147 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'atig/db/listenable'
+require 'atig/db/transaction'
+require 'sqlite3'
+require 'atig/db/roman'
+require 'atig/db/sql'
+require 'base64'
+
+class OpenStruct
+  def id; method_missing(:id) end
+end
+
+module Atig
+  module Db
+    class Statuses
+      include Listenable
+      include Transaction
+
+      Size = 400
+
+      def initialize(name)
+        @db = Sql.new name
+        @roman = Roman.new
+
+        unless File.exist? name then
+          @db.execute do|db|
+            db.execute %{create table status (
+                          id integer primary key,
+                          status_id   text,
+                          tid  text,
+                          sid  text,
+                          screen_name text,
+                          user_id     text,
+                          created_at  integer,
+                          data blob);}
+
+            db.execute %{create table id (
+                          id integer primary key,
+                          screen_name text,
+                          count integer);}
+
+            # thx to @L_star
+            # http://d.hatena.ne.jp/mzp/20100407#c
+            db.execute_batch %{
+              create index status_createdat on status(created_at);
+              create index status_sid on status(sid);
+              create index status_statusid on status(status_id);
+              create index status_tid on status(tid);
+              create index status_userid on status(user_id);
+
+              create index status_id on status(id);
+              create index id_id on id(id);
+            }
+          end
+        end
+      end
+
+      def add(opt)
+        @db.execute do|db|
+          id  = opt[:status].id
+          return unless db.execute(%{SELECT id FROM status WHERE status_id = ?}, id).empty?
+
+          screen_name = opt[:user].screen_name
+          sum   = db.get_first_value("SELECT sum(count) FROM id").to_i
+          count = db.get_first_value("SELECT count      FROM id WHERE screen_name = ?", screen_name).to_i
+          entry = OpenStruct.new opt.merge(:tid => @roman.make(sum),
+                                           :sid => "#{screen_name}:#{@roman.make(count)}")
+          db.execute(%{INSERT INTO status
+                      VALUES(NULL, :id, :tid, :sid, :screen_name, :user_id, :created_at, :data)},
+                     :id          => id,
+                     :tid         => entry.tid,
+                     :sid         => entry.sid,
+                     :screen_name => screen_name,
+                     :user_id     => opt[:user].id,
+                     :created_at  => Time.parse(opt[:status].created_at).to_i,
+                     :data        => @db.dump(entry))
+          if count == 0 then
+            db.execute("INSERT INTO id VALUES(NULL,?,?)", screen_name, 1)
+          else
+            db.execute("UPDATE id SET count = ? WHERE screen_name = ?", count + 1, screen_name)
+          end
+          notify entry
+        end
+      end
+
+      def find_all(opt={})
+        find '1', 1, opt
+      end
+
+      def find_by_screen_name(name, opt={})
+        find 'screen_name',name, opt
+      end
+
+      def find_by_user(user, opt={})
+        find 'user_id', user.id, opt
+      end
+
+      def find_by_tid(tid)
+        find('tid', tid).first
+      end
+
+      def find_by_sid(tid)
+        find('sid', tid).first
+      end
+
+      def find_by_status_id(id)
+        find('status_id', id).first
+      end
+
+      def find_by_id(id)
+        find('id', id).first
+      end
+
+      def remove_by_id(id)
+        @db.execute do|db|
+          db.execute "DELETE FROM status WHERE id = ?",id
+        end
+      end
+
+      def cleanup
+        @db.execute do|db|
+          created_at = db.execute("SELECT created_at FROM status ORDER BY created_at DESC LIMIT 1 OFFSET ?", Size-1)
+          unless created_at.empty? then
+            db.execute "DELETE FROM status WHERE created_at < ?", created_at.first
+          end
+          db.execute "VACUUM status"
+        end
+      end
+
+      private
+      def find(lhs,rhs, opt={},&f)
+        query  = "SELECT id,data FROM status WHERE #{lhs} = :rhs ORDER BY created_at DESC LIMIT :limit"
+        params = { :rhs => rhs, :limit => opt.fetch(:limit,20) }
+        res = []
+
+        @db.execute do|db|
+          db.execute(query,params) do|id,data,*_|
+            e = @db.load(data)
+            e.id = id.to_i
+            res << e
+          end
+        end
+        res
+      end
+    end
+  end
+end

data/lib/atig/db/transaction.rb

@@ -0,0 +1,47 @@
+# -*- mode:ruby; coding:utf-8 -*-
+require 'timeout'
+require 'atig/util'
+
+module Atig
+  module Db
+    module Transaction
+      include Util
+
+      def init
+        return if @queue
+
+        debug "transaction thread start"
+        @queue = SizedQueue.new 10
+        daemon do
+          f,src = @queue.pop
+          debug "transaction is poped at #{src}"
+
+          if respond_to?(:timeout_interval) && timeout_interval > 0 then
+            begin
+              timeout(timeout_interval){ f.call self }
+            rescue TimeoutError
+              debug "transaction is timeout at #{src}"
+            end
+          else
+            f.call self
+          end
+
+          debug "transaction is finished at #{src}"
+        end
+      end
+
+      def transaction(&f)
+        init
+
+        debug "transaction is registered"
+        @queue.push [ f, caller.first ]
+      end
+
+      def debug(s)
+        if respond_to? :log
+          log :debug, s
+        end
+      end
+    end
+  end
+end

data/lib/atig/exception_util.rb

@@ -0,0 +1,26 @@
+# -*- mode:ruby; coding:utf-8 -*-
+
+module Atig
+  module ExceptionUtil
+    def safe(&f)
+      begin
+        f.call
+      rescue Exception => e
+        s = e.inspect + "\n"
+        e.backtrace.each do |l|
+          s += "\t#{l}\n"
+        end
+
+        log :error,s
+      end
+    end
+
+    def daemon(&f)
+      Thread.new do
+        loop{ safe { f.call }}
+      end
+    end
+
+    module_function :safe,:daemon
+  end
+end