logaling-command 0.0.2 → 0.0.3

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+*.*.swp

data/lib/logaling/command.rb

@@ -2,57 +2,90 @@
 
 require 'thor'
 require "logaling/glossary"
-require "logaling/glossary_db"
 
 class Logaling::Command < Thor
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
+  LOGALING_CONFIG = '.logaling'
 
   map '-c' => :create,
       '-a' => :add,
       '-d' => :delete,
       '-u' => :update,
-      '-l' => :lookup
+      '-l' => :lookup,
+      '-n' => :new,
+      '-L' => :link
 
   class_option "glossary",        type: :string, aliases: "-g"
   class_option "source-language", type: :string, aliases: "-S"
   class_option "target-language", type: :string, aliases: "-T"
   class_option "logaling-home",   type: :string, required: false, aliases: "-h"
 
+  desc 'new [PROJECT NAME] [SOURCE LANGUAGE] [TARGET LANGUAGE(optional)]', 'Create .logaling'
+  def new(project_name, source_language, target_language=nil)
+    unless File.exist?(LOGALING_CONFIG)
+      FileUtils.mkdir_p(File.join(LOGALING_CONFIG, "glossary"))
+      File.open(File.join(LOGALING_CONFIG, "config"), 'w') do |config|
+        config.puts "--glossary #{project_name}"
+        config.puts "--source-language #{source_language}"
+        config.puts "--target-language #{target_language}" if target_language
+      end
+      say "Successfully created #{LOGALING_CONFIG}"
+    else
+      say "#{LOGALING_CONFIG} is already exists."
+    end
+  end
+
+  desc 'link', 'Link .logaling'
+  def link
+    logaling_path = find_dotfile
+    if logaling_path
+      logaling_projects_path = File.join(LOGALING_HOME, "projects")
+      FileUtils.mkdir_p(logaling_projects_path) unless File.exist?(logaling_projects_path)
+
+      config = load_config
+      symlink_path = File.join(logaling_projects_path, config["glossary"])
+      unless File.exists?(symlink_path)
+        FileUtils.ln_s(logaling_path, symlink_path)
+        say "Your project is now linked to #{symlink_path}."
+      else
+        say "#{options["glossary"]} is already linked."
+      end
+    else
+      say "Try 'loga new' first."
+    end
+  end
+
   desc 'create', 'Create glossary.'
   def create
-    load_config
     glossary.create
   rescue Logaling::CommandFailed => e
     error(e.message)
   end
 
-  desc 'add [source term] [target term] [note]', 'Add term to glossary.'
+  desc 'add [SOURCE TERM] [TARGET TERM] [NOTE(optional)]', 'Add term to glossary.'
   def add(source_term, target_term, note='')
