logaling-command 0.1.2 → 0.1.3

data/lib/logaling/command.rb

@@ -15,360 +15,5 @@
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-require 'thor'
-require 'rainbow'
-require "logaling/repository"
-require "logaling/glossary"
-
-class Logaling::Command < Thor
-  VERSION = "0.1.2"
-  LOGALING_CONFIG = '.logaling'
-
-  map '-a' => :add,
-      '-d' => :delete,
-      '-u' => :update,
-      '-l' => :lookup,
-      '-i' => :import,
-      '-n' => :new,
-      '-r' => :register,
-      '-U' => :unregister,
-      '-L' => :list,
-      '-s' => :show,
-      '-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, aliases: "-h"
-
-  desc 'new [PROJECT NAME] [SOURCE LANGUAGE] [TARGET LANGUAGE(optional)]', 'Create .logaling'
-  method_option "no-register", type: :boolean, default: false
-  def new(project_name, source_language, target_language=nil)
-    unless File.exist?(LOGALING_CONFIG)
-      FileUtils.mkdir_p(File.join(LOGALING_CONFIG, "glossary"))
-      config = {"glossary" => project_name, "source-language" => source_language}
-      config["target-language"] = target_language if target_language
-      write_config(File.join(LOGALING_CONFIG, "config"), config)
-
-      register unless options["no-register"]
-      say "Successfully created #{LOGALING_CONFIG}"
-    else
-      say "#{LOGALING_CONFIG} already exists."
-    end
-  end
-
-  desc 'import', 'Import external glossary'
-  method_option "list", type: :boolean, default: false
-  def import(external_glossary=nil)
-    require "logaling/external_glossary"
-    Logaling::ExternalGlossary.load
-    if options["list"]
-      Logaling::ExternalGlossary.list.each {|glossary| say "#{glossary.name.bright} : #{glossary.description}" }
-    else
-      repository.import(Logaling::ExternalGlossary.get(external_glossary))
-    end
-  rescue Logaling::ExternalGlossaryNotFound
-    say "'#{external_glossary}' can't find in import list."
-    say "Try 'loga import --list' and confirm import list."
-  end
-
-  desc 'register', 'Register .logaling'
-  def register
-    logaling_path = find_dotfile
-
-    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
-    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 'config [KEY] [VALUE] [--global(optional)]', 'Set config.'
-  method_option "global", type: :boolean, default: false
-  def config(key, value)
-    support_keys = %w(glossary source-language target-language)
-    raise Logaling::CommandFailed, "#{key} is unsupported option" unless support_keys.include?(key)
-
-    config_path = options["global"] ? File.join(LOGALING_HOME, "config") : File.join(find_dotfile, "config")
-    FileUtils.touch(config_path) unless File.exist?(config_path)
-
-    config = load_config(config_path)
-    config = merge_options({key => value}, config)
-    write_config(config_path, config)
-    say "Successfully set config."
-  rescue Logaling::CommandFailed => e
-    say e.message
-  end
-
-  desc 'add [SOURCE TERM] [TARGET TERM] [NOTE(optional)]', 'Add term to glossary.'
-  def add(source_term, target_term, note='')
-    config = load_config_and_merge_options
-    repository.index
-
-    if repository.bilingual_pair_exists?(source_term, target_term, config["glossary"])
-      raise Logaling::TermError, "term '#{source_term}: #{target_term}' already exists in '#{config["glossary"]}'"
-    end
-
-    glossary.add(source_term, target_term, note)
-  rescue Logaling::CommandFailed, Logaling::TermError => e
-    say e.message
-  end
-
-  desc 'delete [SOURCE TERM] [TARGET TERM(optional)] [--force(optional)]', 'Delete term.'
-  method_option "force", type: :boolean, default: false
-  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
-    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='')
-    config = load_config_and_merge_options
-    repository.index
-
-    if repository.bilingual_pair_exists_and_has_same_note?(source_term, new_target_term, note, config["glossary"])
-      raise Logaling::TermError, "term '#{source_term}: #{new_target_term}' already exists in '#{config["glossary"]}'"
-    end
-
-    glossary.update(source_term, target_term, new_target_term, note)
-  rescue Logaling::CommandFailed, Logaling::TermError => e
-    say e.message
-  rescue Logaling::GlossaryNotFound => e
-    say "Try 'loga new or register' first."
-  end
-
-  desc 'lookup [TERM]', 'Lookup terms.'
-  def 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?
-      max_str_size = terms.map{|term| term[:source_term].size}.sort.last
-      run_pager
-      terms.each do |term|
-        target_string = "#{term[:target_term].bright}"
-        target_string <<  "\t# #{term[:note]}" unless term[:note].empty?
-        if repository.glossary_counts > 1
-          target_string << "\t"
-          glossary_name = "(#{term[:glossary_name]})"
-          if term[:glossary_name] == config["glossary"]
-            target_string << glossary_name.foreground(:white).background(:green)
-          else
-            target_string << glossary_name
-          end
-        end
-        source_string = term[:snipped_source_term].map{|word|  word.is_a?(Hash) ? word[:keyword].bright : word }.join
-        printf("  %-#{max_str_size+10}s %s\n", source_string, target_string)
-      end
-    else
-      "source-term <#{source_term}> not found"
-    end
-  rescue Logaling::CommandFailed, Logaling::TermError => e
-    say e.message
-  end
-
-  desc 'version', 'Show version.'
-  def version
-    say "logaling-command version #{Logaling::Command::VERSION}"
-  end
-
-  desc 'show', 'Show terms in glossary.'
-  def show
-    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)
-    repository.index
-    terms = repository.show_glossary(config["glossary"], config["source-language"], config["target-language"])
-    unless terms.empty?
-      run_pager
-      max_str_size = terms.map{|term| term[:source_term].size}.sort.last
-      terms.each do |term|
-        target_string = "#{term[:target_term]}"
-        target_string <<  "\t# #{term[:note]}" unless term[:note].empty?
-        printf("  %-#{max_str_size+10}s %s\n", term[:source_term], target_string)
-      end
-    else
-      "glossary <#{config['glossary']}> not found"
-    end
-
-  rescue Logaling::CommandFailed, Logaling::GlossaryDBNotFound => e
-    say e.message
-  end
-
-  desc 'list', 'Show glossary list.'
-  def list
-    repository.index
-    glossaries = repository.list
-    unless glossaries.empty?
-      run_pager
-      glossaries.each do |glossary|
-        printf("  %s\n", glossary)
-      end
-    else
-      "There is no registered glossary."
-    end
-
-  rescue Logaling::CommandFailed, Logaling::GlossaryDBNotFound => e
-    say e.message
-  end
-
-  private
-  def repository
-    @repository ||= Logaling::Repository.new(LOGALING_HOME)
-  end
-
-  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)
-    STDERR.puts(msg)
-    exit 1
-  end
-
-  def load_config_and_merge_options(required={})
-    config_list ||= {}
-    find_config.each{|type, path| config_list[type] = load_config(path)}
-    global_config = config_list["global_config"] ? config_list["global_config"] : {}
-    project_config = config_list["project_config"] ? config_list["project_config"] : {}
-
-    config = merge_options(project_config, global_config)
-    config = merge_options(options, config)
-
-    required.each do |required_option, message|
-      raise(Logaling::CommandFailed, message) unless config[required_option]
-    end
-
-    config
-  end
-
-  def merge_options(options, secondary_options)
-    config ||={}
-    config["glossary"] = options["glossary"] ? options["glossary"] : secondary_options["glossary"]
-    config["source-language"] = options["source-language"] ? options["source-language"] : secondary_options["source-language"]
-    config["target-language"] = options["target-language"] ? options["target-language"] : secondary_options["target-language"]
-    config
-  end
-
-  def find_config
-    config ||= {}
-    config["project_config"] = File.join(find_dotfile, 'config')
-    config["global_config"] = global_config_path if global_config_path
-    config
-  rescue Logaling::CommandFailed
-    config ||= {}
-    config["project_config"] = repository.config_path if repository.config_path
-    config["global_config"] = global_config_path if global_config_path
-    config
-  end
-
-  def load_config(config_path=nil)
-    config ||= {}
-    if config_path
-      File.readlines(config_path).map{|l| l.chomp.split " "}.each do |option|
-        key = option[0].sub(/^[\-]{2}/, "")
-        value = option[1]
-        config[key] = value
-      end
-    end
-    config
-  end
-
-  def find_dotfile
-    dir = Dir.pwd
-    searched_path = []
-    while(dir) do
-      path = File.join(dir, '.logaling')
-      if File.exist?(path)
-        return path
-      else
-        if dir != "/"
-          searched_path << dir
-          dir = File.dirname(dir)
-        else
-          raise(Logaling::CommandFailed, "Can't found .logaling in #{searched_path}")
-        end
-      end
-    end
-  end
-
-  def global_config_path
-    path = File.join(LOGALING_HOME, "config")
-    File.exist?(path) ? path : nil
-  end
-
-  def write_config(config_path, config)
-    File.open(config_path, 'w') do |fp|
-      fp.puts "--glossary #{config['glossary']}" if config['glossary']
-      fp.puts "--source-language #{config['source-language']}" if config['source-language']
-      fp.puts "--target-language #{config['target-language']}" if config['target-language']
-    end
-  end
-
-  # http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
-  def run_pager
-    return if ::RUBY_PLATFORM =~ /win32/
-    return unless STDOUT.tty?
-
-    read, write = IO.pipe
-
-    unless Kernel.fork # Child process
-      STDOUT.reopen(write)
-      STDERR.reopen(write) if STDERR.tty?
-      read.close
-      write.close
-      return
-    end
-
-    # Parent process, become pager
-    STDIN.reopen(read)
-    read.close
-    write.close
-
-    ENV['LESS'] = 'FSRX' # Don't page if the input is short enough
-
-    # wait until we have input before we start the pager
-    Kernel.select [STDIN]
-    pager = ENV['PAGER'] || 'less'
-    exec pager rescue exec "/bin/sh", "-c", pager
-  end
-end
+require "logaling/command/version"
+require "logaling/command/application"

