logaling-command 0.1.1 → 0.1.2

data/CHANGES

@@ -0,0 +1,18 @@
+= 0.1.2 / 2012-01-30
+
+* 英和 / 和英 辞書のインポートができるようになりました。他プロジェクトの用語集をインポートする `loga import` と同じ手順でインポートすることができます。
+
+* 出力結果が長くなった場合に、ページングが出来るようになりました。
+
+* `loga show` コマンドが追加されました。指定した用語集内の用語を一覧する為のコマンドです。
+
+* `loga list` コマンドが追加されました。登録されている用語集を一覧するためのコマンドです。
+
+* `loga update` コマンド利用時に備考のみの変更ができるようになりました。(KitaitiMakoto さん)
+
+* インデックスのタイミングと方式を変更したので、 `loga lookup` の結果表示速度が改善されました。
+
+* 用語の登録 / 更新時の重複チェックを 用語集ファイルではなくインデックスしたものでチェックするように修正しました。
+
+* loga lookup 時に自分のプロジェクトの用語集名が、より分かり易くなるように色付けを改良しました。
+

data/lib/logaling/command.rb

@@ -19,10 +19,9 @@ require 'thor'
 require 'rainbow'
 require "logaling/repository"
 require "logaling/glossary"
-require "logaling/external_glossary"
 
 class Logaling::Command < Thor
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
   LOGALING_CONFIG = '.logaling'
 
   map '-a' => :add,
@@ -33,6 +32,8 @@ class Logaling::Command < Thor
       '-n' => :new,
       '-r' => :register,
       '-U' => :unregister,
+      '-L' => :list,
+      '-s' => :show,
       '-v' => :version
 
   class_option "glossary",        type: :string, aliases: "-g"
@@ -59,6 +60,7 @@ class Logaling::Command < Thor
   desc 'import', 'Import external glossary'
   method_option "list", type: :boolean, default: false
   def import(external_glossary=nil)
+    require "logaling/external_glossary"
     Logaling::ExternalGlossary.load
     if options["list"]
       Logaling::ExternalGlossary.list.each {|glossary| say "#{glossary.name.bright} : #{glossary.description}" }
@@ -118,6 +120,13 @@ class Logaling::Command < Thor
 
   desc 'add [SOURCE TERM] [TARGET TERM] [NOTE(optional)]', 'Add term to glossary.'
   def add(source_term, target_term, note='')
