logaling-command 0.0.4 → 0.0.5

data/lib/logaling/command.rb

@@ -4,11 +4,10 @@ require 'thor'
 require "logaling/glossary"
 
 class Logaling::Command < Thor
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
   LOGALING_CONFIG = '.logaling'
 
-  map '-c' => :create,
-      '-a' => :add,
+  map '-a' => :add,
       '-d' => :delete,
       '-u' => :update,
       '-l' => :lookup,
@@ -41,80 +40,79 @@ class Logaling::Command < Thor
   desc 'register', 'Register .logaling'
   def register
     logaling_path = find_dotfile
-    if logaling_path
-      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 registered to #{symlink_path}."
-      else
-        say "#{options["glossary"]} is already registered."
-      end
+    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 "Try 'loga new' first."
+      say "#{config['glossary']} is already registered."
     end
+  rescue Logaling::CommandFailed => e
+    say e.message
+    say "Try 'loga new' first."
   end
 
   desc 'unregister', 'Unregister .logaling'
   def unregister
     logaling_path = find_dotfile
-    if logaling_path
-      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 "Your project is now unregistered."
-      else
-        say ".logaling is not yet registered."
-      end
+    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 ".logaling can't be found."
+      say "#{config['glossary']} is not yet registered."
     end
-  end
-
-  desc 'create', 'Create glossary.'
-  def create
-    glossary.create
   rescue Logaling::CommandFailed => e
