natsukantou 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a75166acdb08099edebb39e02f78ca3bf04af192e3233f71067f1178950e964b
+  data.tar.gz: f5af8a9a4df6a4c82e61b7bef67ec6beb3bcac6b49db2dbe7ae46ce8385084ef
+SHA512:
+  metadata.gz: 3079ead2000c24c0c6e06156e6e775e56e233c11fe06a851e655d2b2197bb133b855ae901d8749520f9661ff37e89d759e318c2ad1e9516097fd7c14c0a6d125
+  data.tar.gz: 6612f175de419c560af5e221bbf3f9e074692a5fee2f3907dd800bddc7404db932201ffe69e191fadc87169ae8a6ce7df93700c48510dcbbfc96fc2bdbc28b1f

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,86 @@
+AllCops:
+  TargetRubyVersion: 2.7
+
+Style/StringLiterals:
+  Enabled: false
+  EnforcedStyle: double_quotes
+
+Style/HashSyntax:
+  Enabled: false
+
+Style/EmptyElse:
+  Enabled: false
+
+Style/BlockDelimiters:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
+
+Style/NegatedIf:
+  Enabled: false
+
+Style/UnlessLogicalOperators:
+  Enabled: true
+  EnforcedStyle: forbid_logical_operators
+
+Style/RescueStandardError:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/PercentLiteralDelimiters:
+  Enabled: false
+
+Style/WordArray:
+  Enabled: false
+
+Style/AccessorGrouping:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/LineLength:
+  Max: 120
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2022-07-05
+
+- Initial release

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in natsukantou.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"
+
+gem "rubocop", "~> 1.21"
+
+gem 'vcr', '~> 6.1'
+gem 'webmock', '~> 3.17'
+
+gem 'rib'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 lulalala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# Natsukantou
+
+Natsukantou is a human language translation library for XML documents.
+
+Its strength is to allow users to mix & match different middleware filters and translation services (e.g. DeepL).
+
+[Natsukantou](https://commons.wikimedia.org/wiki/File:NatsuKanTou_Oimatsu.jpg) (夏柑糖) is a Japanese sweet. It is made by taking out the pulp of an orange, "translating" it into a jelly, and then reinserting it back to the hollow peel.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add natsukantou
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install natsukantou
+
+## Usage
+
+If you want to just use it as a executable, run `natsukantou [XML_FILE]`.
+
+It's a wizard that guides you through setting up a translator configuration.
+
+Then it will translate the XML document.
+
+If you choose to save the config (`translator_config.rb`), next time you can reuse it by calling `natsukantou -c [CONFIG_FILE] [XML_FILE]`.
+
+## Feature
+
+### Translators
+
+* [DeepL API](https://www.deepl.com/pro-api)
+* [みんなの自動翻訳＠TexTra](https://mt-auto-minhon-mlt.ucri.jgn-x.jp/)
+
+### Middlewares
+
+#### SubstitudeGlossary
+
+An alternative when glossary isn't supported by the translator. This middleware would substitude glossaries and wrap replaced terms with `<skip>` tag to mark it as being translated (which is supported by DeepL). It supports glossary file in TSV format.
+
+#### HandleRubyMarkup
+
+[Ruby markup](https://www.w3.org/International/articles/ruby/markup.en.html) is not about Ruby the programming language, but the HTML feature: annotations in Japanese and Chinese content that are rendered alongside base text.
+
+A phrase in ruby markup are often segmented by characters, making them less translatable. This middleware flattens ruby markup to just the base text to avoid such issue.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Middleware
+
+Natsukantou aims to be flexible by utilizing the [middleware pattern](https://github.com/mitchellh/middleware). Essentially it allows the user to cherry-pick components (translator or middleware) when needed, to improve translation.
+
+To develop your own component, create a class which responds to `call` with an `env` variable.
+
+* `call` needs to trigger `@app.call(env)` to continue to the next component.
+* `env` is a `Natsukantou::Env`, which is a special Hash. It provides convenience methods `dom`, `lang_from` and `lang_to`. You are also free to add key/values into it.
+  * `lang_from` and `lang_to` are `Natsukantou::LanguageCode`, representing ISO 639-1 language codes. Its `is?` method allows the following comparison:
+    `Natsukantou::LanguageCode.new("en-gb").is?("en") #=> true`
+* The wizard to be made aware of a new component by using `autoload_and_register`:
+  * To infer config prompt, `initialize` needs to accept keyword arguments for all except the first parameter (`app`), and documented with Yard.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitLab at https://gitlab.com/lulalala/natsukantou.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/exe/natsukantou

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "natsukantou"
+require 'tty-prompt'
+require 'optparse'
+require 'natsukantou/setup/config_load_or_prompt'
+require 'natsukantou/setup/write_prompt'
+
+options = {}
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: natsukantou [options] XML_FILE"
+
+  opts.on("-c", "--config CONFIG_FILE",
+    "Config file generated after the first time natsukantou is run") do |v|
+    options[:config_path] = v
+  end
+end
+optparse.parse!
+
+if ARGV.empty?
+  puts optparse
+  exit(-1)
+end
+
+begin
+  xml_path = ARGV[0]
+  dom = Oga.parse_xml(File.read(xml_path))
+rescue Errno::ENOENT
+  warn 'XML not found'
+  return
+end
+
+prompt = TTY::Prompt.new
+
+Natsukantou::Setup::ConfigLoadOrPrompt.new.execute(
+  prompt: prompt,
+  config_path: options[:config_path],
+)
+
+lang_from = prompt.ask("Language code to translate from?")
+lang_to = prompt.ask("Language code to translate to?")
+
+env = Natsukantou::Env.new(
+  dom: dom, lang_from: lang_from, lang_to: lang_to
+)
+
+NatsukantouTranslator.call(env)
+
+Natsukantou::Setup::WritePrompt.new.execute(
+  prompt: prompt,
+  content: env[:dom].to_xml,
+  origin_path: xml_path,
+  lang_to: env.lang_to.code,
+)

data/lib/natsukantou/deep_l.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'deepl'
+
+# Machine translator
+#
+# DeepL
+# https://www.deepl.com
+module Natsukantou
+  class DeepL
+    include UtilityBase
+
+    # @param app [Hash]
+    # @param auth_key [String] authentication key
+    # @param host [String] url of API endpoint
+    # @param version [String] API version, see https://www.deepl.com/docs-api/accessing-the-api/api-versions/
+    # @param request_params [Hash] other optional request parameters, see https://www.deepl.com/docs-api/translating-text/request/
+    def initialize(
+      app,
+      auth_key:,
+      host: "https://api-free.deepl.com",
+      version: "v2",
+      request_params: {}
+    )
+      @app = app
+      @request_params = {
+        tag_handling: 'xml',
+        ignore_tags: 'skip',
+      }.merge(request_params)
+
+      ::DeepL.configure do |config|
+        config.auth_key = auth_key
+        config.host = host
+        config.version = version
+      end
+    end
+
+    attr_reader :request_params
+
+    def call(env)
+      result = ::DeepL.translate(
+        env.dom.to_xml,
+        env.lang_from.code.upcase,
+        env.lang_to.code.upcase,
+        request_params,
+      ).to_s
+
+      env[:dom] = dom(result)
+
+      @app.call(env)
+    end
+  end
+end

data/lib/natsukantou/handle_ruby_markup.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Ruby markup is not about Ruby the programming language,
+# but the HTML feature: annotations in Japanese and Chinese content
+# that are rendered alongside base text.
+# https://www.w3.org/International/articles/ruby/markup.en.html
+#
+# A phrase in ruby markup are often segmented by characters,
+# making them less translatable.
+# This flattens ruby markup to just the base text to avoid such issue.
+module Natsukantou
+  class HandleRubyMarkup
+    include UtilityBase
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env[:dom].css('ruby').each(&method(:process_node))
+
+      @app.call(env)
+    end
+
+    private
+
+    def process_node(node)
+      node.css('rt').each(&:remove)
+      node.inner_text = node.text.gsub(' ', '')
+    end
+  end
+end

data/lib/natsukantou/minhon.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'oauth'
+require 'json'
+
+# Machine translator
+#
+# みんなの自動翻訳＠TexTra (Min'na no Jidou Hon'yaku @ TexTra)
+# https://mt-auto-minhon-mlt.ucri.jgn-x.jp
+module Natsukantou
+  class Minhon
+    include UtilityBase
+
+    # @param app [Hash]
+    # @param name [String] login ID
+    # @param key [String] API Key
+    # @param secret [String] authentication secret
+    # @param url [String] request URL of translator API endpoint
+    # @param request_params [Hash] other optional request parameters
+    #
+    # @param translate_by_section [String] CSS selector to translate matched elements one by one.
+    #   Minhon often returns invalid XML if xml is large.
+    #   To bypass this limitation, one can specify a css path (e.g. "body>p") to translate in smaller chunks.
+    def initialize(
+      app, name:, key:, secret:, url:, request_params: {},
+      translate_by_section: nil
+    )
+      @app = app
+      @key = key
+      @secret = secret
+      @url = url
+      @request_params = request_params.merge(name: name, key: key)
+
+      ### Non request related setting
+      @translate_by_section = translate_by_section
+    end
+
+    attr_reader :request_params, :env
+    attr_reader :key, :secret, :url
+    attr_reader :translate_by_section
+
+    def call(env)
+      @env = env
+
+      if translate_by_section
+        env[:dom].css(translate_by_section).each do |node|
+          next if node.text.empty?
+
+          translated_xml = translate(node.to_xml)
+          node.replace(dom_node(translated_xml))
+        end
+      else
+        translated_xml = translate(env[:dom].to_xml)
+        env[:dom] = dom(translated_xml)
+      end
+
+      @app.call(env)
+    end
+
+    private
+
+    def translate(text)
+      response = client.post(url, text: text, **request_params)
+
+      body = JSON.parse(response.body)
+
+      translated_xml = body.dig('resultset', 'result', 'text')
+
+      temp_fix(env, translated_xml)
+
+      translated_xml
+    rescue Net::OpenTimeout
+      sleep 10
+      retry
+    end
+
+    def client
+      @client ||= OAuth::AccessToken.new(OAuth::Consumer.new(key, secret))
+    end
+
+    def temp_fix(env, text)
+      text.tr!('麵', '面') if env[:lang_to].is?('zh-TW')
+    end
+  end
+end

data/lib/natsukantou/setup/config_load_or_prompt.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Natsukantou
+  module Setup
+    class ConfigLoadOrPrompt
+      def execute(prompt:, config_path:)
+        begin
+          load(config_path) if config_path
+        rescue LoadError # rubocop:disable Lint/SuppressedException
+        end
+
+        if !defined?(NatsukantouTranslator)
+          require_relative 'config_prompt'
+          config_content = ConfigPrompt.new.execute
+
+          if prompt.yes?("\nConfig complete. Do you want to save it for later reuse?")
+            File.write('translator_config.rb', config_content)
+            puts "Saved as translator_config.rb, which you can specify with -c flag next time.\n\n"
+          end
+
+          Kernel.eval(config_content)
+        end
+      end
+    end
+  end
+end

data/lib/natsukantou/setup/config_prompt.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require 'yard'
+require 'erb'
+require 'json'
+require 'delegate'
+
+YARD::Tags::Library.define_tag(
+  'Method parameters which should be entered as Ruby expression',
+  :fields_to_input_ruby
+)
+
+module Natsukantou
+  module Setup
+    class Component
+      attr_reader :name, :klass,
+        :initialize_method, :initialize_method_param_tags
+
+      def initialize(name, path)
+        @name = name
+
+        YARD.parse(path)
+
+        @klass = YARD::Registry.all.find do |item|
+          item.type == :class && item.name == name
+        end
+
+        @initialize_method = klass.meths.find do |item|
+          item.type == :method && item.name == :initialize
+        end
+
+        @initialize_method_param_tags = @initialize_method.tags('param')
+          .reject { |tag| tag.name == 'app' }
+          .map { |tag| MethodParamTagDecorator.new(tag) }
+
+        YARD::Registry.clear
+      end
+    end
+
+    # Both a decorator to Yard tag object,
+    # and where the user input is stored.
+    # Assumption: only dealing with keyword argument
+    class MethodParamTagDecorator < SimpleDelegator
+      attr_accessor :user_input
+
+      def initialize_method
+        object
+      end
+
+      def enter_ruby?
+        return true if type == 'Hash'
+
+        list = initialize_method.tag('fields_to_input_ruby')
+
+        return false if list.nil?
+
+        list.text.split(' ').include?(name)
+      end
+
+      def convert
+        case type
+        when Integer
+          :integer
+        when Float
+          :float
+        else
+          nil # do not convert and assume Ruby code
+        end
+      end
+
+      def default_value_in_string
+        initialize_method.parameters.find { |p| p.first == "#{name}:" }&.last
+      end
+
+      # tty-prompt's `value` field requires String
+      def default_value_in_tty
+        if type == 'String'
+          JSON.parse(default_value_in_string)
+        else
+          default_value_in_string
+        end
+      end
+
+      def user_input_in_erb
+        if enter_ruby?
+          user_input
+        else
+          user_input.inspect
+        end
+      end
+    end
+
+    class ConfigPrompt
+      def initialize
+        @prompt = TTY::Prompt.new
+
+        registry = Natsukantou::Setup::Registry.instance
+
+        @translators = registry.translators.map do |args|
+          Natsukantou::Setup::Component.new(*args)
+        end
+
+        @filters = registry.middlewares.map do |args|
+          Natsukantou::Setup::Component.new(*args)
+        end
+
+        @config = {}
+      end
+
+      attr_reader :prompt, :translators, :filters, :config
+      attr_reader :know_ruby
+
+      def execute
+        ask
+        output
+      end
+
+      def ask
+        @know_ruby = prompt.yes?('Do you know Ruby or JSON syntax?')
+
+        translator = prompt.select(
+          "Choose translation engine:",
+          translators.map { |t| [t.name, t] }.to_h
+        )
+
+        config[:translator] = {
+          component: translator,
+          parameters: ask_initialize_parameters(translator)
+        }
+
+        config[:filters] = []
+
+        selected_filters = prompt.multi_select(
+          "Select one or many filters (using spacebar):",
+          filters.map { |t| [t.name, t] }.to_h
+        )
+
+        selected_filters.each do |filter|
+          config[:filters] << {
+            component: filter,
+            parameters: ask_initialize_parameters(filter)
+          }
+        end
+      end
+
+      def output
+        template = ERB.new(
+          File.read((File.expand_path 'output.erb', __dir__)),
+          trim_mode: "<>-"
+        )
+        template.result(binding)
+      end
+
+      private
+
+      def ask_initialize_parameters(component)
+        puts "\n## Parameters for #{component.name} ---\n"
+
+        answers = []
+
+        component.initialize_method_param_tags.each do |tag|
+          next if tag.enter_ruby? && !know_ruby
+
+          ask_params = {}
+
+          printf "Enter '#{tag.name}', #{tag.text}"
+
+          ask_params[:convert] = tag.convert if tag.convert
+
+          default = tag.default_value_in_string
+          if default == 'nil'
+            printf " (optional)"
+          elsif default
+            printf " (with default)"
+            ask_params[:value] = tag.default_value_in_tty
+          else
+            ask_params[:required] = true
+            printf " (required)"
+          end
+
+          if tag.enter_ruby?
+            printf("\nEnter Ruby expression (#{tag.type}), or press Enter to skip")
+          end
+
+          printf ":\n"
+
+          result = prompt.ask(**ask_params)
+
+          next if result.nil?
+
+          # Check if provided default value was changed, and if not,
+          # the param can be ignored by relying on method declaration's default value.
+          next if ask_params.key?(:value) && result == tag.default_value_in_tty
+
+          tag.user_input = result
+          answers << tag
+        end
+
+        answers
+      end
+    end
+  end
+end

data/lib/natsukantou/setup/output.erb

@@ -0,0 +1,10 @@
+::NatsukantouTranslator = Middleware::Builder.new do
+<% config[:filters].each do |component| -%>
+  use Natsukantou::<%= component[:component].name -%>
+<% component[:parameters].each do |tag| -%>, <%= tag.name %>: <%= tag.user_input_in_erb -%><% end %>
+<% end %>
+<% config[:translator].tap do |component| -%>
+  use Natsukantou::<%= component[:component].name -%>
+<% component[:parameters].each do |tag| -%>, <%= tag.name %>: <%= tag.user_input_in_erb -%><% end %>
+<% end -%>
+end

data/lib/natsukantou/setup/registry.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+module Natsukantou
+  module Setup
+    class Registry
+      include Singleton
+
+      attr_reader :translators
+      attr_reader :middlewares
+
+      def initialize
+        @translators = []
+        @middlewares = []
+      end
+
+      def register(type, klass, path)
+        case type
+        when :translator
+          translators << [klass, path]
+        when :middleware
+          middlewares << [klass, path]
+        end
+      end
+    end
+  end
+end

data/lib/natsukantou/setup/write_prompt.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rake/ext/string'
+
+module Natsukantou
+  module Setup
+    class WritePrompt
+      def execute(prompt:, content:, origin_path:, lang_to:)
+        result_path = prompt.ask(
+          'Where do you want to save the result?',
+          value: origin_path.pathmap("%X.#{lang_to}%x")
+        )
+
+        File.write(result_path, content)
+      rescue Errno::EISDIR
+        warn 'Specified path is a directory.'
+        retry
+      end
+    end
+  end
+end

data/lib/natsukantou/substitude_glossary.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'tsv'
+
+# Glossary isn't supported in some language
+# combinations (e.g. DeepL ja to zh).
+# We can however substitude terms prior to translation
+# and mark it as translated.
+#
+# Support TSV format
+module Natsukantou
+  class SubstitudeGlossary
+    include UtilityBase
+
+    LANGUAGES_WITHOUT_WORD_DIVIDERS = %w{
+      ja zh th lo
+    }.freeze
+
+    # @param filepath [String] path to TSV glossary file.
+    # @param glossary [Array(Array(String, String))] array representing glossary, e.g. [['book', '本']]
+    # @fields_to_input_ruby glossary
+    def initialize(app, filepath: nil, glossary: [])
+      @app = app
+
+      @glossary = glossary
+      @glossary.concat(parse_tsv(filepath)) if filepath
+
+      @glossary.uniq! { |row| row[0] }
+
+      # Longer term has higher priority
+      @glossary.sort_by! { |row| -row[0].length }
+    end
+
+    attr_reader :glossary, :regex, :replacement_mapping
+
+    def call(env)
+      prepare_regular_expression(env)
+
+      env[:dom].each_node(&method(:process_node))
+
+      @app.call(env)
+    end
+
+    def prepare_regular_expression(env)
+      source_terms = glossary.map(&:first)
+      source_terms.map! { |w| /\b#{w}\b/ } if with_space_divider?(env)
+      @regex = Regexp.union(*source_terms)
+
+      @replacement_mapping = glossary.to_h
+      @replacement_mapping.transform_values! { |v| "<skip>#{v}</skip>" }
+    end
+
+    private
+
+    def parse_tsv(path)
+      TSV.parse_file(path).without_header.map do |row|
+        [row[0], row[1]]
+      end
+    end
+
+    def process_node(node)
+      return if !node.is_a?(Oga::XML::Text)
+
+      new_text = node.text.gsub(regex, replacement_mapping)
+
+      return if new_text == node.text
+
+      dom(new_text).children.reverse_each do |new_node|
+        node.after(new_node)
+      end
+      node.remove
+    end
+
+    def with_space_divider?(env)
+      LANGUAGES_WITHOUT_WORD_DIVIDERS.none? do |lang|
+        env[:lang_from].is?(lang)
+      end
+    end
+  end
+end

data/lib/natsukantou/utility/env.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+# Environment of the middleware,
+# which is just a specialized hash with convenience methods,
+# and converts language settings for ease of comparison.
+module Natsukantou
+  class Env < SimpleDelegator
+    # @param [Hash] env
+    # @option env [Oga::XML::Document] dom
+    # @option lang_from [String] Language code in ISO 639-1 to be translated from.
+    # @option lang_to [String] Language code in ISO 639-1 to be translated to.
+    def initialize(env)
+      # Convert languages
+      [:lang_from, :lang_to].each do |key|
+        env[key] = LanguageCode.new(env.fetch(key))
+      end
+
+      # Required keys
+      [:dom].each do |key|
+        env.fetch(key)
+      end
+
+      super(env)
+    end
+
+    def dom
+      self[:dom]
+    end
+
+    def lang_from
+      self[:lang_from]
+    end
+
+    def lang_to
+      self[:lang_to]
+    end
+  end
+end

data/lib/natsukantou/utility/language_code.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Natsukantou
+  class LanguageCode
+    def initialize(code)
+      @code = code.downcase
+      @main, @sub = @code.split('-')
+
+      if @main.length != 2
+        raise 'Language code shoul be in the form of xx or xx-yy'
+      end
+    end
+
+    attr_reader :code, :main, :sub
+
+    def is?(other_code)
+      other = self.class.new(other_code)
+
+      return false if other.main != main
+
+      return true if other.sub.nil?
+
+      sub ? other.sub == sub : false
+    end
+  end
+end

data/lib/natsukantou/utility/logger.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Natsukantou
+  module Logger
+    def logger
+      ::Natsukantou.logger
+    end
+  end
+end

data/lib/natsukantou/utility/parse_xml.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Natsukantou
+  module ParseXml
+    # @param xml [String]
+    # @return [Oga::XML::Document]
+    def dom(xml)
+      Oga.parse_xml(xml, strict: true)
+    rescue => e
+      logger.error(e.message)
+
+      Oga.parse_xml(xml)
+    end
+
+    # @param xml [String]
+    # @return [Oga::XML::Node]
+    def dom_node(xml)
+      dom = dom(xml)
+
+      if dom.children.size != 1
+        logger.error("Parsed XML contains more than one root element:")
+        logger.error(xml)
+      end
+
+      dom.children.first
+    end
+  end
+end

data/lib/natsukantou/utility/utility_base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'parse_xml'
+require_relative 'logger'
+
+module Natsukantou
+  module UtilityBase
+    include ParseXml
+    include Logger
+  end
+end

data/lib/natsukantou/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Natsukantou
+  VERSION = "0.1.0"
+end

data/lib/natsukantou.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'middleware'
+require 'oga'
+
+require_relative "natsukantou/version"
+require_relative "natsukantou/setup/registry"
+require_relative "natsukantou/utility/language_code"
+require_relative "natsukantou/utility/env"
+
+module Natsukantou
+  class Error < StandardError; end
+
+  # While autoloading in Ruby, also keep it in the local registry,
+  # which can be used in setup prompt.
+  def self.autoload_and_register(type, constant, path)
+    Setup::Registry.instance.register(
+      type,
+      constant,
+      (File.expand_path "../#{path}.rb", __FILE__)
+    )
+
+    autoload(constant, path)
+  end
+
+  # Misc
+  autoload :UtilityBase, "natsukantou/utility/utility_base"
+
+  # Translators
+  autoload_and_register :translator, :DeepL, "natsukantou/deep_l"
+  autoload_and_register :translator, :Minhon, "natsukantou/minhon"
+
+  # Middlewares
+  autoload_and_register :middleware, :SubstitudeGlossary, "natsukantou/substitude_glossary"
+  autoload_and_register :middleware, :HandleRubyMarkup, "natsukantou/handle_ruby_markup"
+
+  def self.logger
+    @logger ||= ::Logger.new($stdout)
+  end
+end

data/natsukantou.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "lib/natsukantou/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "natsukantou"
+  spec.version = Natsukantou::VERSION
+  spec.authors = ["lulalala"]
+  spec.email = ["mark@goodlife.tw"]
+
+  spec.summary = "human language translation library for XML documents"
+  spec.description = "human language translation library for XML documents, supporting DeepL"
+  spec.homepage = "https://gitlab.com/lulalala/natsukantou"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = 'https://gitlab.com/lulalala/natsukantou/-/releases'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "middleware", "~> 0.1.0"
+  spec.add_dependency "oga", "~> 3.4"
+  spec.add_dependency "tsv", "~> 1.0"
+
+  spec.add_dependency "tty-prompt", "~> 0.23"
+  spec.add_dependency "yard", "~> 0.9"
+
+  # DeepL
+  spec.add_dependency "deepl-rb", "~> 2.5"
+
+  # Minhon
+  spec.add_dependency 'oauth', '~> 0.5.1'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/sig/natsukantou.rbs

@@ -0,0 +1,4 @@
+module Natsukantou
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: natsukantou
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- lulalala
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-09-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: oga
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: tsv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.23'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: deepl-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.1
+description: human language translation library for XML documents, supporting DeepL
+email:
+- mark@goodlife.tw
+executables:
+- natsukantou
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/natsukantou
+- lib/natsukantou.rb
+- lib/natsukantou/deep_l.rb
+- lib/natsukantou/handle_ruby_markup.rb
+- lib/natsukantou/minhon.rb
+- lib/natsukantou/setup/config_load_or_prompt.rb
+- lib/natsukantou/setup/config_prompt.rb
+- lib/natsukantou/setup/output.erb
+- lib/natsukantou/setup/registry.rb
+- lib/natsukantou/setup/write_prompt.rb
+- lib/natsukantou/substitude_glossary.rb
+- lib/natsukantou/utility/env.rb
+- lib/natsukantou/utility/language_code.rb
+- lib/natsukantou/utility/logger.rb
+- lib/natsukantou/utility/parse_xml.rb
+- lib/natsukantou/utility/utility_base.rb
+- lib/natsukantou/version.rb
+- natsukantou.gemspec
+- sig/natsukantou.rbs
+homepage: https://gitlab.com/lulalala/natsukantou
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://gitlab.com/lulalala/natsukantou
+  source_code_uri: https://gitlab.com/lulalala/natsukantou
+  changelog_uri: https://gitlab.com/lulalala/natsukantou/-/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: human language translation library for XML documents
+test_files: []