-    load_config
     glossary.add(source_term, target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     error(e.message)
   end
 
-  desc 'delete [source term] [target term]', 'Delete term.'
+  desc 'delete [SOURCE TERM] [TARGET TERM]', 'Delete term.'
   def delete(source_term, target_term)
-    load_config
     glossary.delete(source_term, target_term)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     error(e.message)
   end
 
-  desc 'update [source term] [target term] [new_target_term], [note]', 'Update term.'
+  desc 'update [SOURCE TERM] [TARGET TERM] [NEW TARGET TERM], [NOTE(optional)]', 'Update term.'
   def update(source_term, target_term, new_target_term, note='')
-    load_config
     glossary.update(source_term, target_term, new_target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     error(e.message)
   end
 
-  desc 'lookup [source term]', 'Lookup terms.'
+  desc 'lookup [TERM]', 'Lookup terms.'
   def lookup(source_term)
-    load_config
+    index
     glossary.lookup(source_term)
   rescue Logaling::CommandFailed, Logaling::TermError => e
     error(e.message)
@@ -60,30 +93,25 @@ class Logaling::Command < Thor
 
   desc 'index', 'Index glossaries to groonga DB.'
   def index
-    load_config
-    home = find_option("logaling-home") || LOGALING_HOME
-    db_home = File.join(home, ".logadb")
-    glossarydb = Logaling::GlossaryDB.new
-    glossarydb.open(db_home, "utf8") do |db|
-      db.recreate_table(db_home)
-      db.load_glossaries(home)
-    end
+    glossary.index
+  rescue Logaling::CommandFailed, Logaling::TermError => e
+    error(e.message)
   end
 
   private
   def glossary
-    glossary = find_option("glossary")
+    config = load_config
+
+    glossary = options["glossary"] || config["glossary"]
     raise(Logaling::CommandFailed, "input glossary name '-g <glossary name>'") unless glossary
 
-    source_language = find_option("source-language")
+    source_language = options["source-language"] || config["source-language"]
     raise(Logaling::CommandFailed, "input source-language code '-S <source-language code>'") unless source_language
 
-    target_language = find_option("target-language")
+    target_language = options["target-language"] || config["target-language"]
     raise(Logaling::CommandFailed, "input target-language code '-T <target-language code>'") unless target_language
 
-    logaling_home = find_option("logaling-home")
-
-    Logaling::Glossary.new(glossary, source_language, target_language, logaling_home)
+    Logaling::Glossary.new(glossary, source_language, target_language)
   end
 
   def error(msg)
@@ -91,20 +119,16 @@ class Logaling::Command < Thor
     exit 1
   end
 
-  def find_option(key)
-    options[key] || @dot_options[key]
-  end
-
   def load_config
-    @dot_options ||= {}
+    config ||= {}
     if path = find_dotfile
-      tmp_options = File.readlines(path).map {|l| l.chomp.split " "}
-      tmp_options.each do |option|
+      File.readlines(File.join(path, 'config')).map{|l| l.chomp.split " "}.each do |option|
         key = option[0].sub(/^[\-]{2}/, "")
         value = option[1]
-        @dot_options[key] = value
+        config[key] = value
       end
     end
+    config
   end
 
   def find_dotfile

data/lib/logaling/glossary.rb

@@ -1,29 +1,21 @@
 # -*- coding: utf-8 -*-
-#require "logaling-command/version"
-
 require 'psych'
 require "yaml"
 require "fileutils"
+require "logaling/glossary_db"
 
 module Logaling
   class Glossary
-    def self.build_path(glossary, source_language, target_language, logaling_home)
-      dir, file = File::split(glossary)
-      if dir == "."
-        fname = [glossary, source_language, target_language].join(".")
-        return File.join(logaling_home, "#{fname}.yml")
-      else
-        return glossary
-      end
+    def self.build_path(glossary, source_language, target_language)
+      fname = [glossary, source_language, target_language].join(".")
+      File.join(LOGALING_HOME, "projects", glossary, "glossary", "#{fname}.yml")
     end
 
-    def initialize(glossary, source_language, target_language, logaling_home)
-      logaling_home ||= LOGALING_HOME
-      @path = Glossary.build_path(glossary, source_language, target_language, logaling_home)
+    def initialize(glossary, source_language, target_language)
+      @path = Glossary.build_path(glossary, source_language, target_language)
       @glossary = glossary
       @source_language = source_language
       @target_language = target_language
-      @logaling_home = logaling_home
     end
 
     def create
@@ -81,7 +73,7 @@ module Logaling
       check_glossary_exists
 
       glossarydb = Logaling::GlossaryDB.new
-      glossarydb.open(logaling_db_home, "utf8") do |db|
+      glossarydb.open(File.join(LOGALING_HOME, "db"), "utf8") do |db|
         glossaries = db.lookup(source_term)
         glossaries.reject! do |term|
           term[:source_language] != @source_language || term[:target_language] != @target_language
@@ -104,13 +96,25 @@ module Logaling
       end
     end
 
+    def index
+      projects = Dir.glob(File.join(LOGALING_HOME, "projects", "*"))
+      db_home = File.join(LOGALING_HOME, "db")
+      glossarydb = Logaling::GlossaryDB.new
+      glossarydb.open(db_home, "utf8") do |db|
+        db.recreate_table(db_home)
+        projects.each do |project|
+          db.load_glossaries(File.join(project, "glossary"))
+        end
+      end
+    end
+
     private
     def load_glossary_yml
       YAML::load_file(@path) || []
     end
 
     def logaling_db_home
-      File.join(@logaling_home, ".logadb")
+      File.join(LOGALING_HOME, "db")
     end
 
     def build_term(source_term, target_term, note)
@@ -134,16 +138,20 @@ module Logaling
       target_terms(source_term).any?{|data| data['target_term'] == target_term }
     end
 
-    def exist?
-      File.exists?(@path)
+    def check_glossarydir_unexists
+      unless File.exists?(File.dirname(@path))
+        raise CommandFailed, "glossary path #{File.dirname(@path)} not found"
+      end
     end
 
     def check_glossary_unexists
-      raise CommandFailed, "glossary #{@path} already exists" if exist?
+      check_glossarydir_unexists
+      raise CommandFailed, "glossary #{@path} already exists" if File.exists?(@path)
     end
 
     def check_glossary_exists
-      raise CommandFailed, "glossary #{@path} not found" unless exist?
+      check_glossarydir_unexists
+      FileUtils.touch(@path) unless File.exists?(@path)
     end
 
     def target_terms(source_term, path=@path)
@@ -155,15 +163,6 @@ module Logaling
       target_terms
     end
 
-    def lookup_files
-      file_list = Dir.glob("#{@logaling_home}/*.#{@source_language}.#{@target_language}.yml")
-      if glossary_index = file_list.index(@path)
-        file_list.delete_at(glossary_index)
-      end
-      file_list.unshift(@path)
-      return file_list
-    end
-
     def dump_glossary(glossary)
       File.open(@path, "w") do |f|
         f.puts(glossary.to_yaml)

data/lib/logaling/glossary_db.rb

@@ -4,10 +4,11 @@ require 'psych'
 require "yaml"
 require "fileutils"
 require 'groonga'
+require 'csv'
 
 module Logaling
   class GlossaryDB
-    def initialize()
+    def initialize
       @database = nil
     end
 
@@ -46,11 +47,35 @@ module Logaling
       @database.nil? or @database.closed?
     end
 
+    def get_file_list(path, types)
+      glob_list = []
+      types.each do |type|
+        glob_list << File.join(path, "*.#{type}")
+      end
+      Dir.glob(glob_list)
+    end
+
+    def load_glossary(file)
+      case extname = File.extname(file)
+      when ".tsv", ".csv"
+        sep = extname == ".tsv" ? "\t" : ","
+        glossary = []
+        CSV.open(file, "r",  {: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
+      when ".yml"
+        YAML::load_file(file)
+      end
+    end
+
     def load_glossaries(path)
-      file_list = Dir.glob("#{path}/*.yml")
+      file_list = get_file_list(path, ["yml", "tsv", "csv"])
       file_list.each do |file|
-        name, source_language, target_language = File::basename(file, "yml").split(".")
-        glossary = YAML::load_file(file)
+        name, source_language, target_language = File::basename(file, ".*").split(".")
+        glossary = load_glossary(file)
         next if !glossary
         glossary.each do |term|
           source_term = term['source_term']

data/spec/logaling/command_spec.rb

@@ -4,18 +4,20 @@ require File.join(File.dirname(__FILE__), "..", "spec_helper")
 describe Logaling::Command do
   let(:base_options) { {"glossary"=>"spec", "source-language"=>"en", "target-language"=>"ja"} }
   let(:command) { Logaling::Command.new([], base_options) }
-  let(:glossary_path) { File.join(LOGALING_HOME, "/spec.en.ja.yml") }
+  let(:project) { "spec" }
+  let(:glossary_path) { Logaling::Glossary.build_path(project, 'en', 'ja') }
 
   before do
-    FileUtils.remove_file(glossary_path, true)
+    FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+    FileUtils.mkdir_p(File.dirname(glossary_path))
   end
 
   describe '#create' do
-    context 'with arguments show non-existent glossary' do
-      before do
-        command.create
-      end
+    before do
+      FileUtils.touch(glossary_path)
+    end
 
+    context 'with arguments show non-existent glossary' do
       it "glossary yaml should be newly created" do
         File.exists?(glossary_path).should be_true
       end
@@ -23,10 +25,6 @@ describe Logaling::Command do
   end
 
   describe '#add' do
-    before do
-      command.create
-    end
-
     context 'with arguments have only bilingual pair' do
       before do
         command.add("spec", "テスト")
@@ -41,7 +39,7 @@ describe Logaling::Command do
       it "term should note have note" do
         subject["note"].should == ""
       end
-   end
+    end
 
     context 'with arguments have bilingual pair and note' do
       before do
@@ -62,7 +60,6 @@ describe Logaling::Command do
 
   describe "#update" do
     before do
-      command.create
       command.add("spec", "テスト", "備考")
     end
 
@@ -95,7 +92,62 @@ describe Logaling::Command do
     end
   end
 
+  describe '#index' do
+    before do
+      command.add("spec", "スペック", "備考")
+      command.index
+    end
+
+    context 'glossary files exist in some project' do
+      db_home = File.join(LOGALING_HOME, "db")
+      db = Logaling::GlossaryDB.new
+
+      subject { db.open(db_home, "utf8"){|db| records = db.lookup("spec")} }
+
+      it 'glossaries should be indexed' do
+        subject.should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"spec", :target_term=>"スペック", :note=>"備考"}]
+      end
+    end
+  end
+
+  describe '#lookup' do
+    let(:base_options2) { {"glossary"=>"spec2", "source-language"=>"en", "target-language"=>"ja"} }
+    let(:command2) { Logaling::Command.new([], base_options2) }
+    let(:project2) { "spec2" }
+    let(:glossary_path2) { Logaling::Glossary.build_path(project2, 'en', 'ja') }
+
+    context 'with arguments exist term' do
+      before do
+        command.add("spec", "スペック", "備考")
+        FileUtils.mkdir_p(File.dirname(glossary_path2))
+        command2.add("spec", "スペック")
+      end
+
+      it 'succeed at find by term without command.index' do
+        stdout = capture(:stdout) {command.lookup("spec")}
+        stdout.should == <<-EOM
+
+lookup word : spec
+
+  spec
+  スペック
+    note:備考
+    glossary:spec
+
+  spec
+  スペック
+    note:
+    glossary:spec2
+        EOM
+      end
+
+      after do
+        FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec2'), true)
+      end
+    end
+  end
+
   after do
-    FileUtils.remove_file(glossary_path, true)
+    FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
   end
 end

data/spec/logaling/glossary_db_spec.rb

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Logaling::GlossaryDB do
+  let(:glossary_path) { Logaling::Glossary.build_path('spec', 'en', 'ja') }
+  let(:tsv_path) { File.join(File.dirname(glossary_path), 'spec.en.ja.tsv') }
+  let(:csv_path) { File.join(File.dirname(glossary_path), 'spec.en.ja.csv') }
+  let(:glossary_db) { Logaling::GlossaryDB.new }
+
+  before do
+    FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+    FileUtils.mkdir_p(File.dirname(glossary_path))
+  end
+
+  describe '#get_file_list' do
+    context 'when specified file not exist' do
+      subject { glossary_db.get_file_list(File.dirname(glossary_path), ['yml', 'csv', 'tsv']) }
+      it 'should return empty array' do
+        should == []
+      end
+    end
+
+    context 'when specified file exists' do
+      before do
+        FileUtils.touch(glossary_path)
+        FileUtils.touch(tsv_path)
+        FileUtils.touch(csv_path)
+      end
+
+      subject { glossary_db.get_file_list(File.dirname(glossary_path), ['yml', 'csv', 'tsv']) }
+      it 'should return file list' do
+        should == [glossary_path, csv_path, tsv_path]
+      end
+
+      after do
+        FileUtils.remove_entry_secure(glossary_path, true)
+        FileUtils.remove_entry_secure(tsv_path, true)
+        FileUtils.remove_entry_secure(csv_path, true)
+      end
+    end
+  end
+
+  describe '#load_glossary' do
+    context 'with argument yml' do
+      before do
+        FileUtils.touch(glossary_path)
+        term = [{'source_term' => 'spec', 'target_term' => 'スペック', 'note' => 'スペック'}]
+        File.open(glossary_path, "w"){|f| f.puts(term.to_yaml)}
+      end
+
+      subject { glossary_db.load_glossary(glossary_path) }
+
+      it 'should return formatted glossary' do
+        should == [{'source_term' => 'spec', 'target_term' => 'スペック', 'note' => 'スペック'}]
+      end
+
+      after do
+        FileUtils.remove_entry_secure(glossary_path, true)
+      end
+    end
+
+    context 'with argument tsv' do
+      before do
+        FileUtils.touch(tsv_path)
+        term = "spec\tスペック"
+        File.open(tsv_path, "w"){|f| f.puts(term)}
+      end
+
+      subject { glossary_db.load_glossary(tsv_path) }
+
+      it 'should return formatted glossary' do
+        should == [{'source_term' => 'spec', 'target_term' => 'スペック', 'note' => ''}]
+      end
+
+      after do
+        FileUtils.remove_entry_secure(tsv_path, true)
+      end
+    end
+
+    context 'with argument csv' do
+      before do
+        FileUtils.touch(csv_path)
+        term = "spec,スペック,備考\ntest\n"
+        File.open(csv_path, "w"){|f| f.puts(term)}
+      end
+
+      subject { glossary_db.load_glossary(csv_path) }
+
+      it 'should return formatted glossary' do
+        should == [{'source_term' => 'spec', 'target_term' => 'スペック', 'note' => ''}]
+      end
+
+      after do
+        FileUtils.remove_entry_secure(csv_path, true)
+      end
+    end
+  end
+
+  after do
+    FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+  end
+end
+

data/spec/logaling/glossary_spec.rb

@@ -4,15 +4,39 @@ require "fileutils"
 
 module Logaling
   describe Glossary do
-    let(:glossary) { Glossary.new('spec', 'en', 'ja', Dir.pwd) }
-    let(:glossary_path) { File.join(Dir.pwd, 'spec.en.ja.yml') }
+    let(:project) { "spec" }
+    let(:glossary) { Glossary.new(project, 'en', 'ja') }
+    let(:glossary_path) { Glossary.build_path(project, 'en', 'ja') }
 
-    describe '#add' do
-      before do
-        FileUtils.remove_file(glossary_path, true)
-        glossary.create
+    before do
+      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+      FileUtils.mkdir_p(File.dirname(glossary_path))
+    end
+
+    describe '#create' do
+      context 'when glossary already exists' do
+        before do
+          FileUtils.touch(glossary_path)
+        end
+
+        it {
+          -> { glossary.create }.should raise_error(Logaling::CommandFailed)
+        }
+      end
+
+      context 'newly create' do
+        before do
+          glossary.create
+        end
+
+        # <glossary name>.source-language.target_language.yml というファイル名で用語集が作成されること
+        it 'specified glossary should has created' do
+          File.exists?(glossary_path).should be_true
+        end
       end
+    end
 
+    describe '#add' do
       context 'with arguments show new bilingual pair' do
         before do
           glossary.add("spec", "スペック", "テストスペック")
@@ -35,15 +59,31 @@ module Logaling
         }
       end
 
-      after do
-        FileUtils.remove_file(glossary_path, true)
+      context "when the glossary not found" do
+        before do
+          glossary.add("test", "テスト", "テスト")
+        end
+
+        it "should create the glossary and add term" do
+          yaml = YAML::load_file(glossary_path)
+          term = yaml.index({"source_term"=>"test", "target_term"=>"テスト", "note"=>"テスト"})
+          term.should_not be_nil
+        end
+      end
+
+      context "when the glossary dir not found" do
+        before do
+          FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+        end
+
+        it {
+          -> { glossary.add("test", "テスト", "テスト") }.should raise_error(Logaling::CommandFailed)
+        }
       end
     end
 
     describe '#update' do
       before do
-        FileUtils.remove_file(glossary_path, true)
-        glossary.create
         glossary.add("user", "ユーザ", "ユーザーではない")
       end
 
@@ -64,16 +104,10 @@ module Logaling
           -> { glossary.update("user", "ユー", "ユーザー", "やっぱりユーザー") }.should raise_error(Logaling::TermError)
         }
       end