data/lib/logaling/config.rb

@@ -0,0 +1,86 @@
+# Copyright (C) 2012  Koji SHIMADA <koji.shimada@enishi-tech.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+module Logaling
+  class Config
+    class << self
+      def load(config_path)
+        config = new
+        config.load(config_path)
+        config
+      end
+    end
+
+    def initialize(config={})
+      @config = config
+    end
+
+    def check_required_option(required={})
+      required.each do |required_option, message|
+        raise(Logaling::CommandFailed, message) unless @config[required_option]
+      end
+    end
+
+    def merge!(config)
+      keys.each do |key|
+        @config[key] = config[key] if config[key]
+      end
+    end
+
+    def load(config_path=nil)
+      if config_path && File.exist?(config_path)
+        File.readlines(config_path).map{|l| l.chomp.split " "}.each do |option|
+          key = option[0].sub(/^[\-]{2}/, "")
+          value = option[1]
+          @config[key] = value
+        end
+      end
+    end
+
+    def add(key, value)
+      raise Logaling::CommandFailed, "#{key} is unsupported option" unless support?(key)
+      merge!(key => value)
+    end
+
+    def save(config_path)
+      File.open(config_path, 'w') do |fp|
+        keys.each do |key|
+          fp.puts "--#{key} #{@config[key]}" if @config[key]
+        end
+      end
+    end
+
+    def glossary
+      @config["glossary"]
+    end
+
+    def source_language
+      @config["source-language"]
+    end
+
+    def target_language
+      @config["target-language"]
+    end
+
+    private
+    def keys
+      %w(glossary source-language target-language)
+    end
+
+    def support?(key)
+      keys.include?(key)
+    end
+  end
+end

data/lib/logaling/external_glossaries/freebsd_jpman.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright (C) 2012  Koji SHIMADA <koji.shimada@enishi-tech.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require 'open-uri'
+
+module Logaling
+  class FreebsdJpman < ExternalGlossary
+    description     'FreeBSD jpman(http://www.jp.freebsd.org/man-jp/)'
+    source_language 'en'
+    target_language 'ja'
+    output_format   'csv'
+
+    private
+    def convert_to_csv(csv)
+      url = 'http://www.jp.freebsd.org/man-jp/docs/wordlist.txt'
+      open(url,'r:iso-2022-jp') do |f|
+        f.each_line.map{|l| l.encode("utf-8")}.each do |line|
+          next if line =~ /^(#|\t)/
+          csv << line.split(/\t+| {5}/, 2).map(&:strip)
+        end
+      end
+    end
+  end
+end