logaling-command 0.1.5 → 0.1.6

data/lib/logaling/glossary.rb

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 #
-# Copyright (C) 2011  Miho SUZUKI
+# Copyright (C) 2012  Miho SUZUKI
 #
 # 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
@@ -14,159 +14,95 @@
 #
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-begin
-  require 'psych'
-rescue LoadError => e
-  raise LoadError unless e.message =~ /psych/
-  puts "please install psych first."
-end
-require "yaml"
-require "csv"
-require "fileutils"
-
 module Logaling
   class Glossary
-    class << self
-      def load(file)
-        load_glossary(file)
-      end
-
-      def load_glossary(file)
-        case File.extname(file)
-        when ".csv"
-          load_glossary_csv(file)
-        when ".tsv"
-          load_glossary_tsv(file)
-        when ".yml"
-          load_glossary_yml(file)
-        end
-      end
+    SUPPORTED_FILE_TYPE = %w(yml tsv csv)
 
-      def load_glossary_yml(path)
-        YAML::load_file(path) || []
-      end
+    attr_reader :name, :source_language, :target_language
 
-      def load_glossary_tsv(path)
-        load_glossary_csv(path, "\t")
-      end
+    def initialize(name, source_language, target_language, project=nil)
+      @name = name
+      @source_language = source_language
+      @target_language = target_language
+      @project = project
+    end
 
-      def load_glossary_csv(path, sep=",")
-        glossary = []
-        CSV.open(path, "r:utf-8",  {:col_sep => sep}) do |csv|
-          csv.each do |row|
-            glossary << {"source_term" => row[0], "target_term" => row[1], "note" => ""} if row.size >= 2
-          end
-        end
-        glossary
+    def terms
+      raise Logaling::GlossaryDBNotFound unless File.exist?(@project.glossary_db_path)
+      index
+      terms = []
+      Logaling::GlossaryDB.open(@project.glossary_db_path, "utf8") do |db|
+        terms = db.translation_list(self)
       end
+      terms
     end
-    attr_reader :glossary, :source_language, :target_language
 
-    def initialize(glossary, source_language, target_language, logaling_home)
-      @logaling_home = logaling_home
-      @glossary = glossary
-      @source_language = source_language
-      @target_language = target_language
+    def bilingual_pair_exists?(source_term, target_term, note=nil)
+      raise Logaling::GlossaryDBNotFound unless File.exist?(@project.glossary_db_path)
+      index
+      terms = []
+      Logaling::GlossaryDB.open(@project.glossary_db_path, "utf8") do |db|
+        terms = db.get_bilingual_pair(source_term, target_term, @name, note)
+      end
+      !terms.empty?
     end
 
     def add(source_term, target_term, note)
-      FileUtils.touch(source_path) unless File.exist?(source_path)
-
-      glossary = Glossary.load_glossary(source_path)
-      glossary << build_term(source_term, target_term, note)
-      dump_glossary(glossary)
-    rescue
-      raise GlossaryNotFound
+      glossary_source.add(source_term, target_term, note)
     end
 
     def update(source_term, target_term, new_target_term, note)
-      raise GlossaryNotFound unless File.exist?(source_path)
-
-      glossary = Glossary.load_glossary(source_path)
-
-      target_index = find_term_index(glossary, source_term, target_term)
-      if target_index
-        glossary[target_index] = rebuild_term(glossary[target_index], source_term, new_target_term, note)
-        dump_glossary(glossary)
-      else
-        raise TermError, "Can't found term '#{source_term}: #{target_term}' in '#{@glossary}'"
-      end
+      glossary_source.update(source_term, target_term, new_target_term, note)
     end
 
     def delete(source_term, target_term)
-      raise GlossaryNotFound unless File.exist?(source_path)
-
-      glossary = Glossary.load_glossary(source_path)
-      target_index = find_term_index(glossary, source_term, target_term)
-      unless target_index
-        raise TermError, "Can't found term '#{source_term} #{target_term}' in '#{@glossary}'" unless target_index
-      end
-
-      glossary.delete_at(target_index)
-      dump_glossary(glossary)
+      glossary_source.delete(source_term, target_term)
     end
 
     def delete_all(source_term, force=false)
-      raise GlossaryNotFound unless File.exist?(source_path)
-
-      glossary = Glossary.load_glossary(source_path)
-      delete_candidates = target_terms(glossary, source_term)
-      if delete_candidates.empty?
-        raise TermError, "Can't found term '#{source_term} in '#{@glossary}'"
-      end
-
-      if delete_candidates.size == 1 || force
-        glossary.delete_if{|term| term['source_term'] == source_term }
-        dump_glossary(glossary)
-      else
-        raise TermError, "There are duplicate terms in glossary.\n" +
-          "If you really want to delete, please put `loga delete [SOURCE_TERM] --force`\n" +
-          " or `loga delete [SOURCE_TERM] [TARGET_TERM]`"
-      end
+      glossary_source.delete_all(source_term, force)
     end
 
