logaling-command 0.1.5 → 0.1.6

data/lib/logaling/glossary_sources/glossary_tsv_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 GlossaryTsvSource < Base
+    def load
+      glossary_source = []
+      CSV.open(source_path, "r:utf-8",  {:col_sep => "\t"}) do |tsv|
+        tsv.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

data/lib/logaling/glossary_sources/glossary_yaml_source.rb

@@ -0,0 +1,125 @@
+# -*- 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"
+begin
+  require 'psych'
+rescue LoadError => e
+  raise LoadError unless e.message =~ /psych/
+  puts "please install psych first."
+end
+require "yaml"
+require "fileutils"
+
+module Logaling::GlossarySources
+  class GlossaryYamlSource < Base
+    def load
+      YAML::load_file(source_path) || []
+    rescue TypeError
+      []
+    end
+
+    def add(source_term, target_term, note)
+      FileUtils.touch(source_path) unless File.exist?(source_path)
+
+      glossary_source = self.load
+      glossary_source << build_term(source_term, target_term, note)
+      dump_glossary_source(glossary_source)
+    rescue
+      raise Logaling::GlossaryNotFound
+    end
+
+    def update(source_term, target_term, new_target_term, note)
+      raise Logaling::GlossaryNotFound unless File.exist?(source_path)
+
+      glossary_source = self.load
+      target_index = find_term_index(glossary_source, source_term, target_term)
+      if target_index
+        glossary_source[target_index] = rebuild_term(glossary_source[target_index], source_term, new_target_term, note)
+        dump_glossary_source(glossary_source)
+      else
+        raise Logaling::TermError, "Can't found term '#{source_term}: #{target_term}' in '#{@glossary.name}'"
+      end
+    end
+
+    def delete(source_term, target_term)
+      raise Logaling::GlossaryNotFound unless File.exist?(source_path)
+
+      glossary_source = self.load
+      target_index = find_term_index(glossary_source, source_term, target_term)
+      unless target_index
+        raise Logaling::TermError, "Can't found term '#{source_term} #{target_term}' in '#{@glossary.name}'" unless target_index
+      end
+
+      glossary_source.delete_at(target_index)
+      dump_glossary_source(glossary_source)
+    end
+
+    def delete_all(source_term, force=false)
+      raise Logaling::GlossaryNotFound unless File.exist?(source_path)
+
+      glossary_source = self.load
+      delete_candidates = target_terms(glossary_source, source_term)
+      if delete_candidates.empty?
+        raise Logaling::TermError, "Can't found term '#{source_term} in '#{@glossary.name}'"
+      end
+
+      if delete_candidates.size == 1 || force
+        glossary_source.delete_if{|term| term['source_term'] == source_term }
+        dump_glossary_source(glossary_source)
+      else
+        raise Logaling::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
+    end
+
+    private
+    def build_term(source_term, target_term, note)
+      note ||= ''
+      {'source_term' => source_term, 'target_term' => target_term, 'note' => note}
+    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, source_term, target_term='')
+      glossary_source.find_index do |term|
+        if target_term.empty?
+          term['source_term'] == source_term
+        else
+          term['source_term'] == source_term && term['target_term'] == target_term
+        end
+      end
+    end
+
+    def target_terms(glossary_source, source_term)
+      glossary_source.select {|term| term['source_term'] == source_term }
+    end
+
+    def dump_glossary_source(glossary_source)
+      File.open(source_path, "w") do |f|
+        f.puts(glossary_source.to_yaml)
+      end
+    end
+  end
+end

data/lib/logaling/project.rb