-    error(e.message)
+    say e.message
   end
 
   desc 'add [SOURCE TERM] [TARGET TERM] [NOTE(optional)]', 'Add term to glossary.'
   def add(source_term, target_term, note='')
     glossary.add(source_term, target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
-    error(e.message)
+    say e.message
   end
 
   desc 'delete [SOURCE TERM] [TARGET TERM]', 'Delete term.'
   def delete(source_term, target_term)
     glossary.delete(source_term, target_term)
   rescue Logaling::CommandFailed, Logaling::TermError => e
-    error(e.message)
+    say e.message
+  rescue Logaling::GlossaryNotFound => e
+    say "Try 'loga new or register' first."
   end
 
   desc 'update [SOURCE TERM] [TARGET TERM] [NEW TARGET TERM], [NOTE(optional)]', 'Update term.'
   def update(source_term, target_term, new_target_term, note='')
     glossary.update(source_term, target_term, new_target_term, note)
   rescue Logaling::CommandFailed, Logaling::TermError => e
-    error(e.message)
+    say e.message
+  rescue Logaling::GlossaryNotFound => e
+    say "Try 'loga new or register' first."
   end
 
   desc 'lookup [TERM]', 'Lookup terms.'
   def lookup(source_term)
-    index
-    glossary.lookup(source_term)
-  rescue Logaling::CommandFailed, Logaling::TermError => e
-    error(e.message)
-  end
-
-  desc 'index', 'Index glossaries to groonga DB.'
-  def index
     glossary.index
+    terms = glossary.lookup(source_term)
+
+    puts "\nlookup word : #{source_term}"
+    unless terms.empty?
+      terms.each do |term|
+        puts "\n  #{term[:source_term]}\n"
+        puts "  #{term[:target_term]}\n"
+        puts "    note:#{term[:note]}"
+        puts "    glossary:#{term[:name]}"
+      end
+    else
+      "source-term <#{source_term}> not found"
+    end
   rescue Logaling::CommandFailed, Logaling::TermError => e
-    error(e.message)
+    say e.message
   end
 
   private
@@ -156,13 +154,19 @@ class Logaling::Command < Thor
 
   def find_dotfile
     dir = Dir.pwd
+    searched_path = []
     while(dir) do
       path = File.join(dir, '.logaling')
       if File.exist?(path)
         return path
-        break
+      else
+        if dir != "/"
+          searched_path << dir
+          dir = File.dirname(dir)
+        else
+          raise(Logaling::CommandFailed, "Can't found .logaling in #{searched_path}")
+        end
       end
-      dir = (dir != "/") ? File.dirname(dir) : nil
     end
   end
 end

data/lib/logaling/glossary.rb

@@ -18,98 +18,117 @@ module Logaling
       @target_language = target_language
     end
 
-    def create
-      check_glossary_unexists
-
-      dirname = File::dirname(@path)
-      FileUtils.mkdir_p(dirname)
-      FileUtils.touch(@path)
-    end
-
     def add(source_term, target_term, note)
-      check_glossary_exists
+      FileUtils.touch(@path) unless File.exists?(@path)
 
       if bilingual_pair_exists?(source_term, target_term)
-        raise TermError, "[#{source_term}] [#{target_term}] pair already exists"
+        raise TermError, "term '#{source_term}: #{target_term}' already exists in '#{@glossary}'"
       end
 
-      glossary = load_glossary_yml
+      glossary = load_glossary_yml(@path)
       glossary << build_term(source_term, target_term, note)
 
       dump_glossary(glossary)
     end
 
     def update(source_term, target_term, new_target_term, note)
-      check_glossary_exists
+      raise GlossaryNotFound unless File.exists?(@path)
 
       if bilingual_pair_exists?(source_term, new_target_term)
-        raise TermError, "[#{source_term}] [#{new_target_term}] pair already exists"
+        raise TermError, "term '#{source_term}: #{target_term}' already exists in '#{@glossary}'"
       end
 
-      glossary = load_glossary_yml
+      glossary = load_glossary_yml(@path)
       target_index = find_term_index(glossary, source_term, target_term)
       if target_index
         glossary[target_index] = rebuild_term(glossary[target_index], source_term, new_target_term, note)
         dump_glossary(glossary)
       else
-        raise TermError, "source_term:#{source_term} target_term:#{target_term} not found in glossary #{@path}"
+        raise TermError, "Can't found term '#{source_term}: #{target_term}' in '#{@glossary}'"
       end
     end
 
     def delete(source_term, target_term)
-      check_glossary_exists
+      raise GlossaryNotFound unless File.exists?(@path)
 
-      glossary = load_glossary_yml
+      glossary = load_glossary_yml(@path)
       target_index = find_term_index(glossary, source_term, target_term)
       if target_index
         glossary.delete_at(target_index)
         dump_glossary(glossary)
       else
-        raise TermError, "source_term:#{source_term} target_term:#{target_term} not found in glossary #{@path}"
+        raise TermError, "Can't found term '#{source_term}: #{target_term}' in '#{@glossary}'"
       end
     end
 
     def lookup(source_term)
-      check_glossary_exists
+      raise GlossaryDBNotFound unless File.exists?(logaling_db_home)
 
-      glossarydb = Logaling::GlossaryDB.new
-      glossarydb.open(logaling_db_home, "utf8") do |db|
-        glossaries = db.lookup(source_term)
-        glossaries.reject! do |term|
+      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
-        if glossaries.empty?
-          raise TermError, "source-term <#{source_term}> not found"
-        end
-        # order by glossary
-        specified = glossaries.select{|term| term[:name] == @glossary}
-        other = glossaries.select{|term| term[:name] != @glossary}
-        glossaries = specified.concat(other)
-
-        puts "\nlookup word : #{source_term}"
-        glossaries.each do |term|
-          puts "\n  #{term[:source_term]}\n"
-          puts "  #{term[:target_term]}\n"
-          puts "    note:#{term[:note]}"
-          puts "    glossary:#{term[:name]}"
+        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", "*"))
-      glossarydb = Logaling::GlossaryDB.new
-      glossarydb.open(logaling_db_home, "utf8") do |db|
-        db.recreate_table(logaling_db_home)
+
+      Logaling::GlossaryDB.open(logaling_db_home, "utf8") do |db|
+        db.recreate_table
         projects.each do |project|
-          db.load_glossaries(File.join(project, "glossary"))
+          get_glossaries(project).each do |glossary, name, source_language, target_language|
+            db.index_glossary(glossary, name, source_language, target_language)
+          end
         end
       end
     end
 
     private
-    def load_glossary_yml
-      YAML::load_file(@path) || []
+    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 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]
+      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 logaling_db_home
@@ -137,22 +156,6 @@ module Logaling
       target_terms(source_term).any?{|data| data['target_term'] == target_term }
     end
 
-    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
-      check_glossarydir_unexists
-      raise CommandFailed, "glossary #{@path} already exists" if File.exists?(@path)
-    end
-
-    def check_glossary_exists
-      check_glossarydir_unexists
-      FileUtils.touch(@path) unless File.exists?(@path)
-    end
-
     def target_terms(source_term, path=@path)
       target_terms = []
       glossaly = YAML::load_file(path) || []

data/lib/logaling/glossary_db.rb

@@ -8,6 +8,10 @@ require 'csv'
 
 module Logaling
   class GlossaryDB
