sekka 1.1.1.pre → 1.1.3.pre

data/Rakefile

@@ -70,7 +70,7 @@ end
 
 task :compile do
   # generate version.rb
-  dictVersion = "1.2.0"
+  dictVersion = "1.2.2"
   vh = Jeweler::VersionHelper.new "."
   open( "./lib/sekka/sekkaversion.rb", "w" ) {|f|
     f.puts(   "class SekkaVersion" )
@@ -154,33 +154,53 @@ task :bench do
   sh "time ruby -I ./lib /usr/local/bin/nendo ./test/henkan-bench.nnd"
 end
 
-task :alljisyo => [ :jisyoS, :jisyoL, :load, :dump  ]
+task :alljisyo  => [ :alljisyoS, :alljisyoL ]
+task :alljisyoS => [ :jisyoS, :loadS, :dumpS ]
+task :alljisyoL => [ :jisyoL, :loadL, :dumpL ]
 
 task :jisyoS do
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.L.201008           >  ./data/SEKKA-JISYO.SMALL"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.L.hira-kata        >> ./data/SEKKA-JISYO.SMALL"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.hiragana-phrase    >> ./data/SEKKA-JISYO.SMALL"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.hiragana-phrase2   >> ./data/SEKKA-JISYO.SMALL"
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.L.201008           >  ./data/SEKKA-JISYO.SMALL.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.L.hira-kata        >> ./data/SEKKA-JISYO.SMALL.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.hiragana-phrase    >> ./data/SEKKA-JISYO.SMALL.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.hiragana-phrase2   >> ./data/SEKKA-JISYO.SMALL.#{x}"
+  }
 end
 
 task :jisyoL do
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.L.201008           >  ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.L.hira-kata        >> ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.fullname           >> ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.jinmei             >> ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.station            >> ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.hiragana-phrase    >> ./data/SEKKA-JISYO.LARGE"
-  sh "time ./bin/sekka-jisyo convert ./data/SKK-JISYO.hiragana-phrase2   >> ./data/SEKKA-JISYO.LARGE"
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.L.201008           >  ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.L.hira-kata        >> ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.fullname           >> ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.jinmei             >> ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.station            >> ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.hiragana-phrase    >> ./data/SEKKA-JISYO.LARGE.#{x}"
+    sh "time ./bin/sekka-jisyo convert#{x} ./data/SKK-JISYO.hiragana-phrase2   >> ./data/SEKKA-JISYO.LARGE.#{x}"
+  }
+end
+
+task :loadS do
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo load    ./data/SEKKA-JISYO.SMALL.#{x}  ./data/SEKKA-JISYO.SMALL.#{x}.tch"
+  }
 end
 
-task :load do
-  sh "time ./bin/sekka-jisyo load    ./data/SEKKA-JISYO.SMALL  ./data/SEKKA-JISYO.SMALL.tch"
-  sh "time ./bin/sekka-jisyo load    ./data/SEKKA-JISYO.LARGE  ./data/SEKKA-JISYO.LARGE.tch"
+task :loadL do
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo load    ./data/SEKKA-JISYO.LARGE.#{x}  ./data/SEKKA-JISYO.LARGE.#{x}.tch"
+  }
 end
 
-task :dump do
-  sh "time ./bin/sekka-jisyo dump    ./data/SEKKA-JISYO.SMALL.tch > ./data/SEKKA-JISYO.SMALL.tsv"
-  sh "time ./bin/sekka-jisyo dump    ./data/SEKKA-JISYO.LARGE.tch > ./data/SEKKA-JISYO.LARGE.tsv"
+task :dumpS do
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo dump    ./data/SEKKA-JISYO.SMALL.#{x}.tch > ./data/SEKKA-JISYO.SMALL.#{x}.tsv"
+  }
+end
+
+task :dumpL do
+  [ "N", "A" ].each {|x|
+    sh "time ./bin/sekka-jisyo dump    ./data/SEKKA-JISYO.LARGE.#{x}.tch > ./data/SEKKA-JISYO.LARGE.#{x}.tsv"
+  }
 end
 
 