@@ -0,0 +1,79 @@
+# 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
+# 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
+  class Project
+    class << self
+      def find_dotfile(base_dir=Dir.pwd)
+        searched_path = []
+        dir = base_dir
+        loop do
+          path = File.join(dir, '.logaling')
+          if File.exist?(path)
+            return path
+          else
+            unless Pathname.new(dir).root?
+              searched_path << dir
+              dir = File.dirname(dir)
+            else
+              raise Logaling::ProjectNotFound, "Can't found .logaling in #{searched_path}"
+            end
+          end
+        end
+      end
+    end
+    attr_reader :path, :repository
+
+    def initialize(path, repository=nil)
+      @path = path
+      @repository = repository
+    end
+
+    def name
+      File.basename(@path)
+    end
+
+    def find_glossary(source_language, target_language)
+      Logaling::Glossary.new(name, source_language, target_language, self)
+    end
+
+    def glossary_source_path
+      File.join(@path, "glossary")
+    end
+
+    def glossary_db_path
+      @repository.logaling_db_home
+    end
+
+    def glossary_sources
+      all_glossary_source_path = Dir.glob(File.join(glossary_source_path, "*"))
+      all_glossary_source_path.map do |source_path|
+        name, source_language, target_language, type = File.basename(source_path).split(/\./)
+        GlossarySource.create(source_path, find_glossary(source_language, target_language))
+      end
+    end
+  end
+
+  class ImportedProject < Project
+    def name
+      File.basename(@path).split(/\./).first
+    end
+
+    def glossary_sources
+      name, source_language, target_language, type = File.basename(@path).split(/\./)
+      [GlossarySource.create(@path, find_glossary(source_language, target_language))]
+    end
+  end
+end

data/lib/logaling/repository.rb

@@ -17,6 +17,7 @@
 
 require "fileutils"
 require "logaling/glossary_db"
+require "logaling/project"
 
 module Logaling
   class Repository
@@ -25,107 +26,90 @@ module Logaling
     end
 
     def register(dot_logaling_path, register_name)
-      FileUtils.mkdir_p(logaling_projects_path) unless File.exist?(logaling_projects_path)
+      FileUtils.mkdir_p(logaling_projects_path)
       symlink_path = File.join(logaling_projects_path, register_name)
       unless File.exist?(symlink_path)
         FileUtils.ln_s(dot_logaling_path, symlink_path)
       else
-        raise GlossaryAlreadyRegistered, register_name
+        raise Logaling::GlossaryAlreadyRegistered, register_name
       end
+    rescue Logaling::GlossaryAlreadyRegistered => e
+      raise e
     rescue
       raise Logaling::CommandFailed, "Failed register #{register_name} to #{logaling_projects_path}."
     end
 
-    def unregister(register_name)
-      symlink_path = File.join(logaling_projects_path, register_name)
-      if File.exist?(symlink_path)
-        FileUtils.remove_entry_secure(symlink_path, true)
-      else
-        raise GlossaryNotFound, register_name
-      end
+    def unregister(project)
+      raise Logaling::ProjectNotFound unless project
+      FileUtils.remove_entry_secure(project.path, true)
     end
 
-    def import(glossary)
-      FileUtils.mkdir_p(cache_path) unless File.exist?(cache_path)
+    def import(glossary_source)
+      FileUtils.mkdir_p(cache_path)
       Dir.chdir(cache_path) do
-        glossary.import
+        glossary_source.import
       end
     rescue
-      raise Logaling::CommandFailed, "Failed import #{glossary.class.name} to #{cache_path}."
+      raise Logaling::CommandFailed, "Failed import #{glossary_source.class.name} to #{cache_path}."
     end
 
-    def import_tmx(glossary, glossary_info)
-      FileUtils.mkdir_p(cache_path) unless File.exist?(cache_path)
+    def import_tmx(glossary_source, glossary, url)
+      FileUtils.mkdir_p(cache_path)
       Dir.chdir(cache_path) do
-        glossary.import(glossary_info)
+        glossary_source.import(glossary, url)
       end
     rescue Logaling::GlossaryNotFound => e
       raise e
     rescue
-      raise Logaling::CommandFailed, "Failed import_tmx #{glossary.class.name} to #{cache_path}."
+      raise Logaling::CommandFailed, "Failed import_tmx #{glossary_source.class.name} to #{cache_path}."
     end
 
-    def lookup(source_term, glossary_source, dictionary=false)
-      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+    def lookup(source_term, glossary, dictionary=false)
+      raise Logaling::GlossaryDBNotFound unless File.exist?(logaling_db_home)
 
       terms = []
       Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
         if dictionary
           terms = db.lookup_dictionary(source_term)
         else
-          terms = db.lookup(source_term, glossary_source)
+          terms = db.lookup(source_term, glossary)
         end
       end
       terms
     end
 
-    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)
+    def projects
+      projects = registered_project_paths.map do |project_path|
+        Logaling::Project.new(project_path, self)
       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
