logaling-command 0.1.2 → 0.1.3

data/lib/logaling/external_glossaries/mozilla_japan.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+# 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 'nokogiri'
+
+module Logaling
+  class MozillaJapan < ExternalGlossary
+    description     'Mozilla Japan (http://www.mozilla-japan.org/jp/l10n/term/l10n.html)'
+    source_language 'en'
+    target_language 'ja'
+    output_format   'csv'
+
+    private
+    def convert_to_csv(csv)
+      url = 'http://www.mozilla-japan.org/jp/l10n/term/l10n.html'
+      doc = ::Nokogiri::HTML(open(url, "r"))
+      doc.encoding = "UTF-8"
+      doc.search(".obsolete").remove
+      doc.search(".relate").remove
+      doc.css("dl[@class='terminology en-ja']").each do |dl|
+        dl.children.each_slice(2) do |dt, dd|
+          dd.text.split("|").each do |ddt|
+            ddt = ddt.gsub(/\s/, '')
+            unless ddt.empty?
+              csv << [dust_to_tilda(dt.text), dust_to_tilda(ddt)]
+            end
+          end
+        end
+      end
+    end
+
+    def dust_to_tilda(txt)
+      txt.gsub("\xEF\xBF\xBD", "\xE3\x80\x9C")
+    end
+  end
+end

data/lib/logaling/glossary.rb

@@ -15,7 +15,12 @@
 # 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'
+begin
+  require 'psych'
+rescue LoadError => e
+  raise LoadError unless e.message =~ /psych/
+  puts "please install psych first."
+end
 require "yaml"
 require "csv"
 require "fileutils"
@@ -55,32 +60,28 @@ module Logaling
         end
         glossary
       end
-
-      def build_path(glossary, source_language, target_language)
-        fname = [glossary, source_language, target_language].join(".")
-        File.join(LOGALING_HOME, "projects", glossary, "glossary", "#{fname}.yml")
-      end
     end
+    attr_reader :glossary, :source_language, :target_language
 
-    def initialize(glossary, source_language, target_language)
-      @path = Glossary.build_path(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
     end
 
     def add(source_term, target_term, note)
-      FileUtils.touch(@path) unless File.exist?(@path)
+      FileUtils.touch(source_path) unless File.exist?(source_path)
 
-      glossary = Glossary.load_glossary(@path)
+      glossary = Glossary.load_glossary(source_path)
       glossary << build_term(source_term, target_term, note)
       dump_glossary(glossary)
     end
 
     def update(source_term, target_term, new_target_term, note)
-      raise GlossaryNotFound unless File.exist?(@path)
+      raise GlossaryNotFound unless File.exist?(source_path)
 
-      glossary = Glossary.load_glossary(@path)
+      glossary = Glossary.load_glossary(source_path)
 
       target_index = find_term_index(glossary, source_term, target_term)
       if target_index
@@ -92,9 +93,9 @@ module Logaling
     end
 
     def delete(source_term, target_term)
-      raise GlossaryNotFound unless File.exist?(@path)
+      raise GlossaryNotFound unless File.exist?(source_path)
 
-      glossary = Glossary.load_glossary(@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
@@ -105,9 +106,9 @@ module Logaling
     end
 
     def delete_all(source_term, force=false)
-      raise GlossaryNotFound unless File.exist?(@path)
+      raise GlossaryNotFound unless File.exist?(source_path)
 
-      glossary = Glossary.load_glossary(@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}'"
@@ -123,6 +124,15 @@ module Logaling
       end
     end
 
+    def source_path
+      if @source_path
+        @source_path
+      else
+        fname = [@glossary, @source_language, @target_language].join(".")
+        @source_path = File.join(@logaling_home, "projects", @glossary, "glossary", "#{fname}.yml")
+      end
+    end
+
     private
     def build_term(source_term, target_term, note)
       note ||= ''
@@ -152,7 +162,7 @@ module Logaling
     end
 
     def dump_glossary(glossary)
-      File.open(@path, "w") do |f|
+      File.open(source_path, "w") do |f|
         f.puts(glossary.to_yaml)
       end
     end

data/lib/logaling/glossary_db.rb

@@ -81,18 +81,22 @@ module Logaling
       end
     end
 
-    def lookup(source_term, source_language, target_language, glossary)
+    def lookup(source_term, glossary_source=nil)
       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
+        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
+        end
         conditions
       end
-      specified_glossary = records_selected.select do |record|
-        record.glossary == glossary
-      end
-      specified_glossary.each do |record|
-        record.key._score += 10
+      if glossary_source
+        specified_glossary = records_selected.select do |record|
+          record.glossary == glossary_source.glossary
+        end
+        specified_glossary.each do |record|
+          record.key._score += 10
+        end
       end
       records = records_selected.sort([
         {:key=>"_score", :order=>'descending'},
@@ -104,27 +108,55 @@ module Logaling
                  :html_escape => true,
                  :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
 
-      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 || ''}
+
+    def lookup_dictionary(search_word)
+      records_selected_source = Groonga["translations"].select do |record|
+        target = record.match_target do |match_record|
+          match_record.source_term * 2
+        end
+        target =~ search_word
+      end
+      completely_match = records_selected_source.select do |record|
+        record.source_term == search_word
+      end
+      completely_match.each do |record|
+        record.key._score += 10
       end
+
+      records_selected_target = Groonga["translations"].select do |record|
+        record.target_term =~ search_word
+      end
+
+      records_selected = records_selected_target.union!(records_selected_source)
+      records = records_selected.sort([
+        {:key=>"_score", :order=>'descending'},
+        {: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)
+
+      struct_result(records, snippet)
+    ensure
+      snippet.close if snippet
+      records_selected.expression.close if records_selected
     end
 
-    def translation_list(glossary, source_language, target_language)
+    def translation_list(glossary_source)
       records_raw = Groonga["translations"].select do |record|
         [
-          record.glossary == glossary,
-          record.source_language == source_language,
-          record.target_language == target_language
+          record.glossary == glossary_source.glossary,
+          record.source_language == glossary_source.source_language,
+          record.target_language == glossary_source.target_language
         ]
       end
 
@@ -132,16 +164,9 @@ module Logaling
         {:key=>"source_term", :order=>'ascending'},
         {:key=>"target_term", :order=>'ascending'}])
 
-      records.map do |record|
-        term = record.key
-
-        {:glossary_name => term.glossary.key,
-         :source_language => term.source_language,
-         :target_language => term.target_language,
-         :source_term => term.source_term,
-         :target_term => term.target_term,
-         :note => term.note || ''}
-      end
+      struct_result(records)
+    ensure
+      records_raw.expression.close
     end
 
     def get_bilingual_pair(source_term, target_term, glossary)
@@ -153,16 +178,9 @@ module Logaling
         ]
       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
+      struct_result(records)
+    ensure
+      records.expression.close
     end
 
     def get_bilingual_pair_with_note(source_term, target_term, note, glossary)
@@ -175,16 +193,9 @@ module Logaling
         ]
       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
+      struct_result(records)
+    ensure
+      records.expression.close
     end
 
     def glossary_source_exist?(glossary_source, indexed_at)
@@ -195,6 +206,8 @@ module Logaling
         ]
       end
       !glossary.size.zero?
