logaling-command 0.0.6 → 0.0.7

data/lib/logaling.rb

@@ -6,6 +6,7 @@ module Logaling
   class LogalingError < RuntimeError; end
   class TermError < LogalingError; end
   class CommandFailed < LogalingError; end
+  class GlossaryAlreadyRegistered < LogalingError; end
   class GlossaryNotFound < LogalingError; end
   class GlossaryDBNotFound < LogalingError; end
 end

data/lib/logaling/command.rb

@@ -1,10 +1,11 @@
 # -*- coding: utf-8 -*-
 
 require 'thor'
+require "logaling/repository"
 require "logaling/glossary"
 
 class Logaling::Command < Thor
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
   LOGALING_CONFIG = '.logaling'
 
   map '-a' => :add,
@@ -41,34 +42,30 @@ class Logaling::Command < Thor
   desc 'register', 'Register .logaling'
   def register
     logaling_path = find_dotfile
-    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 "#{config['glossary']} is now registered to logaling."
-    else
-      say "#{config['glossary']} is already registered."
-    end
+    required_options = {"glossary" => "input glossary name '-g <glossary name>'"}
+    config = load_config_and_merge_options(required_options)
+
+    repository.register(logaling_path, config["glossary"])
+    say "#{config['glossary']} is now registered to logaling."
   rescue Logaling::CommandFailed => e
     say e.message
     say "Try 'loga new' first."
+  rescue Logaling::GlossaryAlreadyRegistered => e
+    say "#{config['glossary']} is already registered."
   end
 
   desc 'unregister', 'Unregister .logaling'
   def unregister
-    logaling_path = find_dotfile
-    config = load_config
-    symlink_path = File.join(logaling_projects_path, config["glossary"])
-    if File.exists?(symlink_path)
-      FileUtils.remove_entry_secure(symlink_path, true)
-      say "#{config['glossary']} is now unregistered."
-    else
-      say "#{config['glossary']} is not yet registered."
-    end
+    required_options = {"glossary" => "input glossary name '-g <glossary name>'"}
+    config = load_config_and_merge_options(required_options)
+
+    repository.unregister(config["glossary"])
+    say "#{config['glossary']} is now unregistered."
   rescue Logaling::CommandFailed => e
     say e.message
+  rescue Logaling::GlossaryNotFound => e
+    say "#{config['glossary']} is not yet registered."
   end
 
   desc 'add [SOURCE TERM] [TARGET TERM] [NOTE(optional)]', 'Add term to glossary.'
@@ -80,8 +77,12 @@ class Logaling::Command < Thor
 
   desc 'delete [SOURCE TERM] [TARGET TERM(optional)] [--force(optional)]', 'Delete term.'
   method_option "force", type: :boolean, default: false
-  def delete(source_term, target_term='')
-    glossary.delete(source_term, target_term, options["force"])
+  def delete(source_term, target_term=nil)
+    if target_term
+      glossary.delete(source_term, target_term)
+    else
+      glossary.delete_all(source_term, options["force"])
+    end
   rescue Logaling::CommandFailed, Logaling::TermError => e
     say e.message
   rescue Logaling::GlossaryNotFound => e
@@ -99,16 +100,16 @@ class Logaling::Command < Thor
 
   desc 'lookup [TERM]', 'Lookup terms.'
   def lookup(source_term)
-    glossary.index
-    terms = glossary.lookup(source_term)
+    config = load_config_and_merge_options
+    repository.index
+    terms = repository.lookup(source_term, config["source_language"], config["target_language"], config["glossary"])
 
     unless terms.empty?
-      is_glossary_name_print = terms.map{|t| t[:name]}.uniq.size > 1 ? true : false
       terms.each do |term|
         str_term = "#{term[:source_term]} : #{term[:target_term]}"
         str_term << " # #{term[:note]}" unless term[:note].empty?
         puts str_term
-        puts "(#{term[:name]})" if is_glossary_name_print
+        puts "(#{term[:name]})" if repository.registered_project_counts > 1
       end
     else
       "source-term <#{source_term}> not found"