-    def source_path
-      if @source_path
-        @source_path
+    def glossary_source
+      if @glossary_source
+        @glossary_source
       else
-        fname = [@glossary, @source_language, @target_language].join(".")
-        @source_path = File.join(@logaling_home, "projects", @glossary, "glossary", "#{fname}.yml")
+        file_name = [@name, @source_language, @target_language, 'yml'].join('.')
+        source_dir = @project.glossary_source_path
+        FileUtils.mkdir_p(source_dir)
+        source_path = File.join(source_dir, file_name)
+        @glossary_source = Logaling::GlossarySource.create(source_path, self)
       end
     end
 
-    private
-    def build_term(source_term, target_term, note)
-      note ||= ''
-      {'source_term' => source_term, 'target_term' => target_term, 'note' => note}
+    def to_s
+      [@name, @source_language, @target_language].join('.')
     end
 
-    def rebuild_term(current, source_term, target_term, 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
-
-    def find_term_index(glossary, source_term, target_term='')
-      glossary.find_index do |term|
-        if target_term.empty?
-          term['source_term'] == source_term
-        else
-          term['source_term'] == source_term && term['target_term'] == target_term
+    private
+    def index
+      Logaling::GlossaryDB.open(@project.glossary_db_path, "utf8") do |db|
+        db.recreate_table
+        glossary_sources.each do |glossary_source|
+          unless db.glossary_source_exist?(glossary_source)
+            puts "now index #{@name}..."
+            db.index_glossary_source(glossary_source)
+          end
+        end
+        indexed_glossary_sources = db.glossary_sources_related_on_glossary(self)
+        (indexed_glossary_sources - glossary_sources).each do |removed_glossary_source|
+          puts "now deindex #{@name}..."
+          db.deindex_glossary_source(removed_glossary_source)
         end
       end
     end
 
-    def target_terms(glossary, source_term)
-      glossary.select {|term| term['source_term'] == source_term }
-    end
-
-    def dump_glossary(glossary)
-      File.open(source_path, "w") do |f|
-        f.puts(glossary.to_yaml)
+    def glossary_sources
+      glob_condition = SUPPORTED_FILE_TYPE.map do |type|
+        file_name = [self.to_s, type].join('.')
+        File.join(@project.glossary_source_path, file_name)
       end
+      Dir.glob(glob_condition).map {|source_path| GlossarySource.create(source_path, self)}
     end
   end
 end

data/lib/logaling/glossary_db.rb

@@ -49,11 +49,10 @@ module Logaling
     end
 
     def recreate_table
-      version = Groonga["configurations"] ? get_config("version") : 0
-      if version.to_i != VERSION
+      unless latest_version?
         remove_schema
         populate_schema
-        add_config("version", VERSION.to_s)
+        update_version_to_latest
       end
     end
 
@@ -62,41 +61,63 @@ module Logaling
       @database = nil
     end
 
-    def deindex_glossary(glossary_name, glossary_source)
-      delete_translations_by_glossary_source(glossary_source)
-      delete_glossary(glossary_name)
-      delete_glossary_source(glossary_source)
+    def deindex_glossary(glossary, glossary_source)
+      delete_translations_by_glossary_source(glossary_source.source_path)
+      delete_glossary(glossary.name)
+      delete_glossary_source(glossary_source.source_path)
     end
 
-    def index_glossary(glossary, glossary_name, glossary_source, source_language, target_language, indexed_at)
+    def deindex_glossary_source(glossary_source)
+      delete_translations_by_glossary_source(glossary_source.source_path)
+      delete_glossary_source(glossary_source.source_path)
+    end
+
+    def index_glossary_source(glossary_source)
+      delete_terms if offline_index?
+      glossary = glossary_source.glossary
+
+      deindex_glossary_source(glossary_source)
+
+      add_glossary_source(glossary_source)
+      glossary_source.load.each do |term|
+        source_term = term['source_term']
+        target_term = term['target_term']
+        note = term['note']
+        add_translation(glossary.name, glossary_source.source_path, glossary.source_language, glossary.target_language, source_term, target_term, note)
+      end
+
+      create_terms if offline_index?
+    end
+
+    def index_glossary(glossary, glossary_source)
       delete_terms if offline_index?
 
-      deindex_glossary(glossary_name, glossary_source)
+      deindex_glossary(glossary, glossary_source)
 
-      add_glossary_source(glossary_source, indexed_at)
-      add_glossary(glossary_name)
-      glossary.each do |term|
+      add_glossary_source(glossary_source)
+      add_glossary(glossary)
+      glossary_source.load.each do |term|
         source_term = term['source_term']
         target_term = term['target_term']
         note = term['note']
-        add_translation(glossary_name, glossary_source, source_language, target_language, source_term, target_term, note)
+        add_translation(glossary.name, glossary_source.source_path, glossary.source_language, glossary.target_language, source_term, target_term, note)
       end
 
       create_terms if offline_index?
     end
 
-    def lookup(source_term, glossary_source=nil)
+    def lookup(source_term, glossary=nil)
       records_selected = Groonga["translations"].select do |record|
         conditions = [record.source_term =~ source_term]
-        if glossary_source
-          conditions << (record.source_language =~ glossary_source.source_language) if glossary_source.source_language
-          conditions << (record.target_language =~ glossary_source.target_language) if glossary_source.target_language
+        if glossary
+          conditions << (record.source_language =~ glossary.source_language) if glossary.source_language
+          conditions << (record.target_language =~ glossary.target_language) if glossary.target_language
         end
         conditions
       end
-      if glossary_source
+      if glossary
         specified_glossary = records_selected.select do |record|
-          record.glossary == glossary_source.glossary
+          record.glossary == glossary.name
         end
         specified_glossary.each do |record|
           record.key._score += 10
@@ -113,13 +134,8 @@ module Logaling
                  :normalize => true}
       snippet = records_selected.expression.snippet(["<snippet>", "</snippet>"], options)
       struct_result(records, snippet)