+    config = load_config_and_merge_options
+    repository.index
+
+    if repository.bilingual_pair_exists?(source_term, target_term, config["glossary"])
+      raise Logaling::TermError, "term '#{source_term}: #{target_term}' already exists in '#{config["glossary"]}'"
+    end
+
     glossary.add(source_term, target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     say e.message
@@ -139,6 +148,13 @@ class Logaling::Command < Thor
 
   desc 'update [SOURCE TERM] [TARGET TERM] [NEW TARGET TERM], [NOTE(optional)]', 'Update term.'
   def update(source_term, target_term, new_target_term, note='')
+    config = load_config_and_merge_options
+    repository.index
+
+    if repository.bilingual_pair_exists_and_has_same_note?(source_term, new_target_term, note, config["glossary"])
+      raise Logaling::TermError, "term '#{source_term}: #{new_target_term}' already exists in '#{config["glossary"]}'"
+    end
+
     glossary.update(source_term, target_term, new_target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     say e.message
@@ -154,14 +170,20 @@ class Logaling::Command < Thor
 
     unless terms.empty?
       max_str_size = terms.map{|term| term[:source_term].size}.sort.last
+      run_pager
       terms.each do |term|
         target_string = "#{term[:target_term].bright}"
         target_string <<  "\t# #{term[:note]}" unless term[:note].empty?
         if repository.glossary_counts > 1
-          color = (term[:name] == config["glossary"]) ? :green : :cyan
-          target_string << "\t(#{term[:name]})".color(color)
+          target_string << "\t"
+          glossary_name = "(#{term[:glossary_name]})"
+          if term[:glossary_name] == config["glossary"]
+            target_string << glossary_name.foreground(:white).background(:green)
+          else
+            target_string << glossary_name
+          end
         end
-        source_string = term[:source_term].split(source_term).insert(1, source_term.dup.bright).join
+        source_string = term[:snipped_source_term].map{|word|  word.is_a?(Hash) ? word[:keyword].bright : word }.join
         printf("  %-#{max_str_size+10}s %s\n", source_string, target_string)
       end
     else
@@ -176,6 +198,49 @@ class Logaling::Command < Thor
     say "logaling-command version #{Logaling::Command::VERSION}"
   end
 
+  desc 'show', 'Show terms in glossary.'
+  def show
+    required_options = {
+      "glossary" => "input glossary name '-g <glossary name>'",
+      "source-language" => "input source-language code '-S <source-language code>'",
+      "target-language" => "input target-language code '-T <target-language code>'"
+    }
+    config = load_config_and_merge_options(required_options)
+    repository.index
+    terms = repository.show_glossary(config["glossary"], config["source-language"], config["target-language"])
+    unless terms.empty?
+      run_pager
+      max_str_size = terms.map{|term| term[:source_term].size}.sort.last
+      terms.each do |term|
+        target_string = "#{term[:target_term]}"
+        target_string <<  "\t# #{term[:note]}" unless term[:note].empty?
+        printf("  %-#{max_str_size+10}s %s\n", term[:source_term], target_string)
+      end
+    else
+      "glossary <#{config['glossary']}> not found"
+    end
+
+  rescue Logaling::CommandFailed, Logaling::GlossaryDBNotFound => e
+    say e.message
+  end
+
+  desc 'list', 'Show glossary list.'
+  def list
+    repository.index
+    glossaries = repository.list
+    unless glossaries.empty?
+      run_pager
+      glossaries.each do |glossary|
+        printf("  %s\n", glossary)
+      end
+    else
+      "There is no registered glossary."
+    end
+
+  rescue Logaling::CommandFailed, Logaling::GlossaryDBNotFound => e
+    say e.message
+  end
+
   private
   def repository
     @repository ||= Logaling::Repository.new(LOGALING_HOME)
@@ -278,4 +343,32 @@ class Logaling::Command < Thor
       fp.puts "--target-language #{config['target-language']}" if config['target-language']
     end
   end
+
+  # http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
+  def run_pager
+    return if ::RUBY_PLATFORM =~ /win32/
+    return unless STDOUT.tty?
+
+    read, write = IO.pipe
+
+    unless Kernel.fork # Child process
+      STDOUT.reopen(write)
+      STDERR.reopen(write) if STDERR.tty?
+      read.close
+      write.close
+      return
+    end
+
+    # Parent process, become pager
+    STDIN.reopen(read)
+    read.close
+    write.close
+
+    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
+
+    # wait until we have input before we start the pager
+    Kernel.select [STDIN]
+    pager = ENV['PAGER'] || 'less'
+    exec pager rescue exec "/bin/sh", "-c", pager
+  end
 end

data/lib/logaling/external_glossaries/debian_project.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2011  Miho SUZUKI
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,15 +22,14 @@ module Logaling
     description     'Debian JP Project (http://www.debian.or.jp/community/translate/)'
     source_language 'en'
     target_language 'ja'
+    output_format   'csv'
 
-    def convert
-      buffer = ""
-      CSV.generate(buffer) do |csv|
-        doc = ::Nokogiri::HTML(open("http://www.debian.or.jp/community/translate/trans_table.html", "r"))
-        doc.css('dl').each do |dl|
-          dl.children.each_slice(3) do |dt, dd, _|
-            csv << [dt.text, dd.text.gsub(/(^\/|\/$)/,'')]
-          end
+    private
+    def convert_to_csv(csv)
+      doc = ::Nokogiri::HTML(open("http://www.debian.or.jp/community/translate/trans_table.html", "r"))
+      doc.css('dl').each do |dl|
+        dl.children.each_slice(3) do |dt, dd, _|
+          csv << [dt.text, dd.text.gsub(/(^\/|\/$)/,'')]
         end
       end
     end

data/lib/logaling/external_glossaries/edict.rb

@@ -0,0 +1,50 @@
+# Copyright (C) 2012  Koji SHIMADA <koji.shimada@enishi-tech.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'open-uri'
+require 'zlib'
+require 'stringio'
+
+module Logaling
+  class Edict < ExternalGlossary
+    description     'The EDICT Dictionary File (http://www.csse.monash.edu.au/~jwb/edict.html)'
+    source_language 'ja'
+    target_language 'en'
+    output_format   'csv'
+
+    private
+    def convert_to_csv(csv)
+      puts "downloading edict file..."
+      url = 'http://ftp.monash.edu.au/pub/nihongo/edict.gz'
+      Zlib::GzipReader.open(open(url)) do |gz|
+        puts "importing edict file..."
+
+        lines = StringIO.new(gz.read).each_line
+
+        lines.next # skip header
+
+        preprocessed_lines = lines.map do |line|
+          line.encode("UTF-8", "EUC-JP").chomp
+        end
+
+        preprocessed_lines.each do |line|
+          source, target = line.split('/', 2)
+          source = source.strip
+          csv << [source, target]
+        end
+      end
+    end
+  end
+end

data/lib/logaling/external_glossaries/gene95.rb

@@ -0,0 +1,60 @@
+# Copyright (C) 2012  Koji SHIMADA
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'open-uri'
+require 'zlib'
+require 'stringio'
+require 'rubygems/package'
+
+module Logaling
+  class Gene95 < ExternalGlossary
+    description     'GENE95 Dictionary (http://www.namazu.org/~tsuchiya/sdic/data/gene.html)'
+    source_language 'en'
+    target_language 'ja'
+    output_format   'csv'
+
+    private
+    def convert_to_csv(csv)
+      puts "downloading gene95 dictionary..."
+      url = 'http://www.namazu.org/~tsuchiya/sdic/data/gene95.tar.gz'
+      Zlib::GzipReader.open(open(url)) do |gz|
+        puts "importing gene95 dictionary..."
+
+        Gem::Package::TarReader.new(gz) do |tar|
+          tar.each do |entry|
+            case entry.full_name
+            when "gene.txt"
+              lines = StringIO.new(entry.read).each_line
+
+              2.times { lines.next } # skip header
+
+              preprocessed_lines = lines.map.map do |line|
+                line.encode("UTF-8", "CP932",
+                            undef: :replace, replace: '').chomp
+              end
+
+              preprocessed_lines.each_slice(2) do |source, target|
+                csv << [source.sub(/(    .*)/, ''), target]
+              end
+            else
+              # ignore
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/logaling/external_glossaries/gnome_project.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2011  Miho SUZUKI
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,14 +22,13 @@ module Logaling
     description     'GNOME Translation Project Ja (http://live.gnome.org/TranslationProjectJa)'
     source_language 'en'
     target_language 'ja'
+    output_format   'csv'
 
-    def convert
-      buffer = ""
-      CSV.generate(buffer) do |csv|
-        doc = ::Nokogiri::HTML(open("http://www.gnome.gr.jp/l10n/trans-terms.html", "r"))
-        doc.css('table tr')[1..-1].each do |tr|
-          csv << [tr.children[0].text, tr.children[1].text]
-        end
+    private
+    def convert_to_csv(csv)
+      doc = ::Nokogiri::HTML(open("http://www.gnome.gr.jp/l10n/trans-terms.html", "r"))
+      doc.css('table tr')[1..-1].each do |tr|
+        csv << [tr.children[0].text, tr.children[1].text]
       end
     end
   end

data/lib/logaling/external_glossaries/postgresql_manual.rb

@@ -1,4 +1,5 @@
 # Copyright (C) 2011  Miho SUZUKI
+# Copyright (C) 2012  Kouhei Sutou <kou@clear-code.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -21,15 +22,14 @@ module Logaling
     description     'PostgreSQL7.1 Manual (http://osb.sraoss.co.jp/PostgreSQL/Manual/)'
     source_language 'en'
     target_language 'ja'
+    output_format   'csv'
 
-    def convert
-      buffer = ""
-      CSV.generate(buffer) do |csv|
-        doc = ::Nokogiri::HTML(open("http://osb.sraoss.co.jp/PostgreSQL/Manual/word.html", "r:iso-2022-jp").read.encode("utf-8"))
-        doc.css('table table tr')[2..-1].each do |tr|
-          if tr.children[2]
-            csv << [tr.children[2].text, tr.children[4].text]
-          end
+    private
+    def convert_to_csv(csv)
+      doc = ::Nokogiri::HTML(open("http://osb.sraoss.co.jp/PostgreSQL/Manual/word.html", "r:iso-2022-jp").read.encode("utf-8"))
+      doc.css('table table tr')[2..-1].each do |tr|
+        if tr.children[2]
+          csv << [tr.children[2].text, tr.children[4].text]
         end
       end
     end

data/lib/logaling/external_glossary.rb

@@ -42,7 +42,7 @@ class Logaling::ExternalGlossary
     end
 
     def name
-      self.inspect.underscore.gsub(/.*\//,'')
+      self.to_s.underscore.gsub(/.*\//,'')
     end
 
     def description val=nil
@@ -56,14 +56,32 @@ class Logaling::ExternalGlossary
     def target_language val=nil
       @target_language ||= val
     end
+
+    def output_format(*args)
+      if args.empty?
+        @output_format ||= "csv"
+      else
+        @output_format = args.first
+      end
+    end
   end
 
   def import
-    File.open(import_file_name, "w") {|f| f.write(self.convert) }
+    File.open(import_file_name, "w") do |output|
+      output_format = self.class.output_format
+      output_format = output_format.to_s if output_format.is_a?(Symbol)
+      case output_format
+      when "csv"
+        convert_to_csv(CSV.new(output))
+      else
+        raise UnsupportedFormat, "unsupported format: <#{output_format}>"
+      end
+    end
   end
 
   private
   def import_file_name
-    [self.class.name, self.class.source_language, self.class.target_language, 'csv'].join('.')
+    [self.class.name, self.class.source_language,
+     self.class.target_language, self.class.output_format].join('.')
   end
 end

data/lib/logaling/glossary.rb

@@ -17,6 +17,7 @@
 
 require 'psych'
 require "yaml"
+require "csv"
 require "fileutils"
 
 module Logaling
@@ -72,10 +73,6 @@ module Logaling
       FileUtils.touch(@path) unless File.exist?(@path)
 
       glossary = Glossary.load_glossary(@path)
-      if bilingual_pair_exists?(glossary, source_term, target_term)
-        raise TermError, "term '#{source_term}: #{target_term}' already exists in '#{@glossary}'"
-      end
-
       glossary << build_term(source_term, target_term, note)
       dump_glossary(glossary)
     end
@@ -84,9 +81,6 @@ module Logaling
       raise GlossaryNotFound unless File.exist?(@path)
 
       glossary = Glossary.load_glossary(@path)
-      if bilingual_pair_exists?(glossary, source_term, new_target_term)
-        raise TermError, "term '#{source_term}: #{target_term}' already exists in '#{@glossary}'"
-      end
 
       target_index = find_term_index(glossary, source_term, target_term)
       if target_index
@@ -136,7 +130,9 @@ module Logaling
     end
 
     def rebuild_term(current, source_term, target_term, note)
-      note = current['note'] if note.nil? || note == ""
+      if current['target_term'] != target_term && (note.nil? || note == "")
+        note = current['note']
+      end
       target_term = current['target_term'] if target_term == ""
       build_term(source_term, target_term, note)
     end
@@ -151,10 +147,6 @@ module Logaling
       end
     end
 
-    def bilingual_pair_exists?(glossary, source_term, target_term)
-      target_terms(glossary, source_term).any?{|data| data['target_term'] == target_term }
-    end
-
     def target_terms(glossary, source_term)
       glossary.select {|term| term['source_term'] == source_term }
     end

data/lib/logaling/glossary_db.rb

@@ -15,14 +15,13 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'psych'
-require "yaml"
-require "fileutils"
 require 'groonga'
-require 'csv'
+require 'cgi'
 
 module Logaling
   class GlossaryDB
+    VERSION = 1
+
     def self.open(base_path, encoding, &blk)
       blk ? GlossaryDB.new.open(base_path, encoding, &blk) : GlossaryDB.new.open(base_path, encoding)
     end
@@ -50,8 +49,12 @@ module Logaling
     end
 
     def recreate_table
-      remove_schema
-      populate_schema
+      version = Groonga["configurations"] ? get_config("version") : 0
+      if version.to_i != VERSION
+        remove_schema
+        populate_schema
+        add_config("version", VERSION.to_s)
+      end
     end
 
     def close
@@ -59,27 +62,80 @@ module Logaling
       @database = nil
     end
 
-    def index_glossary(glossary, name, source_language, target_language)
+    def deindex_glossary(glossary_name, glossary_source)
+      delete_translations_by_glossary_source(glossary_source)
+      delete_glossary(glossary_name)
+      delete_glossary_source(glossary_source)
+    end
+
+    def index_glossary(glossary, glossary_name, glossary_source, source_language, target_language, indexed_at)
+      deindex_glossary(glossary_name, glossary_source)
+
+      add_glossary_source(glossary_source, indexed_at)
+      add_glossary(glossary_name)
       glossary.each do |term|
         source_term = term['source_term']
         target_term = term['target_term']
         note = term['note']
-        add_glossary(name, source_language, target_language, source_term, target_term, note)
+        add_translation(glossary_name, glossary_source, source_language, target_language, source_term, target_term, note)
       end
     end
 
-    def lookup(source_term)
-      records_raw = Groonga["glossaries"].select do |record|
-        record.source_term =~ source_term
+    def lookup(source_term, source_language, target_language, glossary)
+      records_selected = Groonga["translations"].select do |record|
+        conditions = [record.source_term =~ source_term]
+        conditions << (record.source_language =~ source_language) if source_language
+        conditions << (record.target_language =~ target_language) if target_language
+        conditions
+      end
+      specified_glossary = records_selected.select do |record|
+        record.glossary == glossary
       end
+      specified_glossary.each do |record|
+        record.key._score += 10
+      end
+      records = records_selected.sort([
+        {:key=>"_score", :order=>'descending'},
+        {:key=>"glossary", :order=>'ascending'},
+        {:key=>"source_term", :order=>'ascending'},
+        {:key=>"target_term", :order=>'ascending'}])
+
+      options = {:width => 100,
+                 :html_escape => true,
+                 :normalize => true}
+      snippet = records_selected.expression.snippet(["<snippet>", "</snippet>"], options)
+
+      snipped_source_term = []
+      records.map do |record|
+        term = record.key
+        snipped_text = snippet.execute(term.source_term).join
+        {:glossary_name => term.glossary.key,
+         :source_language => term.source_language,
+         :target_language => term.target_language,
+         :source_term => term.source_term,
+         :snipped_source_term => struct_snipped_text(snipped_text),
+         :target_term => term.target_term,
+         :note => term.note || ''}
+      end
+    end
+
+    def translation_list(glossary, source_language, target_language)
+      records_raw = Groonga["translations"].select do |record|
+        [
+          record.glossary == glossary,
+          record.source_language == source_language,
+          record.target_language == target_language
+        ]
+      end
+
       records = records_raw.sort([
-        {:key=>"name", :order=>'ascending'},
         {:key=>"source_term", :order=>'ascending'},
         {:key=>"target_term", :order=>'ascending'}])
 
       records.map do |record|
         term = record.key
-        {:name => term.name,
+
+        {:glossary_name => term.glossary.key,
          :source_language => term.source_language,
          :target_language => term.target_language,
          :source_term => term.source_term,
@@ -88,15 +144,119 @@ module Logaling
       end
     end
 
+    def get_bilingual_pair(source_term, target_term, glossary)
+      records = Groonga["translations"].select do |record|
+        [
+          record.glossary == glossary,
+          record.source_term == source_term,
+          record.target_term == target_term
+        ]
+      end
+
+      records.map do |record|
+        term = record.key
+
+        {:glossary_name => term.glossary,
+         :source_language => term.source_language,
+         :target_language => term.target_language,
+         :source_term => term.source_term,
+         :target_term => term.target_term,
+         :note => term.note || ''}
+      end
+    end
+
+    def get_bilingual_pair_with_note(source_term, target_term, note, glossary)
+      records = Groonga["translations"].select do |record|
+        [
+          record.glossary == glossary,
+          record.source_term == source_term,
+          record.target_term == target_term,
+          record.note == note
+        ]
+      end
+
+      records.map do |record|
+        term = record.key
+
+        {:glossary_name => term.glossary,
+         :source_language => term.source_language,
+         :target_language => term.target_language,
+         :source_term => term.source_term,
+         :target_term => term.target_term,
+         :note => term.note || ''}
+      end
+    end
+
+    def glossary_source_exist?(glossary_source, indexed_at)
+      glossary = Groonga["glossary_sources"].select do |record|
+        [
+          record.key == glossary_source,
+          record.indexed_at == indexed_at
+        ]
+      end
+      !glossary.size.zero?
+    end
+
+    def get_all_glossary_source
+      Groonga["glossary_sources"].sort([
+        {:key=>"_key", :order=>'ascending'}
+      ]).map{|record| record.key}
+    end
+
+    def get_all_glossary
+      Groonga["glossaries"].sort([
+        {:key=>"_key", :order=>'ascending'}
+      ]).map{|record| record.key}
+    end
+
     private
-    def add_glossary(name, source_language, target_language, source_term, target_term, note)
-      Groonga["glossaries"].add(:name => name,
-                                :source_language => source_language,
-                                :target_language => target_language,
-                                :source_term => source_term,
-                                :target_term => target_term,
-                                :note => note,
-                               )
+    def delete_glossary_source(glossary_source)
+      records = Groonga["glossary_sources"].select do |record|
+        record.key == glossary_source
+      end
+
+      records.each do |record|
+        record.key.delete
+      end
+    end
+
+    def add_glossary_source(glossary_source, indexed_at)
+      Groonga["glossary_sources"].add(glossary_source, :indexed_at => indexed_at)
+    end
+
+    def delete_glossary(glossary_name)
+      records = Groonga["glossaries"].select do |record|
+        record.key == glossary_name
+      end
+
+      records.each do |record|
+        record.key.delete
+      end
+    end
+
+    def add_glossary(glossary_name)
+      Groonga["glossaries"].add(glossary_name)
+    end
+
+    def delete_translations_by_glossary_source(glossary_source)
+      records = Groonga["translations"].select do |record|
+        record.glossary_source == glossary_source
+      end
+
+      records.each do |record|
+        record.key.delete
+      end
+    end
+
+    def add_translation(glossary_name, glossary_source, source_language, target_language, source_term, target_term, note)
+      Groonga["translations"].add(:glossary => glossary_name,
+                                  :glossary_source => glossary_source,
+                                  :source_language => source_language,
+                                  :target_language => target_language,
+                                  :source_term => source_term,
+                                  :target_term => target_term,
+                                  :note => note,
+                                 )
     end
 
     def reset_context(encoding)
@@ -110,8 +270,25 @@ module Logaling
 
     def populate_schema
       Groonga::Schema.define do |schema|
-        schema.create_table("glossaries") do |table|
-          table.short_text("name")
+        schema.create_table("configurations") do |table|
+          table.short_text("conf_key")
+          table.text("conf_value")
+        end
+
+        schema.create_table("glossary_sources",
+                           :type => :hash,
+                           :key_type => "ShortText") do |table|
+          table.time("indexed_at")
+        end
+
+        schema.create_table("glossaries",
+                           :type => :hash,
+                           :key_type => "ShortText") do |table|
+        end
+
+        schema.create_table("translations") do |table|
+          table.reference("glossary", "glossaries")
+          table.reference("glossary_source", "glossary_sources")
           table.short_text("source_language")
           table.short_text("target_language")
           table.short_text("source_term")
@@ -124,14 +301,17 @@ module Logaling
                             :key_type => "ShortText",
                             :key_normalize => true,
                             :default_tokenizer => "TokenBigram") do |table|
-          table.index("glossaries.source_term")
+          table.index("translations.source_term")
         end
       end
     end
 
     def remove_schema
       Groonga::Schema.define do |schema|
+        schema.remove_table("configurations") if Groonga["configurations"]
+        schema.remove_table("translations") if Groonga["translations"]
         schema.remove_table("glossaries") if Groonga["glossaries"]
+        schema.remove_table("glossary_sources") if Groonga["glossary_sources"]
         schema.remove_table("terms") if Groonga["terms"]
       end
     end
@@ -139,5 +319,33 @@ module Logaling
     def closed?
       @database.nil? or @database.closed?
     end
+
+    def struct_snipped_text(snipped_text)
+      word_list = snipped_text.split(/(<snippet>[^<]*<\/snippet>)/)
+      structed_source_term = word_list.map{|word|
+        replaced_word = word.sub(/<snippet>([^<]*)<\/snippet>/){|match| $1}
+        if replaced_word == word
+          CGI.unescapeHTML(word)
+        else
+          {:keyword => CGI.unescapeHTML(replaced_word)}
+        end
+      }
+      structed_source_term
+    end
+
+    def get_config(conf_key)
+      records = Groonga["configurations"].select do |record|
+        record.conf_key == conf_key
+      end
+      value = records.map do |record|
+        config = record.key
+        config.conf_value
+      end
+      value.size > 0 ? value[0] : ""
+    end
+
+    def add_config(conf_key, conf_value)
+      Groonga["configurations"].add(:conf_key => conf_key, :conf_value => conf_value)
+    end
   end
 end

data/lib/logaling/repository.rb

@@ -55,36 +55,54 @@ module Logaling
 
       terms = []
       Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
-        terms = db.lookup(source_term)
-        terms.delete_if{|term| term[:source_language] != source_language } if source_language
-        terms.delete_if{|term| term[:target_language] != target_language } if target_language
-        if glossary && !terms.empty?
-          # order by glossary
-          specified = terms.select{|term| term[:name] == glossary}
-          other = terms.select{|term| term[:name] != glossary}
-          terms = specified.concat(other)
-        end
+        terms = db.lookup(source_term, source_language, target_language, glossary)
+      end
+      terms
+    end
+
+    def show_glossary(glossary, source_language, target_language)
+      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+
+      terms = []
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        terms = db.translation_list(glossary, source_language, target_language)
       end
       terms
     end
 
+    def list
+      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+
+      glossaries = []
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        glossaries = db.get_all_glossary
+      end
+      glossaries
+    end
+
     def index
-      return if latest_index?
-      projects = Dir[File.join(@path, "projects", "*")]
+      project_glossaries = Dir[File.join(@path, "projects", "*")].map do |project|
+        Dir.glob(get_all_glossary_sources(File.join(project, "glossary")))
+      end
+      imported_glossaries = Dir.glob(get_all_glossary_sources(cache_path))
+      all_glossaries = project_glossaries.flatten + imported_glossaries
 
       Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
         db.recreate_table
-        projects.each do |project|
-          get_glossaries_from_project(project).each do |glossary, name, source_language, target_language|
-            db.index_glossary(glossary, name, source_language, target_language)
+        all_glossaries.each do |glossary_source|
+          indexed_at = File.mtime(glossary_source)
+          unless db.glossary_source_exist?(glossary_source, indexed_at)
+            glossary_name, source_language, target_language = get_glossary(glossary_source)
+            puts "now index #{glossary_name}..."
+            db.index_glossary(Glossary.load(glossary_source), glossary_name, glossary_source, source_language, target_language, indexed_at)
           end
         end
-        get_glossaries(cache_path).each do |glossary, name, source_language, target_language|
-          db.index_glossary(glossary, name, source_language, target_language)
+        (db.get_all_glossary_source - all_glossaries).each do |glossary_source|
+          glossary_name, source_language, target_language = get_glossary(glossary_source)
+          puts "now deindex #{glossary_name}..."
+          db.deindex_glossary(glossary_name, glossary_source)
         end
       end
-
-      FileUtils.touch(index_at_file)
     end
 
     def glossary_counts
@@ -96,33 +114,43 @@ module Logaling
       File.exist?(path) ? path : nil
     end
 
-    private
-    def latest_index?
-      if File.exist?(index_at_file)
-        index_at = File.mtime(index_at_file)
-        all_glossary_files = [cache_path, registered_projects.map{|path| File.join(path, "glossary")}].flatten.map{|path| get_all_glossary_paths(path)}.flatten
-        unless Dir.glob(all_glossary_files).any?{|file| File.mtime(file) >= index_at }
-          true
-        else
-          false
-        end
+    def bilingual_pair_exists?(source_term, target_term, glossary)
+      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+
+      terms = []
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        terms = db.get_bilingual_pair(source_term, target_term, glossary)
+      end
+
+      if terms.size > 0
+        true
       else
         false
       end
     end
 
-    def get_glossaries(path)
-      Dir.glob(get_all_glossary_paths(path)).map do |file|
-        name, source_language, target_language = File::basename(file, ".*").split(".")
-        [Glossary.load(file), name, source_language, target_language]
+    def bilingual_pair_exists_and_has_same_note?(source_term, target_term, note, glossary)
+      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+
+      terms = []
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        terms = db.get_bilingual_pair_with_note(source_term, target_term, note, glossary)
+      end
+
+      if terms.size > 0
+        true
+      else
+        false
       end
     end
 
-    def get_glossaries_from_project(path)
-      get_glossaries(File.join(path, "glossary"))
+    private
+    def get_glossary(path)
+      glossary_name, source_language, target_language = File::basename(path, ".*").split(".")
+      [glossary_name, source_language, target_language]
     end
 
-    def get_all_glossary_paths(path)
+    def get_all_glossary_sources(path)
       %w(yml tsv csv).map{|type| File.join(path, "*.#{type}") }
     end
 
@@ -145,9 +173,5 @@ module Logaling
     def imported_glossaries
       Dir[File.join(cache_path, "*")]
     end
-
-    def index_at_file
-      File.join(logaling_db_home, "index_at")
-    end
   end
 end

data/lib/logaling.rb

@@ -1,6 +1,7 @@
-# -*- encoding: utf-8 -*-
+# -*- coding: utf-8 -*-
 #
 # Copyright (C) 2011  Miho SUZUKI
+# Copyright (C) 2011  Kouhei Sutou <kou@clear-code.com>
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -25,4 +26,5 @@ module Logaling
   class GlossaryNotFound < LogalingError; end
   class GlossaryDBNotFound < LogalingError; end
   class ExternalGlossaryNotFound < LogalingError; end
+  class UnsupportedFormat < LogalingError; end
 end

data/spec/logaling/command_spec.rb

@@ -22,6 +22,7 @@ describe Logaling::Command do
   let(:command) { Logaling::Command.new([], base_options) }
   let(:glossary_path) { Logaling::Glossary.build_path('spec', 'en', 'ja') }
   let(:target_project_path) { File.join(LOGALING_HOME, "projects", "spec") }
+  let(:repository) { Logaling::Repository.new(LOGALING_HOME) }
 
   before do
     FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
@@ -80,6 +81,7 @@ describe Logaling::Command do
 
   describe '#register' do
     before do
+      sleep(1)
       @project_counts = Dir[File.join(LOGALING_HOME, "projects", "*")].size
     end
 
@@ -293,35 +295,40 @@ describe Logaling::Command do
 
   describe "#update" do
     before do
+      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, "db", "index_at"), true)
       command.new('spec', 'en', 'ja')
       command.add("spec", "テスト", "備考")
     end
 
-    context "not given source-term option" do
-      # should show err
-    end
-
-    context "not given target-term option" do
-      #should show err
-    end
+    context "with arguments except note" do
+      before do
+        command.update("spec", "テスト", "スペック")
+        @yaml = YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }
+      end
 
-    context "not given new-target-term option" do
-      #should show err
+      it "term's target_term should be updated" do
+        @yaml.should == {"source_term"=>"spec", "target_term"=>"スペック", "note"=>"備考"}
+      end
     end
 
-    context "with arguments except note" do
+    context 'with exisiting bilingual pair and note' do
       before do
-        command.update("spec", "テスト", "スペック")
+        @stdout = capture(:stdout) { command.update("spec", "テスト", "テスト", "備考") }
       end
 
-      subject { YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }}
+      it 'should show error message' do
+        @stdout.should include "already exists"
+      end
+    end
 
-      it "term's target_term should be updated" do
-        subject["target_term"].should == "スペック"
+    context 'with existing bilingual pair and different note' do
+      before do
+        command.update("spec", "テスト", "テスト", "備考だけ書き換え")
+        @yaml = YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }
       end
 
