logaling-command 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in logaling-command.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = true
+end
+
+task :default => :spec

data/bin/loga

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib) && !$LOAD_PATH.include?(lib)
+LOGALING_HOME = File.expand_path("~/.logaling.d")
+
+require "logaling"
+
+Logaling::Command.start
+

data/lib/logaling/command.rb

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+
+require 'thor'
+require "logaling/glossary"
+require "logaling/glossary_db"
+
+class Logaling::Command < Thor
+  VERSION = "0.0.1"
+
+  map '-c' => :create,
+      '-a' => :add,
+      '-d' => :delete,
+      '-u' => :update,
+      '-l' => :lookup
+
+  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"
+
+  def initialize(*args)
+    super
+    @dot_options = Hash.new
+  end
+
+  desc 'create', 'Create glossary.'
+  def create
+    load_config
+    glossary.create
+  rescue Logaling::CommandFailed => e
+    error(e.message)
+  end
+
+  desc 'add', 'Add term to glossary.'
+  method_option :source_term, type: :string, required: true, aliases: "-s"
+  method_option :target_term, type: :string, required: true, aliases: "-t"
+  method_option :note, type: :string, aliases: "-n"
+  def add
+    load_config
+    glossary.add(options[:source_term], options[:target_term], options[:note])
+  rescue Logaling::CommandFailed => e
+    error(e.message)
+  end
+
+  desc 'delete', 'Delete term.'
+  method_option :source_term, type: :string, required: true, aliases: "-s"
+  method_option :target_term, type: :string, required: true, aliases: "-t"
+  def delete
+    load_config
+    glossary.delete(options[:source_term], options[:target_term])
+  rescue Logaling::CommandFailed => e
+    error(e.message)
+  end
+
+  desc 'update', 'Update term.'
+  method_option :source_term, type: :string, required: true, aliases: "-s"
+  method_option :target_term, type: :string, required: true, aliases: "-t"
+  method_option :new_target_term, type: :string, required: true, aliases: "-nt"
+  method_option :note, type: :string, required: true, aliases: "-n"
+  def update
+    load_config
+    glossary.update(options[:source_term], options[:target_term], options[:new_target_term], options[:note])
+  rescue Logaling::CommandFailed => e
+    error(e.message)
+  end
+
+  desc 'lookup', 'Lookup terms.'
+  method_option :source_term, type: :string, required: true, aliases: "-s"
+  def lookup
+    load_config
+    glossary.lookup(options[:source_term])
+  rescue Logaling::CommandFailed => e
+    error(e.message)
+  end
+
+  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
+  end
+
+  private
+  def glossary
+    glossary = find_option("glossary")
+    raise(Logaling::CommandFailed, "input glossary name '-g <glossary name>'") unless glossary
+
+    source_language = find_option("source_language")
+    raise(Logaling::CommandFailed, "input source-language code '-S <source-language code>'") unless source_language
+
+    target_language = find_option("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)
+  end
+
+  def error(msg)
+    STDERR.puts(msg)
+    exit 1
+  end
+
+  def find_option(key)
+    options[key] || @dot_options[key]
+  end
+
+  def load_config
+    if path = find_dotfile
+      tmp_options = File.readlines(path).map {|l| l.chomp.split " "}
+      tmp_options.each do |option|
+        key = option[0].sub(/^[\-]{2}/, "")
+        value = option[1]
+        @dot_options[key] = value
+      end
+    end
+  end
+
+  def find_dotfile
+    dir = Dir.pwd
+    while(dir) do
+      path = File.join(dir, '.logaling')
+      if File.exist?(path)
+        return path
+        break
+      end
+      dir = (dir != "/") ? File.dirname(dir) : nil
+    end
+  end
+end

data/lib/logaling/glossary.rb

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+#require "logaling-command/version"
+
+require 'psych'
+require "yaml"
+require "fileutils"
+
+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
+    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)
+      @glossary = glossary
+      @source_language = source_language
+      @target_language = target_language
+      @logaling_home = logaling_home
+    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
+
+      if bilingual_pair_exists?(source_term, target_term)
+        puts "[#{source_term}] [#{target_term}] pair already exists"
+        return
+      end
+
+      glossary = load_glossary_yml
+      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
+
+      if bilingual_pair_exists?(source_term, new_target_term)
+        puts "[#{source_term}] [#{new_target_term}] pair already exists"
+        return
+      end
+
+      glossary = load_glossary_yml
+      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
+        puts "source_term:#{source_term} target_term:#{target_term} not found in glossary #{@path}"
+      end
+    end
+
+    def delete(source_term, target_term)
+      check_glossary_exists
+
+      glossary = load_glossary_yml
+      target_index = find_term_index(glossary, source_term, target_term)
+      if target_index
+        glossary.delete_at(target_index)
+        dump_glossary(glossary)
+      else
+        puts "source_term:#{source_term} target_term:#{target_term} not found in glossary #{@path}"
+      end
+    end
+
+    def lookup(source_term)
+      check_glossary_exists
+
+      glossarydb = Logaling::GlossaryDB.new
+      glossarydb.open(logaling_db_home, "utf8") do |db|
+        glossaries = db.lookup(source_term)
+        glossaries.reject! do |term|
+          term[:source_language] != @source_language || term[:target_language] != @target_language
+        end
+        if glossaries.empty?
+          puts "source_term <#{source_term}> not found"
+          return
+        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]}"
+        end
+      end
+    end
+
+    private
+    def load_glossary_yml
+      YAML::load_file(@path) || []
+    end
+
+    def logaling_db_home
+      File.join(@logaling_home, ".logadb")
+    end
+
+    def build_term(source_term, target_term, note)
+      {'source_term' => source_term, 'target_term' => target_term, 'note' => note}
+    end
+
+    def rebuild_term(current, source_term, target_term, note)
+      note = current['note'] if note == ""
+      target_term = current['target_term'] if target_term == ""
+      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
+      end
+    end
+
+    def bilingual_pair_exists?(source_term, target_term)
+      target_terms(source_term).any?{|data| data['target_term'] == target_term }
+    end
+
+    def exist?
+      File.exists?(@path)
+    end
+
+    def check_glossary_unexists
+      raise CommandFailed, "glossary #{@path} already exists" if exist?
+    end
+
+    def check_glossary_exists
+      raise CommandFailed, "glossary #{@path} not found" unless exist?
+    end
+
+    def target_terms(source_term, path=@path)
+      target_terms = []
+      glossaly = YAML::load_file(path) || []
+      glossaly.each do |term|
+        target_terms << term if term['source_term'] == source_term
+      end
+      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)
+      end
+    end
+  end
+end