-    ensure
-      snippet.close if snippet
-      records_selected.expression.close if records_selected
-      specified_glossary.expression.close if specified_glossary
     end
 
-
     def lookup_dictionary(search_word)
       records_selected_source = Groonga["translations"].select do |record|
         target = record.match_target do |match_record|
@@ -150,74 +166,71 @@ module Logaling
       snippet = records_selected.expression.snippet(["<snippet>", "</snippet>"], options)
 
       struct_result(records, snippet)
-    ensure
-      snippet.close if snippet
-      records_selected.expression.close if records_selected
     end
 
-    def translation_list(glossary_source)
+    def translation_list(glossary, order='ascending')
       records_raw = Groonga["translations"].select do |record|
         [
-          record.glossary == glossary_source.glossary,
-          record.source_language == glossary_source.source_language,
-          record.target_language == glossary_source.target_language
+          record.glossary == glossary.name,
+          record.source_language == glossary.source_language,
+          record.target_language == glossary.target_language
         ]
       end
 
       records = records_raw.sort([
-        {:key=>"source_term", :order=>'ascending'},
-        {:key=>"target_term", :order=>'ascending'}])
+        {:key => "source_term", :order => order},
+        {:key => "target_term", :order => order}
+      ])
 
       struct_result(records)
-    ensure
-      records_raw.expression.close
     end
 
-    def get_bilingual_pair(source_term, target_term, glossary)
+    def get_bilingual_pair(source_term, target_term, glossary, note=nil)
       records = Groonga["translations"].select do |record|
-        [
-          record.glossary == glossary,
-          record.source_term == source_term,
-          record.target_term == target_term
-        ]
-      end
-
-      struct_result(records)
-    ensure
-      records.expression.close
-    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
-        ]
+        if note
+          [
+            record.glossary == glossary,
+            record.source_term == source_term,
+            record.target_term == target_term,
+            record.note == note
+          ]
+        else
+          [
+            record.glossary == glossary,
+            record.source_term == source_term,
+            record.target_term == target_term
+          ]
+        end
       end
-
       struct_result(records)
-    ensure
-      records.expression.close
     end
 
-    def glossary_source_exist?(glossary_source, indexed_at)
+    def glossary_source_exist?(glossary_source)
       glossary = Groonga["glossary_sources"].select do |record|
         [
-          record.key == glossary_source,
-          record.indexed_at == indexed_at
+          record.key == glossary_source.source_path,
+          record.indexed_at == glossary_source.mtime
         ]
       end
       !glossary.size.zero?
-    ensure
-      glossary.expression.close
     end
 