+    def self.open(base_path, encoding, &blk)
+      blk ? GlossaryDB.new.open(base_path, encoding, &blk) : GlossaryDB.new.open(base_path, encoding)
+    end
+
     def initialize
       @database = nil
     end
@@ -30,11 +34,8 @@ module Logaling
       end
     end
 
-    def recreate_table(base_path)
-      path = File.join(base_path, "logaling.db.tables")
-      if File.exist?(path)
-        remove_schema
-      end
+    def recreate_table
+      remove_schema
       populate_schema
     end
 
@@ -43,38 +44,12 @@ module Logaling
       @database = nil
     end
 
-    def closed?
-      @database.nil? or @database.closed?
-    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 = get_file_list(path, ["yml", "tsv", "csv"])
-      file_list.each do |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']
-          target_term = term['target_term']
-          note = term['note']
-          add_glossary(name, source_language, target_language, source_term, target_term, note)
-        end
+    def index_glossary(glossary, name, source_language, target_language)
+      glossary.each do |term|
+        source_term = term['source_term']
+        target_term = term['target_term']
+        note = term['note']
+        add_glossary(name, source_language, target_language, source_term, target_term, note)
       end
     end
 
@@ -141,15 +116,13 @@ module Logaling
 
     def remove_schema
       Groonga::Schema.define do |schema|
-        schema.remove_table("glossaries")
-        schema.remove_table("terms")
+        schema.remove_table("glossaries") if Groonga["glossaries"]
+        schema.remove_table("terms") if Groonga["terms"]
       end
     end
 
-    def get_file_list(path, types)
-      glob_list = types.map{|type| File.join(path, "*.#{type}") }
-      Dir.glob(glob_list)
+    def closed?
+      @database.nil? or @database.closed?
     end
-
   end
 end

data/lib/logaling.rb

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

data/spec/logaling/command_spec.rb

@@ -7,10 +7,13 @@ describe Logaling::Command do
   let(:glossary_path) { Logaling::Glossary.build_path('spec', 'en', 'ja') }
   let(:target_project_path) { File.join(LOGALING_HOME, "projects", "spec") }
 
+  before do
+    FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
+    FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
+  end
+
   describe '#new' do
     before do
-      FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
-      FileUtils.remove_file(target_project_path) if File.exist?(target_project_path)
       @project_counts = Dir[File.join(LOGALING_HOME, "projects", "*")].size
     end
 
@@ -61,7 +64,6 @@ describe Logaling::Command do
 
   describe '#register' do
     before do
-      FileUtils.remove_file(target_project_path) if File.exist?(target_project_path)
       @project_counts = Dir[File.join(LOGALING_HOME, "projects", "*")].size
     end
 
@@ -76,7 +78,7 @@ describe Logaling::Command do
       end
 
       it "print message \"Try 'loga new' first.\"" do
-        @stdout.should == "Try 'loga new' first.\n"
+        @stdout.should be_include "Try 'loga new' first.\n"
       end
     end
 
@@ -108,22 +110,19 @@ describe Logaling::Command do
         @stdout = capture(:stdout) {command.unregister}
       end
 
-      it 'unregister nothing' do
+      it 'should not register nothing' do
         Dir[File.join(LOGALING_HOME, "projects", "*")].size.should == @project_counts
       end
 
-      it "print message \".logaling can't be found.\"" do
-        @stdout.should == ".logaling can't be found.\n"
+      it "should print message \"Can't found .logaling in [...]\"" do
+        @stdout.should be_include "Can't found .logaling in"
       end
     end
 
     context 'when find .logaling' do
-      before do
-        command.new('spec', 'en', 'ja')
-      end
-
       context 'and .logaling registered' do
         before do
+          command.new('spec', 'en', 'ja')
           command.register
           command.unregister
         end
@@ -136,42 +135,21 @@ describe Logaling::Command do
 
       context "and .logaling is not registered" do
         before do
+          command.options = base_options.merge("no-register" => true)
+          command.new('spec', 'en', 'ja')
           @stdout = capture(:stdout) {command.unregister}
         end
 
-        it "print message \".logaling is not yet registered.\"" do
-          @stdout.should == ".logaling is not yet registered.\n"
+        it "print message \"<glossary name> is not yet registered.\"" do
+          @stdout.should == "spec is not yet registered.\n"
         end
       end
     end
   end
 