+    ensure
+      glossary.expression.close
     end
 
     def get_all_glossary_source
@@ -218,6 +231,8 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
+    ensure
+      records.expression.close
     end
 
     def add_glossary_source(glossary_source, indexed_at)
@@ -232,6 +247,8 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
+    ensure
+      records.expression.close
     end
 
     def add_glossary(glossary_name)
@@ -246,6 +263,8 @@ module Logaling
       records.each do |record|
         record.key.delete
       end
+    ensure
+      records.expression.close
     end
 
     def add_translation(glossary_name, glossary_source, source_language, target_language, source_term, target_term, note)
@@ -302,6 +321,7 @@ module Logaling
                             :key_normalize => true,
                             :default_tokenizer => "TokenBigram") do |table|
           table.index("translations.source_term")
+          table.index("translations.target_term")
         end
       end
     end
@@ -320,7 +340,24 @@ module Logaling
       @database.nil? or @database.closed?
     end
 
+    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) : []
+        {:glossary_name => term.glossary.key,
+         :source_language => term.source_language,
+         :target_language => term.target_language,
+         :source_term => term.source_term,
+         :snipped_source_term => snipped_source_term,
+         :target_term => term.target_term,
+         :snipped_target_term => snipped_target_term,
+         :note => term.note || ''}
+      end
+    end
+
     def struct_snipped_text(snipped_text)
+      return [] if snipped_text.empty?
       word_list = snipped_text.split(/(<snippet>[^<]*<\/snippet>)/)
       structed_source_term = word_list.map{|word|
         replaced_word = word.sub(/<snippet>([^<]*)<\/snippet>/){|match| $1}
@@ -333,6 +370,16 @@ 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)
+    end
+
+    def snip_target_term(term, snippet)
+        snipped_text = snippet.execute(term.target_term).join
+        struct_snipped_text(snipped_text)
+    end
+
     def get_config(conf_key)
       records = Groonga["configurations"].select do |record|
         record.conf_key == conf_key
@@ -342,6 +389,8 @@ 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/repository.rb

@@ -50,22 +50,26 @@ module Logaling
       end
     end
 
-    def lookup(source_term, source_language, target_language, glossary)
+    def lookup(source_term, glossary_source, dictionary=false)
       raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
 
       terms = []
       Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
-        terms = db.lookup(source_term, source_language, target_language, glossary)
+        if dictionary
+          terms = db.lookup_dictionary(source_term)
+        else
+          terms = db.lookup(source_term, glossary_source)
+        end
       end
       terms
     end
 
-    def show_glossary(glossary, source_language, target_language)
+    def show_glossary(glossary_source)
       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)
+        terms = db.translation_list(glossary_source)
       end
       terms
     end

data/logaling-command.gemspec

@@ -1,4 +1,4 @@
-# -*- encoding: utf-8 -*-
+# -*- coding: utf-8 -*-
 #
 #    Copyright (C) 2011  Miho SUZUKI
 #
@@ -16,7 +16,7 @@
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 $:.push File.expand_path("../lib", __FILE__)
-require "logaling/command"
+require "logaling/command/version"
 
 Gem::Specification.new do |s|
   s.name        = "logaling-command"
@@ -41,7 +41,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'rroonga', ['>= 1.3.0']
   s.add_runtime_dependency 'rainbow'
   s.add_runtime_dependency 'nokogiri'
-  s.add_runtime_dependency 'active_support'
+  s.add_runtime_dependency 'activesupport'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'