logaling-command 0.0.5 → 0.0.6

data/lib/logaling/command.rb

@@ -4,7 +4,7 @@ require 'thor'
 require "logaling/glossary"
 
 class Logaling::Command < Thor
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
   LOGALING_CONFIG = '.logaling'
 
   map '-a' => :add,
@@ -13,12 +13,13 @@ class Logaling::Command < Thor
       '-l' => :lookup,
       '-n' => :new,
       '-r' => :register,
-      '-U' => :unregister
+      '-U' => :unregister,
+      '-v' => :version
 
   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"
+  class_option "logaling-home",   type: :string, aliases: "-h"
 
   desc 'new [PROJECT NAME] [SOURCE LANGUAGE] [TARGET LANGUAGE(optional)]', 'Create .logaling'
   method_option "no-register", type: :boolean, default: false
@@ -77,9 +78,10 @@ class Logaling::Command < Thor
     say e.message
   end
 
-  desc 'delete [SOURCE TERM] [TARGET TERM]', 'Delete term.'
-  def delete(source_term, target_term)
-    glossary.delete(source_term, target_term)
+  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"])
   rescue Logaling::CommandFailed, Logaling::TermError => e
     say e.message
   rescue Logaling::GlossaryNotFound => e
@@ -100,13 +102,13 @@ class Logaling::Command < Thor
     glossary.index
     terms = glossary.lookup(source_term)
 
-    puts "\nlookup word : #{source_term}"
     unless terms.empty?
+      is_glossary_name_print = terms.map{|t| t[:name]}.uniq.size > 1 ? true : false
       terms.each do |term|
-        puts "\n  #{term[:source_term]}\n"
-        puts "  #{term[:target_term]}\n"
-        puts "    note:#{term[:note]}"
-        puts "    glossary:#{term[:name]}"
+        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
       end
     else
       "source-term <#{source_term}> not found"
@@ -115,6 +117,11 @@ class Logaling::Command < Thor
     say e.message
   end
 
+  desc 'version', 'Show version.'
+  def version
+    say "logaling-command version #{Logaling::Command::VERSION}"
+  end
+
   private
   def glossary
     config = load_config

data/lib/logaling/glossary.rb

@@ -21,24 +21,23 @@ module Logaling
     def add(source_term, target_term, note)
       FileUtils.touch(@path) unless File.exists?(@path)
 
-      if bilingual_pair_exists?(source_term, target_term)
+      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
 
-      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)
       raise GlossaryNotFound unless File.exists?(@path)
 
-      if bilingual_pair_exists?(source_term, new_target_term)
+      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
 
-      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)
@@ -48,16 +47,29 @@ module Logaling
       end
     end
 
-    def delete(source_term, target_term)
+    def delete(source_term, target_term='', force=false)
       raise GlossaryNotFound unless File.exists?(@path)
 
-      glossary = load_glossary_yml(@path)
-      target_index = find_term_index(glossary, source_term, target_term)
-      if target_index
+      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)
+        raise TermError, "Can't found term '#{source_term} #{target_term}' in '#{@glossary}'" unless target_index
         glossary.delete_at(target_index)
         dump_glossary(glossary)
       else
-        raise TermError, "Can't found term '#{source_term}: #{target_term}' in '#{@glossary}'"
+        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
 
@@ -146,20 +158,27 @@ module Logaling
       build_term(source_term, target_term, note)
     end
 
-    def find_term_index(glossary_yml, source_term, target_term)
-      glossary_yml.find_index do |term|
-        term['source_term'] == source_term && term['target_term'] == target_term
+    def find_term_index(glossary, source_term, target_term='')
+      glossary.find_index do |term|
+        if target_term.empty?
+          term['source_term'] == source_term
+        else
+          term['source_term'] == source_term && term['target_term'] == target_term
+        end
       end
     end
 
-    def bilingual_pair_exists?(source_term, target_term)
-      target_terms(source_term).any?{|data| data['target_term'] == target_term }
+    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(source_term, path=@path)
+    def target_terms(glossary, source_term)
       target_terms = []
-      glossaly = YAML::load_file(path) || []
-      glossaly.each do |term|
+      glossary.each do |term|
         target_terms << term if term['source_term'] == source_term
       end
       target_terms