-    def get_all_glossary_source
-      Groonga["glossary_sources"].sort([
+    def get_all_glossary_sources
+      source_paths = Groonga["glossary_sources"].sort([
         {:key=>"_key", :order=>'ascending'}
       ]).map{|record| record.key}
+      source_paths.map do |source_path|
+        glossary_name, source_language, target_language = File.basename(source_path).split(/\./)
+        glossary = Glossary.new(glossary_name, source_language, target_language)
+        GlossarySource.create(source_path, glossary)
+      end
+    end
+
+    def glossary_sources_related_on_glossary(glossary)
+      records = Groonga["glossary_sources"].select do |record|
+        [record.key =~ glossary.to_s]
+      end
+      records.map{|record| GlossarySource.create(record.key.key, glossary) }
     end
 
     def get_all_glossary
@@ -235,12 +248,10 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
-    ensure
-      records.expression.close
     end
 
-    def add_glossary_source(glossary_source, indexed_at)
-      Groonga["glossary_sources"].add(glossary_source, :indexed_at => indexed_at)
+    def add_glossary_source(glossary_source)
+      Groonga["glossary_sources"].add(glossary_source.source_path, :indexed_at => glossary_source.mtime)
     end
 
     def delete_glossary(glossary_name)
@@ -251,12 +262,10 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
-    ensure
-      records.expression.close
     end
 
-    def add_glossary(glossary_name)
-      Groonga["glossaries"].add(glossary_name)
+    def add_glossary(glossary)
+      Groonga["glossaries"].add(glossary.name)
     end
 
     def delete_translations_by_glossary_source(glossary_source)
@@ -267,8 +276,6 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
-    ensure
-      records.expression.close
     end
 
     def delete_terms
@@ -345,11 +352,9 @@ module Logaling
 
     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"]
+        %w(configurations translations glossaries glossary_sources terms).each do |table|
+          schema.remove_table(table) if Groonga[table]
+        end
       end
     end
 
@@ -360,8 +365,8 @@ module Logaling
     def struct_result(records, snippet=nil)
       records.map do |record|
         term = record.key
-        snipped_source_term = snippet ? snip_source_term(term, snippet) : []
-        snipped_target_term = snippet ? snip_target_term(term, snippet) : []
+        snipped_source_term = snippet ? struct_snipped_term(term.source_term, snippet) : []
+        snipped_target_term = snippet ? struct_snipped_term(term.target_term, snippet) : []
         {:glossary_name => term.glossary.key,
          :source_language => term.source_language,
          :target_language => term.target_language,
@@ -387,14 +392,21 @@ module Logaling
       structed_source_term
     end
 
-    def snip_source_term(term, snippet)
-        snipped_text = snippet.execute(term.source_term).join
-        struct_snipped_text(snipped_text)
+    def struct_snipped_term(term, snippet)
+      snipped_text = snippet.execute(term).join
+      snipped_text.empty? ? [term] : struct_snipped_text(snipped_text)
+    end
+
+    def latest_version?
+      current_version == VERSION
+    end
+
+    def current_version
+      Groonga["configurations"] ? get_config("version").to_i : 0
     end
 
-    def snip_target_term(term, snippet)
-        snipped_text = snippet.execute(term.target_term).join
-        struct_snipped_text(snipped_text)
+    def update_version_to_latest
+      add_config("version", VERSION.to_s)
     end
 
     def get_config(conf_key)
@@ -406,8 +418,6 @@ module Logaling
         config.conf_value
       end
       value.size > 0 ? value[0] : ""
-    ensure
-      records.expression.close
     end
 
     def add_config(conf_key, conf_value)

data/lib/logaling/glossary_source.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2011  Miho SUZUKI
+#
+# 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 "logaling/glossary_sources/glossary_yaml_source"
+require "logaling/glossary_sources/glossary_csv_source"
+require "logaling/glossary_sources/glossary_tsv_source"
+
+module Logaling
+  class GlossarySource
+    def self.create(source_path, glossary)
+      case File.extname(source_path)
+      when ".csv"
+        GlossarySources::GlossaryCsvSource.new(source_path, glossary)
+      when ".tsv"
+        GlossarySources::GlossaryTsvSource.new(source_path, glossary)
+      when ".yml"
+        GlossarySources::GlossaryYamlSource.new(source_path, glossary)
+      end
+    end
+  end
+end

data/lib/logaling/glossary_sources/base.rb

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# 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/>.
+
+module Logaling
+  module GlossarySources
+    class Base
+      attr_reader :source_path, :glossary
+
+      def initialize(source_path, glossary)
+        @source_path = source_path
+        @glossary = glossary
+      end
+
+      def eql?(other)
+        return false unless self.class == other.class
+        @source_path == other.source_path
+      end
+
+      def hash
+        @source_path.hash
+      end
+
+      def mtime
+        File.mtime(@source_path)
+      end
+    end
+  end
+end

data/lib/logaling/glossary_sources/glossary_csv_source.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+#
+# 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 "logaling/glossary_sources/base"
+require "csv"
+
+module Logaling::GlossarySources
+  class GlossaryCsvSource < Base
+    def load
+      glossary_source = []
+      CSV.open(source_path, "r:utf-8",  {:col_sep => ','}) do |csv|
+        csv.each do |row|
+          glossary_source << {"source_term" => row[0], "target_term" => row[1], "note" => ""} if row.size >= 2
+        end
+      end
+      glossary_source
+    end
+  end
+end