-      it "term's note should not be updated" do
-        subject["note"].should == "備考"
+      it "should update note" do
+        @yaml.should == {"source_term"=>"spec", "target_term"=>"テスト", "note"=>"備考だけ書き換え"}
       end
     end
   end
@@ -409,6 +416,74 @@ describe Logaling::Command do
     end
   end
 
+  describe "#show" do
+    let(:csv_path) { File.join(File.dirname(glossary_path), "spec.ja.en.csv") }
+    before do
+      command.new('spec', 'en', 'ja')
+      command.add("spec", "スペック", "備考")
+      command.add("spec-test", "スペックてすと", "備考")
+      command.add("spec-test-test", "スペックてすとてすと", "備考")
+
+      FileUtils.mkdir_p(File.dirname(glossary_path))
+      FileUtils.touch(csv_path)
+      File.open(csv_path, "w"){|f| f.puts "test_logaling,テスト"}
+    end
+
+    context 'when .logaling exists' do
+      before do
+        @stdout = capture(:stdout) {command.show}
+      end
+
+      it 'should show translation list' do
+        @stdout.should include "spec"
+        @stdout.should include "spec-test"
+        @stdout.should include "spec-test-test"
+        @stdout.should_not include "test_logaling"
+      end
+    end
+
+    context 'with arguments glossary' do
+      before do
+        command.options = base_options.merge("glossary" => "spec", "source-language" => "ja", "target-language" => "en")
+        @stdout = capture(:stdout) {command.show}
+      end
+
+      it 'should show translation list' do
+        @stdout.should include "test_logaling"
+        @stdout.should_not include "spec-test-test"
+      end
+    end
+
+    after do
+      FileUtils.remove_entry_secure(csv_path, true)
+    end
+  end
+
+  describe '#list' do
+    context 'when some glossaries are registered' do
+      before do
+        command.new('spec', 'en', 'ja')
+        @stdout = capture(:stdout) {command.list}
+      end
+
+      it 'should list glossaries' do
+        @stdout.should include "spec"
+      end
+    end
+
+    context 'when a glossary is unregistered' do
+      before do
+        command.new('spec', 'en', 'ja')
+        repository.unregister('spec')
+        @stdout = capture(:stdout) {command.list}
+      end
+
+      it 'should not include unregistered glossary' do
+        @stdout.should_not include "spec"
+      end
+    end
+  end
+
   after do
     FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
     FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)