@@ -123,23 +124,22 @@ class Logaling::Command < Thor
   end
 
   private
-  def glossary
-    config = load_config
-
-    glossary = options["glossary"] || config["glossary"]
-    raise(Logaling::CommandFailed, "input glossary name '-g <glossary name>'") unless glossary
-
-    source_language = options["source-language"] || config["source-language"]
-    raise(Logaling::CommandFailed, "input source-language code '-S <source-language code>'") unless source_language
-
-    target_language = options["target-language"] || config["target-language"]
-    raise(Logaling::CommandFailed, "input target-language code '-T <target-language code>'") unless target_language
-
-    Logaling::Glossary.new(glossary, source_language, target_language)
+  def repository
+    @repository ||= Logaling::Repository.new(LOGALING_HOME)
   end
 
-  def logaling_projects_path
-    File.join(LOGALING_HOME, "projects")
+  def glossary
+    if @glossary
+      @glossary
+    else
+      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)
+      @glossary = Logaling::Glossary.new(config["glossary"], config["source-language"], config["target-language"])
+    end
   end
 
   def error(msg)
@@ -147,10 +147,29 @@ class Logaling::Command < Thor
     exit 1
   end
 
+  def load_config_and_merge_options(required={})
+    config = load_config
+    config["glossary"] = options["glossary"] ? options["glossary"] : config["glossary"]
+    config["source-language"] = options["source-language"] ? options["source-language"] : config["source-language"]
+    config["target-language"] = options["target-language"] ? options["target-language"] : config["target-language"]
+
+    required.each do |required_option, message|
+      raise(Logaling::CommandFailed, message) unless config[required_option]
+    end
+
+    config
+  end
+
+  def find_config
+    File.join(find_dotfile, 'config')
+  rescue Logaling::CommandFailed
+    repository.config_path
+  end
+
   def load_config
     config ||= {}
-    if path = find_dotfile
-      File.readlines(File.join(path, 'config')).map{|l| l.chomp.split " "}.each do |option|
+    if config_path = find_config
+      File.readlines(config_path).map{|l| l.chomp.split " "}.each do |option|
         key = option[0].sub(/^[\-]{2}/, "")
         value = option[1]
         config[key] = value

data/lib/logaling/glossary.rb

@@ -2,13 +2,47 @@
 require 'psych'
 require "yaml"
 require "fileutils"
-require "logaling/glossary_db"
 
 module Logaling
   class Glossary