-
-      after do
-        FileUtils.remove_file(glossary_path, true)
-      end
     end
 
     describe '#delete' do
       before do
-        FileUtils.remove_file(glossary_path, true)
-        glossary.create
         glossary.add("user", "ユーザ", "ユーザーではない")
       end
 
@@ -82,35 +116,130 @@ module Logaling
           -> { glossary.delete("user", "ユーザー") }.should raise_error(Logaling::TermError)
         }
       end
-
-      after do
-        FileUtils.remove_file(glossary_path, true)
-      end
     end
 
     describe '#lookup' do
       before do
-        FileUtils.remove_file(glossary_path, true)
-        glossary.create
         glossary.add("user", "ユーザ", "ユーザーではない")
+      end
 
-        db_home = File.join(LOGALING_HOME, ".logadb")
-        glossarydb = Logaling::GlossaryDB.new
-        glossarydb.open(db_home, "utf8") do |db|
-          db.recreate_table(db_home)
-          db.load_glossaries(LOGALING_HOME)
+      context 'with arguments show existing bilingual pair' do
+        it 'succeed at find by term' do
+          glossary.index
+          stdout = capture(:stdout) {glossary.lookup("user")}
+          stdout.should == <<-EOM
+
+lookup word : user
+
+  user
+  ユーザ
+    note:ユーザーではない
+    glossary:spec
+          EOM
         end
       end
 