data/spec/logaling/glossary_spec.rb

@@ -43,16 +43,6 @@ module Logaling
         end
       end
 
-      context 'with arguments show existing bilingual pair' do
-        before do
-          glossary.add("user", "ユーザ", "ユーザーではない")
-        end
-
-        it {
-          -> { glossary.add("user", "ユーザ", "ユーザーではない") }.should raise_error(Logaling::TermError)
-        }
-      end
-
       context "when the glossary not found" do
         before do
           glossary.add("test", "テスト", "テスト")
@@ -77,17 +67,30 @@ module Logaling
         }
       end
 
-      context 'with source-term arguments show not existing bilingual pair' do
+      context 'with source-term show not existing bilingual pair' do
         it {
           -> { glossary.update("use", "ユーザ", "ユーザー", "やっぱりユーザー") }.should raise_error(Logaling::TermError)
         }
       end
 
-      context 'with target-term arguments show not existing bilingual pair' do
+      context 'with target-term show not existing bilingual pair' do
         it {
           -> { glossary.update("user", "ユー", "ユーザー", "やっぱりユーザー") }.should raise_error(Logaling::TermError)
         }
       end
+
+      context 'with same target-term and empty note' do
+        before do
+          glossary.update("user", "ユーザ", "ユーザ", "")
+        end
+
+        it 'should clear note' do
+          yaml = YAML::load_file(glossary_path)
+          term = yaml.index({"source_term"=>"user", "target_term"=>"ユーザ", "note"=>""})
+          term.should_not be_nil
+        end
+
+      end
     end
 
     describe '#delete' do