data/lib/logaling/glossary_db.rb

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*-
+
+require 'psych'
+require "yaml"
+require "fileutils"
+require 'groonga'
+
+module Logaling
+  class GlossaryDB
+    def initialize()
+      @database = nil
+    end
+
+    def open(base_path, encoding)
+      reset_context(encoding)
+      path = File.join(base_path, "logaling.db")
+      if File.exist?(path)
+        @database = Groonga::Database.open(path)
+      else
+        FileUtils.mkdir_p(base_path)
+        populate(path)
+      end
+      if block_given?
+        begin
+          yield(self)
+        ensure
+          close unless closed?
+        end
+      end
+    end
+
+    def recreate_table(base_path)
+      path = File.join(base_path, "logaling.db.tables")
+      if File.exist?(path)
+        remove_schema
+      end
+      populate_schema
+    end
+
+    def close
+      @database.close
+      @database = nil
+    end
+
+    def closed?
+      @database.nil? or @database.closed?
+    end
+
+    def load_glossaries(path)
+      file_list = Dir.glob("#{path}/*.yml")
+      file_list.each do |file|
+        name, source_language, target_language = File::basename(file, "yml").split(".")
+        glossary = YAML::load_file(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
+      end
+    end
+
+    def lookup(source_term)
+      records_raw = Groonga["glossaries"].select do |record|
+        record.source_term =~ source_term
+      end
+      records = records_raw.sort([
+        {:key=>"name", :order=>'ascending'},
+        {:key=>"source_term", :order=>'ascending'},
+        {:key=>"target_term", :order=>'ascending'}])
+
+      records.map do |record|
+        term = record.key
+        {:name => term.name,
+         :source_language => term.source_language,
+         :target_language => term.target_language,
+         :source_term => term.source_term,
+         :target_term => term.target_term,
+         :note => term.note,}
+      end
+    end
+
+    private
+    def add_glossary(name, source_language, target_language, source_term, target_term, note)
+      Groonga["glossaries"].add(:name => name,
+                                :source_language => source_language,
+                                :target_language => target_language,
+                                :source_term => source_term,
+                                :target_term => target_term,
+                                :note => note,
+                               )
+    end
+
+    def reset_context(encoding)
+      Groonga::Context.default_options = {:encoding => encoding}
+      Groonga::Context.default = nil
+    end
+
+    def populate(path)
+      @database = Groonga::Database.create(:path => path)
+    end
+
+    def populate_schema
+      Groonga::Schema.define do |schema|
+        schema.create_table("glossaries") do |table|
+          table.short_text("name")
+          table.short_text("source_language")
+          table.short_text("target_language")
+          table.short_text("source_term")
+          table.text("target_term")
+          table.text("note")
+        end
+
+        schema.create_table("terms",
+                            :type => :patricia_trie,
+                            :key_type => "ShortText",
+                            :key_normalize => true,
+                            :default_tokenizer => "TokenBigram") do |table|
+          table.index("glossaries.source_term")
+        end
+      end
+    end
+
+    def remove_schema
+      Groonga::Schema.define do |schema|
+        schema.remove_table("glossaries")
+        schema.remove_table("terms")
+      end
+    end
+  end
+end

data/lib/logaling.rb

@@ -0,0 +1,7 @@
+# -*- encoding: utf-8 -*-
+
+require "logaling/command"
+
+module Logaling
+  class CommandFailed < RuntimeError; end
+end

data/logaling-command.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "logaling/command.rb"
+
+Gem::Specification.new do |s|
+  s.name        = "logaling-command"
+  s.version     = Logaling::Command::VERSION
+  s.authors     = ["SHIMADA Koji", "SHIDARA Yoji", "Kouhei Sutou", "Daijiro MORI", "SUZUKI Miho"]
+  s.email       = ["koji.shimada@enishi-tech.com", "dara@shidara.net", "kou@clear-code.com", "daijiro.mori@gmail.com", "adzuki34@gmail.com"]
+  s.homepage    = "http://logaling.github.com/"
+  s.summary     = %q{A command line interface for logaling.}
+  s.description = %q{A command line interface for logaling.}
+
+  s.rubyforge_project = "logaling-command"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require "rubygems"
+require "bundler/setup"
+
+require 'rspec'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'logaling_command'
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: logaling-command
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- SHIMADA Koji
+- SHIDARA Yoji
+- Kouhei Sutou
+- Daijiro MORI
+- SUZUKI Miho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-09 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2151902900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151902900
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2151901960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2151901960
+description: A command line interface for logaling.
+email:
+- koji.shimada@enishi-tech.com
+- dara@shidara.net
+- kou@clear-code.com
+- daijiro.mori@gmail.com
+- adzuki34@gmail.com
+executables:
+- loga
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Rakefile
+- bin/loga
+- lib/logaling.rb
+- lib/logaling/command.rb
+- lib/logaling/glossary.rb
+- lib/logaling/glossary_db.rb
+- logaling-command.gemspec
+- spec/spec_helper.rb
+homepage: http://logaling.github.com/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: logaling-command
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: A command line interface for logaling.
+test_files:
+- spec/spec_helper.rb