-      context 'with arguments show not existing bilingual pair' do
-        it {
-          -> { glossary.delete("user", "ユーザー") }.should raise_error(Logaling::TermError)
-        }
+      context 'when tsv file as glossary exists' do
+        let(:tsv_path) { File.join(File.dirname(glossary_path), "spec.en.ja.tsv") }
+
+        before do
+          FileUtils.mkdir_p(File.dirname(glossary_path))
+          FileUtils.touch(tsv_path)
+          File.open(tsv_path, "w"){|f| f.puts "user\tユーザー"}
+          glossary.index
+        end
+
+        it 'succeed at find by term' do
+          glossary.index
+          stdout = capture(:stdout) {glossary.lookup("user")}
+          stdout.should == <<-EOM
+
+lookup word : user
+
+  user
+  ユーザ
+    note:ユーザーではない
+    glossary:spec
+
+  user
+  ユーザー
+    note:
+    glossary:spec
+          EOM
+        end
+
+        after do
+          FileUtils.remove_entry_secure(tsv_path, true)
+        end
       end
+    end
+
+    describe '#index' do
+      let(:db_home) { File.join(LOGALING_HOME, "db") }
+      let(:logaling_db) { Logaling::GlossaryDB.new }
+      let(:tsv_path) { File.join(File.dirname(glossary_path), "spec.en.ja.tsv") }
+      let(:csv_path) { File.join(File.dirname(glossary_path), "spec.en.ja.csv") }
+
+      context 'when yml file as glossary exists' do
+        before do
+          FileUtils.mkdir_p(File.dirname(glossary_path))
+          FileUtils.touch(glossary_path)
+          glossary.add("spec", "スペック", "備考")
+          glossary.index
+        end
 