@@ -101,8 +104,8 @@ module Logaling
         end
 
         it 'should delete the bilingual pair' do
-          @result.should include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete_logaling", :target_term=>"てすと2", :note=>"備考"})
-          @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete_logaling", :target_term=>"てすと1", :note=>"備考"})
+          @result.any?{|term| term[:source_term] == "delete_logaling" && term[:target_term] == "てすと2"}.should be_true
+          @result.any?{|term| term[:source_term] == "delete_logaling" && term[:target_term] == "てすと1"}.should be_false
         end
       end
 
@@ -138,7 +141,7 @@ module Logaling
           end
 
           it 'should delete the term' do
-            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user_logaling", :target_term=>"ユーザ", :note=>"備考"})
+            @result.any?{|term| term[:source_term] == "user_logaling" && term[:target_term] == "ユーザ"}.should be_false
           end
         end
 
@@ -158,8 +161,8 @@ module Logaling
           }
 
           it "should delete terms when force option is true" do
-            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete_loglaing", :target_term=>"てすと1", :note=>"備考"})
-            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete_logaling", :target_term=>"てすと2", :note=>"備考"})
+            @result.any?{|term| term[:source_term] == "delete_logaling" && term[:target_term] == "てすと1"}.should be_false
+            @result.any?{|term| term[:source_term] == "delete_logaling" && term[:target_term] == "てすと2"}.should be_false
           end
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logaling-command
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-20 00:00:00.000000000Z
+date: 2012-01-30 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2158772960 !ruby/object:Gem::Requirement
+  requirement: &2153162840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: 0.14.6
   type: :runtime
   prerelease: false