+      projects += imported_glossary_paths.map do |imported_project_path|
+        Logaling::ImportedProject.new(imported_project_path, self)
       end
-      glossaries
+      projects.sort_by(&:path)
     end
 
     def index
-      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
+      all_glossary_sources = projects.map{|project| project.glossary_sources}.flatten
 
       Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
         db.recreate_table
-        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)
+        all_glossary_sources.each do |glossary_source|
+          glossary = glossary_source.glossary
+          unless db.glossary_source_exist?(glossary_source)
+            puts "now index #{glossary.name}..."
+            db.index_glossary(glossary, glossary_source)
           end
         end
-        (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)
+        (db.get_all_glossary_sources - all_glossary_sources).each do |glossary_source|
+          glossary = glossary_source.glossary
+          puts "now deindex #{glossary.name}..."
+          db.deindex_glossary(glossary, glossary_source)
         end
       end
     end
 
     def glossary_counts
-      [registered_projects, imported_glossaries].map(&:size).inject(&:+)
+      [registered_project_paths, imported_glossary_paths].map(&:size).inject(&:+)
     end
 
     def config_path
@@ -133,50 +117,15 @@ module Logaling
       File.exist?(path) ? path : nil
     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 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
-
-    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_sources(path)
-      %w(yml tsv csv).map{|type| File.join(path, "*.#{type}") }
+    def find_project(project_name)
+      project = projects.detect{|project| project.name == project_name}
     end
 
     def logaling_db_home
       File.join(@path, "db")
     end
 
+    private
     def logaling_projects_path
       File.join(@path, "projects")
     end
@@ -185,11 +134,11 @@ module Logaling
       File.join(@path, "cache")
     end
 
-    def registered_projects
+    def registered_project_paths
       Dir[File.join(logaling_projects_path, "*")]
     end
 
-    def imported_glossaries
+    def imported_glossary_paths
       Dir[File.join(cache_path, "*")]
     end
   end

data/lib/logaling.rb

@@ -27,4 +27,5 @@ module Logaling
   class GlossaryDBNotFound < LogalingError; end
   class ExternalGlossaryNotFound < LogalingError; end
   class UnsupportedFormat < LogalingError; end
+  class ProjectNotFound < LogalingError; end
 end

data/logaling-command.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'thor', ['>= 0.14.6']
   s.add_runtime_dependency 'bundler', ['>= 1.0']
-  s.add_runtime_dependency 'rroonga', ['>= 1.3.0']
+  s.add_runtime_dependency 'rroonga', ['>= 2.0.3']
   s.add_runtime_dependency 'rainbow'
   s.add_runtime_dependency 'nokogiri'
   s.add_runtime_dependency 'activesupport'

data/spec/logaling/command_spec.rb

@@ -22,10 +22,10 @@ describe Logaling::Command::Application do
   let(:logaling_config) { File.join(File.dirname(__FILE__), "..", "tmp", ".logaling") }
   let(:base_options) { {"glossary"=>"spec", "source-language"=>"en", "target-language"=>"ja", "logaling-config" => logaling_config} }
   let(:command) { Logaling::Command::Application.new([], base_options) }
-  let(:glossary) { Logaling::Glossary.new('spec', 'en', 'ja', logaling_home) }
-  let(:glossary_path) { glossary.source_path }
   let(:target_project_path) { File.join(logaling_home, "projects", "spec") }
   let(:repository) { Logaling::Repository.new(logaling_home) }
+  let(:glossary) { repository.find_project('spec').find_glossary('en', 'ja') }
+  let(:glossary_source_path) { glossary.glossary_source.source_path }
 
   before do
     FileUtils.rm_rf(File.join(logaling_home, 'projects', 'spec'))
@@ -265,7 +265,7 @@ describe Logaling::Command::Application do
         command.add("spec", "テスト")
       end
 
-      subject { YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }}
+      subject { YAML::load_file(glossary_source_path).find{|h| h["source_term"] == "spec" }}
 
       it "glossary yaml should contain that term" do
         subject["target_term"].should == "テスト"
@@ -282,7 +282,7 @@ describe Logaling::Command::Application do
         command.add("spec", "テスト", "備考")
       end
 