-      after do
-        FileUtils.remove_file(glossary_path, true)
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("spec")} }
+
+        it 'glossaries should be indexed' do
+          subject.should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"spec", :target_term=>"スペック", :note=>"備考"}]
+        end
+
+        after do
+          FileUtils.remove_entry_secure(glossary_path, true)
+        end
       end
+
+      context 'when tsv file as glossary exists' do
+        before do
+          FileUtils.mkdir_p(File.dirname(glossary_path))
+          FileUtils.touch(tsv_path)
+          File.open(tsv_path, "w"){|f| f.puts "user\tユーザ"}
+          glossary.index
+        end
+
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("user")} }
+
+        it 'glossaries should be indexed' do
+          subject.should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>nil}]
+        end
+
+        after do
+          FileUtils.remove_entry_secure(tsv_path, true)
+        end
+      end
+
+      context 'when csv file as glosary exists' do
+        before do
+          FileUtils.mkdir_p(File.dirname(glossary_path))
+          FileUtils.touch(csv_path)
+          File.open(csv_path, "w"){|f| f.puts "test,テスト"}
+          glossary.index
+        end
+
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("test")} }
+
+        it 'glossaries should be indexed' do
+          subject.should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"test", :target_term=>"テスト", :note=>nil}]
+        end
+
+        after do
+          FileUtils.remove_entry_secure(csv_path, true)
+        end
+      end
+    end
+
+    after do
+      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logaling-command
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-16 00:00:00.000000000Z
+date: 2011-11-22 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2152051920 !ruby/object:Gem::Requirement
+  requirement: &2154516840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: 0.14.6
   type: :runtime
   prerelease: false
-  version_requirements: *2152051920
+  version_requirements: *2154516840
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2152050600 !ruby/object:Gem::Requirement
+  requirement: &2154515940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152050600
+  version_requirements: *2154515940
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152049620 !ruby/object:Gem::Requirement
+  requirement: &2154515340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,10 +47,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152049620
+  version_requirements: *2154515340
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152047900 !ruby/object:Gem::Requirement
+  requirement: &2154514760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -58,7 +58,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152047900
+  version_requirements: *2154514760
 description: A command line interface for logaling.
 email:
 - koji.shimada@enishi-tech.com
@@ -82,6 +82,7 @@ files:
 - lib/logaling/glossary_db.rb
 - logaling-command.gemspec
 - spec/logaling/command_spec.rb
+- spec/logaling/glossary_db_spec.rb
 - spec/logaling/glossary_spec.rb
 - spec/spec_helper.rb
 homepage: http://logaling.github.com/
@@ -110,5 +111,6 @@ specification_version: 3
 summary: A command line interface for logaling.
 test_files:
 - spec/logaling/command_spec.rb
+- spec/logaling/glossary_db_spec.rb
 - spec/logaling/glossary_spec.rb
 - spec/spec_helper.rb