-  describe '#create' do
-    before do
-      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
-    end
-
-    context 'with arguments show non-existent glossary' do
-      before do
-        command.new('spec', 'en', 'ja')
-        command.register
-        command.create
-      end
-
-      it "glossary yaml should be newly created" do
-        File.exists?(glossary_path).should be_true
-      end
-    end
-
-    after do
-      FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
-    end
-  end
-
   describe '#add' do
     before do
-      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
-      FileUtils.mkdir_p(File.dirname(glossary_path))
+      command.new('spec', 'en', 'ja')
     end
 
     context 'with arguments have only bilingual pair' do
@@ -209,8 +187,7 @@ describe Logaling::Command do
 
   describe "#update" do
     before do
-      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
-      FileUtils.mkdir_p(File.dirname(glossary_path))
+      command.new('spec', 'en', 'ja')
       command.add("spec", "テスト", "備考")
     end
 
@@ -243,68 +220,25 @@ describe Logaling::Command do
     end
   end
 
-  describe '#index' do
-    before do
-      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
-      FileUtils.mkdir_p(File.dirname(glossary_path))
-      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(:glossary_path2) { Logaling::Glossary.build_path('spec2', 'en', 'ja') }
-
     before do
-      FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
-      FileUtils.mkdir_p(File.dirname(glossary_path))
+      command.new('spec', 'en', 'ja')
+      command.add("spec", "スペック", "備考")
     end
 
     context 'with arguments exist term' do
       before do
-        command.add("spec", "スペック", "備考")
-        FileUtils.mkdir_p(File.dirname(glossary_path2))
-        command2.add("spec", "スペック")
+        @stdout = capture(:stdout) {command.lookup("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)
+        @stdout.should be_include "glossary:spec"
       end
     end
   end
 
   after do
+    FileUtils.remove_entry_secure(Logaling::Command::LOGALING_CONFIG, true)
     FileUtils.remove_entry_secure(File.join(LOGALING_HOME, 'projects', 'spec'), true)
   end
 end

data/spec/logaling/glossary_spec.rb

@@ -13,29 +13,6 @@ module Logaling
       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
@@ -70,16 +47,6 @@ module Logaling
           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
@@ -121,21 +88,14 @@ module Logaling
     describe '#lookup' do
       before do
         glossary.add("user", "ユーザ", "ユーザーではない")
+        glossary.index
       end
 
       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
+        subject {glossary.lookup("user")}
 
-lookup word : user
-
-  user
-  ユーザ
-    note:ユーザーではない
-    glossary:spec
-          EOM
+        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
 
@@ -149,23 +109,10 @@ lookup word : user
           glossary.index
         end
 
-        it 'succeed at find by term' do
-          glossary.index
-          stdout = capture(:stdout) {glossary.lookup("user")}
-          stdout.should == <<-EOM
+        subject {glossary.lookup("user")}
 
-lookup word : user
-
-  user
-  ユーザ
-    note:ユーザーではない
-    glossary:spec
-
-  user
-  ユーザー
-    note:
-    glossary:spec
-          EOM
+        it 'succeed at find by term' do
+          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザー", :note=>nil})
         end
 
         after do
@@ -191,7 +138,7 @@ lookup word : user
         subject { logaling_db.open(db_home, "utf8"){|db| logaling_db.lookup("spec")} }
 
         it 'glossaries should be indexed' do
-          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"spec", :target_term=>"スペック", :note=>"備考"}]
+          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"spec", :target_term=>"スペック", :note=>"備考"})
         end
 
         after do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: logaling-command
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-28 00:00:00.000000000Z
+date: 2011-11-30 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2152368760 !ruby/object:Gem::Requirement
+  requirement: &2153858740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: 0.14.6
   type: :runtime
   prerelease: false
-  version_requirements: *2152368760
+  version_requirements: *2153858740
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2152368000 !ruby/object:Gem::Requirement
+  requirement: &2153857740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2152368000
+  version_requirements: *2153857740
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152367420 !ruby/object:Gem::Requirement
+  requirement: &2153837940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,10 +47,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152367420
+  version_requirements: *2153837940
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152366640 !ruby/object:Gem::Requirement
+  requirement: &2153837240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -58,7 +58,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152366640
+  version_requirements: *2153837240
 description: A command line interface for logaling.
 email:
 - koji.shimada@enishi-tech.com
@@ -82,7 +82,6 @@ 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/
@@ -111,6 +110,5 @@ 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

data/spec/logaling/glossary_db_spec.rb

@@ -1,75 +0,0 @@
-# -*- 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 '#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
-