-    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")
+    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
+
+      def load_glossary_yml(path)
+        YAML::load_file(path) || []
+      end
+
+      def load_glossary_tsv(path)
+        load_glossary_csv(path, "\t")
+      end
+
+      def load_glossary_csv(path, sep=",")
+        glossary = []
+        CSV.open(path, "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
+      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
 
     def initialize(glossary, source_language, target_language)
@@ -19,9 +53,9 @@ module Logaling
     end
 
     def add(source_term, target_term, note)
-      FileUtils.touch(@path) unless File.exists?(@path)
+      FileUtils.touch(@path) unless File.exist?(@path)
 
-      glossary = load_glossary(@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
@@ -31,9 +65,9 @@ module Logaling
     end
 
     def update(source_term, target_term, new_target_term, note)
-      raise GlossaryNotFound unless File.exists?(@path)
+      raise GlossaryNotFound unless File.exist?(@path)
 
-      glossary = load_glossary(@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
@@ -47,106 +81,39 @@ module Logaling
       end
     end
 
-    def delete(source_term, target_term='', force=false)
-      raise GlossaryNotFound unless File.exists?(@path)
+    def delete(source_term, target_term)
+      raise GlossaryNotFound unless File.exist?(@path)
 
-      glossary = load_glossary(@path)
-      target_num = find_term_num(glossary, source_term)
-      if target_num == 0
-        raise TermError, "Can't found term '#{source_term} #{target_term}' in '#{@glossary}'"
-      elsif !target_term.empty? || target_num == 1
-        target_index = find_term_index(glossary, source_term, target_term)
+      glossary = Glossary.load_glossary(@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
-        glossary.delete_at(target_index)
-        dump_glossary(glossary)
-      else
-        if force
-          while target_index = find_term_index(glossary, source_term) do
-            glossary.delete_at(target_index)
-            dump_glossary(glossary)
-          end
-        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
       end
-    end
-
-    def lookup(source_term)
-      raise GlossaryDBNotFound unless File.exists?(logaling_db_home)
 
-      terms = []
-      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
-        terms = db.lookup(source_term)
-        terms.reject! do |term|
-          term[:source_language] != @source_language || term[:target_language] != @target_language
-        end
-        unless terms.empty?
-          # order by glossary
-          specified = terms.select{|term| term[:name] == @glossary}
-          other = terms.select{|term| term[:name] != @glossary}
-          terms = specified.concat(other)
-        end
-      end
-      terms
-    end
-
-    def index
-      projects = Dir.glob(File.join(LOGALING_HOME, "projects", "*"))
-
-      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
-        db.recreate_table
-        projects.each do |project|
-          get_glossaries(project).each do |glossary, name, source_language, target_language|
-            db.index_glossary(glossary, name, source_language, target_language)
-          end
-        end
-      end
+      glossary.delete_at(target_index)
+      dump_glossary(glossary)
     end
 
-    private
-    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
+    def delete_all(source_term, force=false)
+      raise GlossaryNotFound unless File.exist?(@path)
 
-    def get_glossaries(path)
-      glob_list = %w(yml tsv csv).map{|type| File.join(path, "glossary", "*.#{type}") }
-      Dir.glob(glob_list).map do |file|
-        name, source_language, target_language = File::basename(file, ".*").split(".")
-        [load_glossary(file), name, source_language, target_language]
+      glossary = Glossary.load_glossary(@path)
+      delete_candidates = target_terms(glossary, source_term)
+      if delete_candidates.empty?
+        raise TermError, "Can't found term '#{source_term} in '#{@glossary}'"
       end
-    end
-
-    def load_glossary_yml(path)
-      YAML::load_file(path) || []
-    end
-
-    def load_glossary_tsv(path)
-      load_glossary_csv(path, "\t")
-    end
 
-    def load_glossary_csv(path, sep=",")
-      glossary = []
-      CSV.open(path, "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
+      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
-    end
-
-    def logaling_db_home
-      File.join(LOGALING_HOME, "db")
     end
 
+    private
     def build_term(source_term, target_term, note)
       note ||= ''
       {'source_term' => source_term, 'target_term' => target_term, 'note' => note}
@@ -168,20 +135,12 @@ module Logaling
       end
     end
 
-    def find_term_num(glossary, source_term)
-      glossary.select{|term| term["source_term"] == source_term}.size
-    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)
-      target_terms = []
-      glossary.each do |term|
-        target_terms << term if term['source_term'] == source_term
-      end
-      target_terms
+      glossary.select {|term| term['source_term'] == source_term }
     end
 
     def dump_glossary(glossary)

data/lib/logaling/repository.rb

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+require "fileutils"
+require "logaling/glossary_db"
+
+module Logaling
+  class Repository
+    def initialize(path)
+      @path = path
+    end
+
+    def register(dot_logaling_path, register_name)
+      FileUtils.mkdir_p(logaling_projects_path) unless File.exist?(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
+      end
+    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
+    end
+
+    def lookup(source_term, source_language, target_language, glossary)
+      raise GlossaryDBNotFound unless File.exist?(logaling_db_home)
+
+      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
+      end
+      terms
+    end
+
+    def index
+      projects = Dir.glob(File.join(@path, "projects", "*"))
+
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        db.recreate_table
+        projects.each do |project|
+          get_glossaries(project).each do |glossary, name, source_language, target_language|
+            db.index_glossary(glossary, name, source_language, target_language)
+          end
+        end
+      end
+    end
+
+    def registered_project_counts
+      Dir.entries(logaling_projects_path).reject{|dir| dir.sub(/[\.]+/, '').empty?}.size
+    end
+
+    def config_path
+      path = File.join(@path, "config")
+      File.exist?(path) ? path : nil
+    end
+
+    private
+    def get_glossaries(path)
+      glob_list = %w(yml tsv csv).map{|type| File.join(path, "glossary", "*.#{type}") }
+      Dir.glob(glob_list).map do |file|
+        name, source_language, target_language = File::basename(file, ".*").split(".")
+        [Glossary.load(file), name, source_language, target_language]
+      end
+    end
+
+    def logaling_db_home
+      File.join(@path, "db")
+    end
+
+    def logaling_projects_path
+      File.join(@path, "projects")
+    end
+  end
+end

data/logaling-command.gemspec

@@ -23,4 +23,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rroonga'
 end

data/spec/logaling/command_spec.rb

@@ -105,17 +105,29 @@ describe Logaling::Command do
     end
 
     context "when can not find .logaling" do
-      before(:all) do
+      before do
         FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
-        @stdout = capture(:stdout) {command.unregister}
       end
 
-      it 'should not register nothing' do
-        Dir[File.join(LOGALING_HOME, "projects", "*")].size.should == @project_counts
+      context "and call without option" do
+        before do
+          command.options = base_options.merge("glossary" => nil)
+          @stdout = capture(:stdout) {command.unregister}
+        end
+
+        it "should print message 'input glossary name ...'" do
+          @stdout.should be_include "input glossary name"
+        end
       end
 
-      it "should print message \"Can't found .logaling in [...]\"" do
-        @stdout.should be_include "Can't found .logaling in"
+      context "and call with option" do
+        before do
+          command.new('spec', 'en', 'ja')
+          @stdout = capture(:stdout) {command.unregister}
+        end
+        it 'should unregister symlink' do
+          Dir[File.join(LOGALING_HOME, "projects", "*")].size.should == @project_counts
+        end
       end
     end
 
@@ -233,9 +245,30 @@ describe Logaling::Command do
 
       it 'succeed at find by term without command.index' do
         @stdout.should include "spec : スペック # 備考"
+      end
+    end
+
+    context 'only one project exist in LOGALING_HOME/projects' do
+      before do
+        Dir.should_receive(:entries).with(File.join(LOGALING_HOME, "projects")).and_return([".", "..", "spec"])
+        @stdout = capture(:stdout) {command.lookup("spec")}
+      end
+
+      it 'should not show glossary name' do
         @stdout.should_not include "(spec)"
       end
     end
+
+    context 'some projects exist in LOGALING_HOME/projects' do
+      before do
+        Dir.should_receive(:entries).with(File.join(LOGALING_HOME, "projects")).and_return([".", "..", "spec", "spec2"])
+        @stdout = capture(:stdout) {command.lookup("spec")}
+      end
+
+      it 'should show glossary name' do
+        @stdout.should include "(spec)"
+      end
+    end
   end
 
   describe "#delete" do

data/spec/logaling/glossary_spec.rb

@@ -7,6 +7,7 @@ module Logaling
     let(:project) { "spec" }
     let(:glossary) { Glossary.new(project, 'en', 'ja') }
     let(:glossary_path) { Glossary.build_path(project, 'en', 'ja') }
+    let(:repository) { Logaling::Repository.new(LOGALING_HOME) }
 
     before do
       FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
@@ -74,178 +75,76 @@ module Logaling
     end
 
     describe '#delete' do
-      context 'given target_term' do
-        context 'bilingual pair exists' do
-          before do
-            glossary.add("delete", "てすと1", "備考")
-            glossary.add("delete", "てすと2", "備考")
-            glossary.delete("delete", "てすと1")
-            glossary.index
-            @result = glossary.lookup("delete")
-          end
-
-          it 'should delete the bilingual pair' do
-            @result.should include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと2", :note=>"備考"})
-            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと1", :note=>"備考"})
-          end
-        end
-
-        context 'bilingual pair does not exist' do
-          before do
-            glossary.add("user", "ユーザ", "ユーザーではない")
-          end
-
-          it {
-            -> { glossary.delete("user", "ユーザー") }.should raise_error(Logaling::TermError)
-          }
-        end
-      end
-
-      context 'not given target_term' do
-        context 'source_term not found' do
-          before do
-            glossary.add("user", "ユーザ", "備考")
-          end
-
-          it {
-            -> { glossary.delete("usr") }.should raise_error(Logaling::TermError)
-          }
+      context 'bilingual pair exists' do
+        before do
+          glossary.add("delete", "てすと1", "備考")
+          glossary.add("delete", "てすと2", "備考")
+          glossary.delete("delete", "てすと1")
+          repository.index
+          @result = repository.lookup("delete", "en", "ja", project)
         end
 
-        context 'source_term found' do
-          context 'there is only 1 bilingual pair' do
-            before do
-              glossary.add("user", "ユーザ", "備考")
-              glossary.delete("user")
-              glossary.index
-              @result = glossary.lookup("user")
-            end
-
-            it 'should delete the term' do
-              @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>"備考"})
-            end
-          end
-
-          context 'there are more than 1 bilingual pair' do
-            before do
-              glossary.add("user", "ユーザ1", "備考")
-              glossary.add("user", "ユーザ2", "備考")
-              glossary.add("delete", "てすと1", "備考")
-              glossary.add("delete", "てすと2", "備考")
-              glossary.delete("delete", "", true)
-              glossary.index
-              @result = glossary.lookup("delete")
-            end
-
-            it {
-              -> { glossary.delete("user") }.should raise_error(Logaling::TermError)
-            }
-
-            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", :target_term=>"てすと1", :note=>"備考"})
-              @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと2", :note=>"備考"})
-            end
-          end
+        it 'should delete the bilingual pair' do
+          @result.should include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと2", :note=>"備考"})
+          @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと1", :note=>"備考"})
         end
       end
-    end
-
-    describe '#lookup' do
-      before do
-        glossary.add("user", "ユーザ", "ユーザーではない")
-        glossary.index
-      end
-
-      context 'with arguments show existing bilingual pair' do
-        subject {glossary.lookup("user")}
-
-        it 'succeed at find by term' do
-          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>"ユーザーではない"})
-        end
-      end
-
-      context 'when tsv file as glossary exists' do
-        let(:tsv_path) { File.join(File.dirname(glossary_path), "spec.en.ja.tsv") }
 
+      context 'bilingual pair does not exist' 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 {glossary.lookup("user")}
-
-        it 'succeed at find by term' do
-          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザー", :note=>''})
+          glossary.add("user", "ユーザ", "ユーザーではない")
         end
 
-        after do
-          FileUtils.remove_entry_secure(tsv_path, true)
-        end
+        it {
+          -> { glossary.delete("user", "ユーザー") }.should raise_error(Logaling::TermError)
+        }
       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
+    describe '#delete_all' do
+      context 'source_term not found' do
         before do
-          FileUtils.mkdir_p(File.dirname(glossary_path))
-          FileUtils.touch(glossary_path)
-          glossary.add("spec", "スペック", "備考")
-          glossary.index
+          glossary.add("user", "ユーザ", "備考")
         end
 
-        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("spec")} }
-
-        it 'glossaries should be indexed' do
-          should be_include({: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
+        it {
+          -> { glossary.delete_all("usr") }.should raise_error(Logaling::TermError)
+        }
       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
-          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>''}]
-        end
-
-        after do
-          FileUtils.remove_entry_secure(tsv_path, true)
-        end
-      end
+      context 'source_term found' do
+        context 'there is only 1 bilingual pair' do
+          before do
+            glossary.add("user", "ユーザ", "備考")
+            glossary.delete_all("user")
+            repository.index
+            @result = repository.lookup("user", "en", "ja", project)
+          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
+          it 'should delete the term' do
+            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>"備考"})
+          end
         end
 