-      subject { YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }}
+      subject { YAML::load_file(glossary_source_path).find{|h| h["source_term"] == "spec" }}
 
       it "glossary yaml should contain that term" do
         subject["target_term"].should == "テスト"
@@ -331,7 +331,7 @@ describe Logaling::Command::Application do
     context "with arguments except note" do
       before do
         command.update("spec", "テスト", "スペック")
-        @yaml = YAML::load_file(glossary_path).find{|h| h["source_term"] == "spec" }
+        @yaml = YAML::load_file(glossary_source_path).find{|h| h["source_term"] == "spec" }
       end
 
       it "term's target_term should be updated" do
@@ -352,7 +352,7 @@ describe Logaling::Command::Application do
     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" }
+        @yaml = YAML::load_file(glossary_source_path).find{|h| h["source_term"] == "spec" }
       end
 
       it "should update note" do
@@ -450,12 +450,12 @@ describe Logaling::Command::Application do
   end
 
   describe "#show" do
-    let(:csv_path) { File.join(File.dirname(glossary_path), "spec.ja.en.csv") }
+    let(:csv_path) { File.join(File.dirname(glossary_source_path), "spec.ja.en.csv") }
     before do
       command.new('spec', 'en', 'ja')
       command.add("spec-test", "スペックてすと", "備考")
 
-      FileUtils.mkdir_p(File.dirname(glossary_path))
+      FileUtils.mkdir_p(File.dirname(glossary_source_path))
       FileUtils.touch(csv_path)
       File.open(csv_path, "w"){|f| f.puts "test_logaling,テストろがりん"}
     end
@@ -496,7 +496,8 @@ describe Logaling::Command::Application do
 
     context 'when a glossary is unregistered' do
       before do
-        repository.unregister('spec')
+        project = repository.find_project('spec')
+        repository.unregister(project)
         command.options = base_options.merge("no-pager" => true)
         @stdout = capture(:stdout) {command.list}
       end

data/spec/logaling/glossary_spec.rb

@@ -20,15 +20,14 @@ require "fileutils"
 
 module Logaling
   describe Glossary do
-    let(:project) { "spec" }
     let(:logaling_home) { @logaling_home }
-    let(:glossary) { Glossary.new(project, 'en', 'ja', logaling_home) }
-    let(:glossary_path) { glossary.source_path }
     let(:repository) { Logaling::Repository.new(logaling_home) }
+    let(:glossary) { repository.find_project('spec').find_glossary('en', 'ja') }
+    let(:glossary_source_path) { glossary.glossary_source.source_path }
 
     before do
       FileUtils.remove_entry_secure(File.join(logaling_home, 'projects', 'spec'), true)
-      FileUtils.mkdir_p(File.dirname(glossary_path))
+      FileUtils.mkdir_p(File.join(logaling_home, 'projects', 'spec'))
     end
 
     describe '#add' do
@@ -38,7 +37,7 @@ module Logaling
         end
 
         it 'glossary yaml should have that bilingual pair' do
-          yaml = YAML::load_file(glossary_path)
+          yaml = YAML::load_file(glossary_source_path)
           term = yaml.index({"source_term"=>"spec", "target_term"=>"スペック", "note"=>"テストスペック"})
           term.should_not be_nil
         end
@@ -50,7 +49,7 @@ module Logaling
         end
 
         it "should create the glossary and add term" do
-          yaml = YAML::load_file(glossary_path)
+          yaml = YAML::load_file(glossary_source_path)
           term = yaml.index({"source_term"=>"test", "target_term"=>"テスト", "note"=>"テスト"})
           term.should_not be_nil
         end
@@ -86,7 +85,7 @@ module Logaling
         end
 
         it 'should clear note' do
-          yaml = YAML::load_file(glossary_path)
+          yaml = YAML::load_file(glossary_source_path)
           term = yaml.index({"source_term"=>"user", "target_term"=>"ユーザ", "note"=>""})
           term.should_not be_nil
         end
@@ -153,7 +152,7 @@ module Logaling
             glossary.add("delete_logaling", "てすと1", "備考")
             glossary.add("delete_logaling", "てすと2", "備考")
             glossary.delete_all("delete_logaling", true)
-            @result = Logaling::Glossary.load_glossary_yml(glossary_path)
+            @result = Logaling::GlossarySource.create(glossary_source_path, glossary).load
           end
 
           it {