-  version_requirements: *2158772960
+  version_requirements: *2153162840
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2158771780 !ruby/object:Gem::Requirement
+  requirement: &2153162000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158771780
+  version_requirements: *2153162000
 - !ruby/object:Gem::Dependency
   name: rroonga
-  requirement: &2158770780 !ruby/object:Gem::Requirement
+  requirement: &2153155300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,10 +47,10 @@ dependencies:
         version: 1.3.0
   type: :runtime
   prerelease: false
-  version_requirements: *2158770780
+  version_requirements: *2153155300
 - !ruby/object:Gem::Dependency
   name: rainbow
-  requirement: &2158769700 !ruby/object:Gem::Requirement
+  requirement: &2153154740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -58,10 +58,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158769700
+  version_requirements: *2153154740
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &2158768880 !ruby/object:Gem::Requirement
+  requirement: &2153153780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -69,10 +69,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158768880
+  version_requirements: *2153153780
 - !ruby/object:Gem::Dependency
   name: active_support
-  requirement: &2158768160 !ruby/object:Gem::Requirement
+  requirement: &2153152800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -80,10 +80,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158768160
+  version_requirements: *2153152800
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2158767380 !ruby/object:Gem::Requirement
+  requirement: &2153151540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -91,10 +91,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2158767380
+  version_requirements: *2153151540
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2158766720 !ruby/object:Gem::Requirement
+  requirement: &2153150900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -102,7 +102,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2158766720
+  version_requirements: *2153150900
 description: A command line interface for logaling.
 email:
 - koji.shimada@enishi-tech.com
@@ -117,6 +117,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- CHANGES
 - COPYING
 - Gemfile
 - README.md
@@ -125,6 +126,8 @@ files:
 - lib/logaling.rb
 - lib/logaling/command.rb
 - lib/logaling/external_glossaries/debian_project.rb
+- lib/logaling/external_glossaries/edict.rb
+- lib/logaling/external_glossaries/gene95.rb
 - lib/logaling/external_glossaries/gnome_project.rb
 - lib/logaling/external_glossaries/postgresql_manual.rb
 - lib/logaling/external_glossary.rb