-        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("test")} }
+        context 'there are more than 1 bilingual pair' do
+          before do
+            glossary.add("user", "ユーザ1", "備考")
+            glossary.add("user", "ユーザ2", "備考")
+            glossary.add("delete", "てすと1", "備考")
+            glossary.add("delete", "てすと2", "備考")
+            glossary.delete_all("delete", true)
+            repository.index
+            @result = repository.lookup("delete", "en", "ja", project)
+          end
 
-        it 'glossaries should be indexed' do
-          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"test", :target_term=>"テスト", :note=>''}]
-        end
+          it {
+            -> { glossary.delete_all("user") }.should raise_error(Logaling::TermError)
+          }
 
-        after do
-          FileUtils.remove_entry_secure(csv_path, true)
+          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", :target_term=>"てすと1", :note=>"備考"})
+            @result.should_not include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"delete", :target_term=>"てすと2", :note=>"備考"})
+          end
         end
       end
     end

data/spec/logaling/repository_spec.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+require "fileutils"
+
+module Logaling
+  describe Repository do
+    let(:project) { "spec" }
+    let(:glossary) { Glossary.new(project, 'en', 'ja') }
+    let(:glossary_path) { Glossary.build_path(project, 'en', 'ja') }
+    let(:repository) { Logaling::Repository.new(LOGALING_HOME) }
+
+    before do
+      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+      FileUtils.mkdir_p(File.dirname(glossary_path))
+    end
+
+    describe '#lookup' do
+      before do
+        glossary.add("user", "ユーザ", "ユーザーではない")
+        repository.index
+      end
+
+      context 'with arguments show existing bilingual pair' do
+        subject {repository.lookup("user", "en", "ja", project)}
+
+        it 'succeed at find by term' do
+          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>"ユーザーではない"})
+        end
+      end
+
+      context 'when tsv file as glossary exists' do
+        let(:tsv_path) { glossary_path.sub(/yml$/, 'tsv') }
+
+        before do
+          FileUtils.mkdir_p(File.dirname(tsv_path))
+          FileUtils.touch(tsv_path)
+          File.open(tsv_path, "w"){|f| f.puts "user\tユーザー"}
+          repository.index
+        end
+
+        subject {repository.lookup("user", "en", "ja", project)}
+
+        it 'succeed at find by term' do
+          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザー", :note=>''})
+        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", "スペック", "備考")
+          repository.index
+        end
+
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("spec")} }
+
+        it 'glossaries should be indexed' do
+          should be_include({: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ユーザ"}
+          repository.index
+        end
+
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("user")} }
+
+        it 'glossaries should be indexed' do
+          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>''}]
+        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,テスト"}
+          repository.index
+        end
+
+        subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("test")} }
+
+        it 'glossaries should be indexed' do
+          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"test", :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
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logaling-command
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-06 00:00:00.000000000Z
+date: 2011-12-09 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2152321920 !ruby/object:Gem::Requirement
+  requirement: &2153169540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: 0.14.6
   type: :runtime
   prerelease: false