data/lib/logaling/glossary_db.rb

@@ -69,7 +69,7 @@ module Logaling
          :target_language => term.target_language,
          :source_term => term.source_term,
          :target_term => term.target_term,
-         :note => term.note,}
+         :note => term.note || ''}
       end
     end
 

data/spec/logaling/command_spec.rb

@@ -232,7 +232,72 @@ describe Logaling::Command do
       end
 
       it 'succeed at find by term without command.index' do
-        @stdout.should be_include "glossary:spec"
+        @stdout.should include "spec : スペック # 備考"
+        @stdout.should_not include "(spec)"
+      end
+    end
+  end
+
+  describe "#delete" do
+    before do
+      command.new('spec', 'en', 'ja')
+      command.add('spec', 'スペック', '備考')
+      command.add('user', 'ユーザ', '備考')
+      command.add('test', 'てすと1', '備考')
+      command.add('test', 'てすと2', '備考')
+    end
+
+    context 'with arguments exist term' do
+      before do
+        command.delete('spec', 'スペック')
+        @stdout = capture(:stdout) {command.lookup("spec")}
+      end
+
+      it 'should delete the term' do
+        @stdout.should_not include "spec : スペック # 備考"
+      end
+    end
+
+    context 'without target_term' do
+      context 'only 1 bilingual pair exist' do
+      before do
+        command.delete('user')
+        @stdout = capture(:stdout) {command.lookup("user")}
+      end
+
+      it 'should delete the term' do
+        @stdout.should_not include "user : ユーザ # 備考"
+      end
+      end
+
+      context 'some bilingual pair exist' do
+        context "called without '--force=true'" do
+          before do
+            @stdout = capture(:stdout) {command.delete('test')}
+          end
+
+          it "should print usage" do
+            @stdout.should == "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]`\n"
+          end
+        end
+
+        context "and called with '--force=true'" do
+          before do
+            command.options = base_options.merge("force" => true)
+            command.new('spec', 'en', 'ja')
+            command.add('term', '用語1', '備考')
+            command.add('term', '用語2', '備考')
+            command.delete("term")
+            @stdout = capture(:stdout) {command.lookup("term")}
+          end
+
+          it 'should delete bilingual pairs' do
+            @stdout.should_not include "term : 用語1 # 備考"
+            @stdout.should_not include "term : 用語2 # 備考"
+          end
+        end
       end
     end
   end

data/spec/logaling/glossary_spec.rb

@@ -74,14 +74,79 @@ module Logaling
     end
 
     describe '#delete' do
-      before do
-        glossary.add("user", "ユーザ", "ユーザーではない")
+      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 'with arguments show not existing bilingual pair' do
-        it {
-          -> { glossary.delete("user", "ユーザー") }.should raise_error(Logaling::TermError)
-        }
+      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)
+          }
+        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
+        end
       end
     end
 
@@ -112,7 +177,7 @@ module Logaling
         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=>nil})
+          should be_include({:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザー", :note=>''})
         end
 
         after do
@@ -157,7 +222,7 @@ module Logaling
         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=>nil}]
+          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"user", :target_term=>"ユーザ", :note=>''}]
         end
 
         after do
@@ -176,7 +241,7 @@ module Logaling
         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=>nil}]
+          should == [{:name=>"spec", :source_language=>"en", :target_language=>"ja", :source_term=>"test", :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.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -13,11 +13,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-11-30 00:00:00.000000000Z
+date: 2011-12-06 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2153858740 !ruby/object:Gem::Requirement
+  requirement: &2152321920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -25,10 +25,10 @@ dependencies:
         version: 0.14.6
   type: :runtime
   prerelease: false
-  version_requirements: *2153858740
+  version_requirements: *2152321920
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2153857740 !ruby/object:Gem::Requirement
+  requirement: &2152321280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -36,10 +36,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153857740
+  version_requirements: *2152321280
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153837940 !ruby/object:Gem::Requirement
+  requirement: &2152320420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -47,10 +47,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153837940
+  version_requirements: *2152320420
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153837240 !ruby/object:Gem::Requirement
+  requirement: &2152319460 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -58,7 +58,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153837240
+  version_requirements: *2152319460
 description: A command line interface for logaling.
 email:
 - koji.shimada@enishi-tech.com