data/VERSION.yml

@@ -1,4 +1,4 @@
 ---
 :major: 1
 :minor: 1
-:patch: 1
+:patch: 3

data/bin/sekka-jisyo

@@ -76,7 +76,8 @@ core.evalStr( <<";;END-OF-SCRIPT" )
 
 (define (display-help)
   (print "Usage : ")
-  (print "  sekka-jisyo convert  SKK-JISYO.X      > SEKKA-JISYO.X       ... output   SEKKA-JISYO to STDOUT")
+  (print "  sekka-jisyo convertA SKK-JISYO.X      > SEKKA-JISYO.X       ... output   SEKKA-JISYO to STDOUT(AZIK data included)")
+  (print "  sekka-jisyo convertN SKK-JISYO.X      > SEKKA-JISYO.X       ... output   SEKKA-JISYO to STDOUT(AZIK data excluded)")
   (print "  sekka-jisyo load     SEKKA-JISYO.X      SEKKA-JISYO.X.tch   ... load     SEKKA-JISYO to Tokyo Cabinet DB")
   (print "  sekka-jisyo load     SEKKA-JISYO.X      SEKKA-JISYO.X.db    ... load     SEKKA-JISYO to ndbm          DB")
   (print "  sekka-jisyo load     SEKKA-JISYO.X      redis:[hostname]    ... load     SEKKA-JISYO to redis DB on [hostname]")
@@ -85,13 +86,14 @@ core.evalStr( <<";;END-OF-SCRIPT" )
   (print "  sekka-jisyo dump     SEKKA-JISYO.X.db                       ... dump     ndbm                     to   DUMPDATA(STDOUT)")
   (print "  sekka-jisyo dump     redis:[hostname]                       ... dump     redis DB on [hostname]   to   DUMPDATA(STDOUT)")
   (print "  sekka-jisyo dump     redis:                                 ... dump     redis DB on localhost    to   DUMPDATE(STDOUT)")
+  (print "  sekka-jisyo restore  SEKKA-JISYO.X.tsv  SEKKA-JISYO.X.tch   ... restore  Tokyo Cabinet DB from tsv-file")
   (print "  sekka-jisyo restore  SEKKA-JISYO.X.tsv  redis:[hostname]    ... restore  redis DB on [hostname]   from tsv-file")
   (print "  sekka-jisyo restore  SEKKA-JISYO.X.tsv  redis:              ... restore  redis DB on localhost    from tsv-file"))
 
 
 (define (analyze-kvs-type filename)
   (cond
-   ((rxmatch #/[.]tch$/ filename)
+   ((rxmatch #/[.]tch/ filename)
     (values 'tokyocabinet filename))
    ((rxmatch #/[.]db$/ filename)
     (values 'dbm filename))
@@ -113,7 +115,13 @@ core.evalStr( <<";;END-OF-SCRIPT" )
    (else
     (let1 command (string->symbol (first argv))
       (cond
-       ((eq? 'convert command)
+       ((eq? 'convertN command)
+        (if (< (length argv) 2)
+            (display-help)
+            (begin
+              (set! global-use-azik #f)
+              (convert-skk-jisyo (second argv)))))
+       ((eq? 'convertA command)
         (if (< (length argv) 2)
             (display-help)
             (convert-skk-jisyo (second argv))))

data/bin/sekka-server

@@ -16,17 +16,23 @@ DICTURL = "https://raw.github.com/kiyoka/sekka/master/public_dict/" + SekkaVersi
 
 PIDFILE = DICTDIR + "/pid"
 
+DICTTYPE = if ENV.has_key?( 'SEKKA_AZIK' )
+             "A"
+           else
+             "N"
+           end
+
 TC_OPTS = "#xmsiz=256m"
-TC_FILE = DICTDIR + "/SEKKA-JISYO.SMALL.tch" + TC_OPTS
-TSVFILE = DICTDIR + "/SEKKA-JISYO.SMALL.tsv"
-SUMFILE = DICTDIR + "/SEKKA-JISYO.SMALL.md5"
+TC_FILE = DICTDIR + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.tch" + TC_OPTS
+TSVFILE = DICTDIR + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.tsv"
+SUMFILE = DICTDIR + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.md5"
 
-URLURL  = DICTURL + "/SEKKA-JISYO.SMALL.url"
-SUMURL  = DICTURL + "/SEKKA-JISYO.SMALL.md5"
+URLURL  = DICTURL + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.url"
+SUMURL  = DICTURL + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.md5"
 
 TC_FILE_LIST = [ DICTDIR + "/SEKKA-JISYO.CUSTOM.tch" + TC_OPTS,
-                 DICTDIR + "/SEKKA-JISYO.LARGE.tch"  + TC_OPTS,
-                 DICTDIR + "/SEKKA-JISYO.SMALL.tch"  + TC_OPTS ]
+                 DICTDIR + "/SEKKA-JISYO.LARGE.#{DICTTYPE}.tch"  + TC_OPTS,
+                 DICTDIR + "/SEKKA-JISYO.SMALL.#{DICTTYPE}.tch"  + TC_OPTS ]
 
 MEMCACHED = "localhost:11211"                # memcahced
 
@@ -50,6 +56,35 @@ def getSekkaDbInfo( env )
   end
 end
 
+def checkJisyoIsInstalled( dictType, dictSource )
+  key = "SEKKA::VERSION"
+  STDERR.printf( "Info: Checking SEKKA jisyo on #{dictType} server...\n" )
+  begin
+    result = case dictType
+             when :tokyocabinet
+               require 'tokyocabinet'
+               require 'sekka/kvs'
+               tc = Kvs.new( :tokyocabinet )
+               tc.open( dictSource )
+               ret = tc.get( key )
+               tc.close()
+               ret
+             when :redis
+               begin
+                 require 'redis'
+                 require 'sekka/kvs'
+                 redis = Kvs.new( :redis )
+                 redis.open( dictSource )
+                 ret = redis.get( key )
+                 redis.close()
+                 ret
+               rescue => e
+                 STDERR.printf( "Error: sekka-server can't connect to redis(port=%s)...\n", dictSource )
+                 exit 1
+               end
+             end
+  end
+end
 
 def main
   if not File.directory?( DICTDIR )
@@ -115,38 +150,24 @@ def main
     # .tchファイルが存在するか調べる
     list = TC_FILE_LIST.select { |name| File.exist?( name ) }
 
-    if 0 == list.size
-      # tsvファイルをTokyo CabinetのHashDB化する
-      STDERR.printf( "Info: Converting TSV file to Tokyo Cabinet *.tch\n" )
-      cmd = sprintf( "tchmgr importtsv %s %s", TC_FILE, TSVFILE )
-      STDERR.printf( "Command : %s\n", cmd )
-      system( cmd )
-
-      # 中身を確認する(tchmgrで読めるものができている)
-      STDERR.printf( "Info: inform *.tch\n" )
-      cmd = sprintf( "tchmgr inform %s", TC_FILE )
+    # redisサーバーに辞書が投入済みか確認する
+    ok = checkJisyoIsInstalled( dictType, TC_FILE )
+    if 0 == list.size and (not ok)
+      # tsvファイルをuploadする
+      STDERR.printf( "Info: Uploading...\n" )
+      cmd = sprintf( "sekka-jisyo restore %s %s", TSVFILE, TC_FILE )
       STDERR.printf( "Command : %s\n", cmd )
       system( cmd )
     end
+    STDERR.printf( "Info: [OK]\n" )
 
     # 存在する.tchファイルの中で一番最初のファイルを使う。
     list = TC_FILE_LIST.select { |name| File.exist?( name ) }
     dictSource = list[0]
   when :redis
-    key = "SEKKA::VERSION"
     # redisサーバーに辞書が投入済みか確認する
-    STDERR.printf( "Info: Checking SEKKA jisyo on redis server...\n" )
-    require 'redis'
-    require 'sekka/kvs'
-    redis = Kvs.new( :redis )
-    begin
-      redis.open( dictSource )
-      result = redis.get( key )
-    rescue => e
-      STDERR.printf( "Error: sekka-server can't connect to redis(port=%s)...\n", dictSource )
-      exit 1
-    end
-    unless result
+    ok = checkJisyoIsInstalled( dictType, dictSource )
+    unless ok
       # tsvファイルをuploadする。
       STDERR.printf( "Info: Uploading...\n" )
       cmd = sprintf( "sekka-jisyo restore %s %s:%s", TSVFILE, dictType, dictSource )

data/emacs/sekka.el

@@ -1620,7 +1620,7 @@ point から行頭方向に同種の文字列が続く間を漢字変換しま
 (setq default-input-method "japanese-sekka")
 
 (defconst sekka-version
-  "1.1.1" ;;SEKKA-VERSION
+  "1.1.3" ;;SEKKA-VERSION
   )
 (defun sekka-version (&optional arg)
   "入力モード変更"

data/lib/sekka/approximatesearch.rb

@@ -42,11 +42,11 @@ class ApproximateSearch
   def search( userid, kvs, keyword, type )
     arr = []
     case userid
-    when "MASTER"
-      arr  = searchByUser( "MASTER", kvs, keyword, type )
+    when "M"
+      arr  = searchByUser( "M", kvs, keyword, type )
     else
       h = {}
-      searchByUser( "MASTER", kvs, keyword, type ).each { |item| h[ item[1] ] = item[0] }
+      searchByUser( "M", kvs, keyword, type ).each { |item| h[ item[1] ] = item[0] }
       searchByUser(  userid,  kvs, keyword, type ).each { |item| h[ item[1] ] = item[0] }
       h.keys.each { |k|  arr << [ h[k], k ] }
     end
@@ -56,11 +56,11 @@ class ApproximateSearch
   def searchByUser( userid, kvs, keyword, type )
     pair = case type
            when 'k' # okuri nashi kanji entry
-             ["Ik::" + userid + "::", keyword.downcase]
+             ["Ik:" + userid + ":", keyword.downcase]
            when 'K' # okuri ari   kanji entry
-             ["IK::" + userid + "::", keyword]
+             ["IK:" + userid + ":", keyword]
            when 'h' # hiragana phrase entry
-             ["Ih::" + userid + "::", keyword.downcase]
+             ["Ih:" + userid + ":", keyword.downcase]
            else
              raise sprintf( "Error: ApproximateSearch#search unknown type %s ", type )
            end

data/lib/sekka/convert-jisyo.nnd

@@ -36,13 +36,13 @@
 (use srfi-1)
 (use sekka.util)
 (use sekka.roman-lib)
-
+(require "progressbar")
 
 (define (expand-hiragana-phrase-entry key)
   (let1 roman-list (gen-hiragana->roman-list key)
     (if (< 1000 (length roman-list))
         (begin
-          #?=(sprintf " Warning: ignored entry [%s] (hiragana phrase), because too many pattens.\n" key)
+          (sprintf " Warning: ignored entry [%s] (hiragana phrase), because too many pattens.\n" key)
           #f) ;; パターン数が爆発した単語は無視する
         (map
          (lambda (x)
@@ -53,7 +53,7 @@
   (let1 roman-list (gen-hiragana->roman-list key)
     (if (< 1000 (length roman-list))
         (begin
-          #?=(sprintf " Warning: ignored entry [%s %s] , because too many pattens.\n" key value)
+          (sprintf " Warning: ignored entry [%s %s] , because too many pattens.\n" key value)
           #f) ;; パターン数が爆発した単語は無視する
         (append
          (map
@@ -85,81 +85,74 @@
 
 
 (define (convert-skk-jisyo-f f)
-  (define total   0)
-  (define current 0)
-
-  (define (display-progress line)
-    (set! current (+ current 1))
-    (when (= 0 (% current 1000))
-      (STDERR.printf "  %7d/%7d (%3.3f％)\n" current total (* (/ current (total.to_f)) 100.0))))
-
-  (define (gen-sekka-entries line)
-    (display-progress line)
-
-    (let* ((line   (line.sub #/\/$/ ""))
-           (fields (split-dict-line line)))
-      (cond
-       ((rxmatch #/^\;/ line)
-        ;; コメント行
-        #f)
-       ((not fields)
-        ;; フォーマットエラー
-        #f)
-       ((rxmatch #/\;\;/ line)
-        ;; フォーマットエラー
-        #f)
-       ((and (is-hiragana (first fields))
-             (= 1 (length fields)))
-        ;; 平仮名フレーズ
-        (expand-hiragana-phrase-entry (first fields)))
-       ((and (is-hiragana (first fields))
-             (rxmatch #/^\/$/ (second fields)))
-        ;; 平仮名フレーズ
-        (expand-hiragana-phrase-entry (first fields)))
-       ((or (is-hiragana (first fields))
-            (rxmatch #/^([>#あ-んー]+)$/ (first fields)))
-        ;; 送り仮名なしデータ
-        (expand-okuri-nashi-entry (first fields) (second fields)))
-       ((rxmatch #/^([>あ-んー]+)([a-z])$/ (first fields))
-        => (lambda (m)
-             ;; 送り仮名ありデータ
-             (expand-okuri-ari-entry (rxmatch-substring m 1)
-                                     (rxmatch-substring m 2)
+  (let1 progress (ProgressBar.new "convert  " (file-length f) STDERR)
+
+    (define (gen-sekka-entries line)
+      (progress.inc)
+      
+      (let* ((line   (line.sub #/\/$/ ""))
+             (fields (split-dict-line line)))
+        (cond
+         ((rxmatch #/^\;/ line)
+          ;; コメント行
+          #f)
+         ((not fields)
+          ;; フォーマットエラー
+          #f)
+         ((rxmatch #/\;\;/ line)
+          ;; フォーマットエラー
+          #f)
+         ((and (is-hiragana (first fields))
+               (= 1 (length fields)))
+          ;; 平仮名フレーズ
+          (expand-hiragana-phrase-entry (first fields)))
+         ((and (is-hiragana (first fields))
+               (rxmatch #/^\/$/ (second fields)))
+          ;; 平仮名フレーズ
+          (expand-hiragana-phrase-entry (first fields)))
+         ((or (is-hiragana (first fields))
+              (rxmatch #/^([>#あ-んー]+)$/ (first fields)))
+          ;; 送り仮名なしデータ
+          (expand-okuri-nashi-entry (first fields) (second fields)))
+         ((rxmatch #/^([>あ-んー]+)([a-z])$/ (first fields))
+          => (lambda (m)
+               ;; 送り仮名ありデータ
+               (expand-okuri-ari-entry (rxmatch-substring m 1)
+                                       (rxmatch-substring m 2)
                                      (second fields))))
-       ((rxmatch #/[亜-瑤]+/ (first fields))
-        ;; 漢字が1文字でも含まれている
-        #f)
-       ((rxmatch #/[#]+/ (first fields))
-        ;; # が1文字でも含まれている
-        #f)
-       ((rxmatch #/^[ ]*$/ (first fields) )
-        ;; 空文字列
-        #f)
-       ((= 1 (length fields))
-        ;; フィールドが1件しかない。
-        #f)
-       (else
-        (list (cons (first fields) (second fields)))))))
-
-  (let* ([lines
-          (map
-           (lambda (line)
-             (line.chomp))
-           (f.readlines))]
-         [_ (set! total (lines.size))]
-         [result '#()])
-    (for-each
-     (lambda (x)
-       (let1 entries (gen-sekka-entries x)
-         (when entries
-           (for-each
-            (lambda (entry)
-              (result.push (sprintf "%s %s" (car entry) (cdr entry))))
-            entries))))
-     lines)
+         ((rxmatch #/[亜-瑤]+/ (first fields))
+          ;; 漢字が1文字でも含まれている
+          #f)
+         ((rxmatch #/[#]+/ (first fields))
+          ;; # が1文字でも含まれている
+          #f)
+         ((rxmatch #/^[ ]*$/ (first fields) )
+          ;; 空文字列
+          #f)
+         ((= 1 (length fields))
+          ;; フィールドが1件しかない。
+          #f)
+         (else
+          (list (cons (first fields) (second fields)))))))
+    
+    (let* ([lines
+            (map
+             (lambda (line)
+               (line.chomp))
+             (f.readlines))]
+           [result '#()])
+      (for-each
+       (lambda (x)
+         (let1 entries (gen-sekka-entries x)
+           (when entries
+             (for-each
+              (lambda (entry)
+                (result.push (sprintf "%s %s" (car entry) (cdr entry))))
+              entries))))
+       lines)
+      
+      (to-list result))))
 
-    (to-list result)))
-   
 
 
 

data/lib/sekka/henkan.nnd

@@ -377,7 +377,7 @@
 (define (sekkaHenkan userid kvs cachesv keyword limit roman-method)
   (define cache-exp-second (* 60 60))
   (let* ((keyword (keyword.strip))
-         (sekka-keyword (+ "sekka::" roman-method "::" (limit.to_s) "::" keyword)))
+         (sekka-keyword (+ "sekka:" roman-method ":" (limit.to_s) ":" keyword)))
     (if-let1 fetched (and cachesv
                           (cachesv.get sekka-keyword #f))
       (begin
@@ -389,13 +389,13 @@
                            (sekka-henkan userid kvs keyword limit (make-keyword roman-method)))
         (and cachesv
              (not (null? henkan-result))
-             (let1 fetched2 (cachesv.get  "sekka::(keys)" #f)
+             (let1 fetched2 (cachesv.get  "sekka:(keys)" #f)
                (cachesv.put! sekka-keyword (write-to-string henkan-result) cache-exp-second)
-               (cachesv.put! "sekka::(keys)" (if fetched2
+               (cachesv.put! "sekka:(keys)" (if fetched2
                                                  (+ fetched2 " " sekka-keyword)
                                                  sekka-keyword)
                              cache-exp-second)
-               (if-let1 v (cachesv.get  "sekka::(keys)" #f)
+               (if-let1 v (cachesv.get  "sekka:(keys)" #f)
                  (begin
                    #?=(v.size)
                    #?=v)
@@ -408,13 +408,13 @@
 ;; Flush henkan-result cache data on cachesv(memcached)
 (define (flushCacheServer cachesv)
   #?="--- do (flushCacheServer) ---"
-  (if-let1 fetched (cachesv.get  "sekka::(keys)" #f)
+  (if-let1 fetched (cachesv.get  "sekka:(keys)" #f)
     (begin
       (for-each
        (lambda (x)
          (cachesv.delete  #?=x))
        (to-list (fetched.split #/[ ]+/)))
-      (cachesv.delete "sekka::(keys)"))
+      (cachesv.delete "sekka:(keys)"))
     #f))
 ;; Export to Ruby world
 (export-to-ruby flushCacheServer)
@@ -429,7 +429,7 @@
     (dict-get userid kvs key #f))
 
   (define (write-user-entry userid kvs key value)
-    (kvs.put! (+ userid "::" key) value))
+    (kvs.put! (+ userid ":" key) value))
 
   (define (join-henkan-kouho lst)
     (+ "/"
@@ -474,7 +474,7 @@
 ;; ユーザー辞書の全削除 (useridで指定したユーザーの辞書)
 ;; 削除した件数を返す。
 (define (flushUserJisyo userid kvs)
-  (let1 lst (to-list (kvs.forward_match_keys (+ userid "::")))
+  (let1 lst (to-list (kvs.forward_match_keys (+ userid ":")))
     (for-each
      (lambda (k)
        (kvs.delete k))
@@ -499,13 +499,13 @@
 
   ;; "ユーザー語彙を"(stored)"にpush!する"
   (define (kvs-push! userid kvs entry-str)
-    (let* ((orig (kvs.get (+ userid "::(stored)") "()"))
+    (let* ((orig (kvs.get (+ userid ":(stored)") "()"))
            (orig (read-from-string orig)))
-      (kvs.put! (+ userid "::(stored)") (write-to-string (append orig (list entry-str))))
+      (kvs.put! (+ userid ":(stored)") (write-to-string (append orig (list entry-str))))
       entry-str))
 
   (cond
-   ((memv dict-line (read-from-string (kvs.get (+ userid "::(stored)") "()")))
+   ((memv dict-line (read-from-string (kvs.get (+ userid ":(stored)") "()")))
     #?=(+ "already stored userid=[" userid "] tango=[" dict-line "]")
     #f)
    (else

data/lib/sekka/jisyo-db.nnd

@@ -40,8 +40,8 @@
 (require "distributedtrie")
 (use sekka.util)
 
-(define master-prefix  "MASTER")
-(define version-prefix "SEKKA::VERSION")
+(define master-prefix  "M")
+(define version-prefix "SEKKA:VERSION")
 (define okuri-ari-prefix       "IK")
 (define okuri-nashi-prefix     "Ik")
 (define hiragana-phrase-prefix "Ih")
@@ -56,12 +56,12 @@
 
 
 ;; dict-get search sequence
-;;   (1) try "userid::keyword" key
-;;   (2) try "MASTER::keyword" key
+;;   (1) try "userid:keyword" key
+;;   (2) try "M:keyword" key
 (define (dict-get userid kvs key . fallback)
   (if-let1 value
-      (or (kvs.get (+ userid "::" key) #f)
-          (kvs.get (+ master-prefix "::" key) #f))
+      (or (kvs.get (+ userid ":" key) #f)
+          (kvs.get (+ master-prefix ":" key) #f))
     value
     (let1 opt (get-optional fallback #f)
       opt)))
@@ -119,18 +119,18 @@
                              (length okuri-nashi-list)
                              (length hiragana-phrase-list))))))
 
-      (let1 trie (DistributedTrie::Trie.new kvs (+ okuri-ari-prefix "::" userid "::"))
+      (let1 trie (DistributedTrie::Trie.new kvs (+ okuri-ari-prefix ":" userid ":"))
         (trie-add-autocommit trie   okuri-ari-list       progress))
       
-      (let1 trie (DistributedTrie::Trie.new kvs (+ okuri-nashi-prefix "::" userid "::"))
+      (let1 trie (DistributedTrie::Trie.new kvs (+ okuri-nashi-prefix ":" userid ":"))
         (trie-add-autocommit trie   okuri-nashi-list     progress))
       
-      (let1 trie (DistributedTrie::Trie.new kvs (+ hiragana-phrase-prefix "::" userid "::"))
+      (let1 trie (DistributedTrie::Trie.new kvs (+ hiragana-phrase-prefix ":" userid ":"))
         (trie-add-autocommit trie   hiragana-phrase-list progress)))))
 
 
 (define (append-entry userid kvs _key value)
-  (let1 key (+ userid "::" _key)
+  (let1 key (+ userid ":" _key)
     (cond
      ((rxmatch #/^=/ _key)
       ;; hiragana-phrase entry
@@ -161,15 +161,6 @@
         (kvs.put! key value))))))
 
 
-(define (file-length f)
-  (let1 total 0
-    (for-each
-     (lambda (x)
-       (set! total (+ 1 total)))
-     f)
-    (f.rewind)
-    total))
-
 (define (load-sekka-jisyo-f f filename)
   (define keylist '())
   (define (create-keylist kvs f)