-  version_requirements: *2152321920
+  version_requirements: *2153169540
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2152321280 !ruby/object:Gem::Requirement
+  requirement: &2153168180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152321280
+  version_requirements: *2153168180
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152320420 !ruby/object:Gem::Requirement
+  requirement: &2153167720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,10 +47,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152320420
+  version_requirements: *2153167720
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152319460 !ruby/object:Gem::Requirement
+  requirement: &2153166260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -58,7 +58,18 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152319460
+  version_requirements: *2153166260
+- !ruby/object:Gem::Dependency
+  name: rroonga
+  requirement: &2153165060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2153165060
 description: A command line interface for logaling.
 email:
 - koji.shimada@enishi-tech.com
@@ -80,9 +91,11 @@ files:
 - lib/logaling/command.rb
 - lib/logaling/glossary.rb
 - lib/logaling/glossary_db.rb
+- lib/logaling/repository.rb
 - logaling-command.gemspec
 - spec/logaling/command_spec.rb
 - spec/logaling/glossary_spec.rb
+- spec/logaling/repository_spec.rb
 - spec/spec_helper.rb
 homepage: http://logaling.github.com/
 licenses: []
@@ -111,4 +124,5 @@ summary: A command line interface for logaling.
 test_files:
 - spec/logaling/command_spec.rb
 - spec/logaling/glossary_spec.rb
+- spec/logaling/repository_spec.rb
 - spec/spec_helper.rb