natsukantou 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eeacff02b528faa718685f0538b9e81d953874f411a0966c3ab4340d9a0a0aee
-  data.tar.gz: dd2b7056ab77874e2783f8e6f7f4e6691a5dfe37022ebc4f274461fa912c5536
+  metadata.gz: cad5c6f1f3972aa1ea7f4d793ff42bd3f08b96b292a3475ebc8be378d68e3e8b
+  data.tar.gz: cbcdce19fe10dcb3e6658959c9be61363a3ab30aa3096465c41a069811fb2cee
 SHA512:
-  metadata.gz: ad4f341ac35371d2f63850c7d2f327770e25ba5e1b6af1e8b9bd2acf8bc0cd3c85db52b9bbf1fa7b4742b22df44d7351a16ebccd74f5dd87649f053932c4fa69
-  data.tar.gz: 86c26ea7575ff81d8c1d57baa37c9f5b84d9b8ef4a0d7a91db581cc76c0ca710347644b5ebe8a18419477400d6360554744c36760f638c7e715aba6eca95abc4
+  metadata.gz: 04e7580ca7090cd615ce9e51432c97b7159824394dbc0cedea74c4426426b7e78101d97f121fda63d02ad023907df6e2c3cbfab9349b08789f3dc4346eecd50f
+  data.tar.gz: 2cd1b3c1d8456a8c586baddf78711f6a3e52a8c8e3cafe16eadbb49bf0306ca5af2fd47378aec514aab6aea2f6ae046b9a58f323cd5f31f3564658baee74e7c8

data/.claude/skills/add-translator-backend/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: add-translator-backend
+description: Use when adding a new translation service backend (e.g. "add Google Translate", "add Claude as a translator") or a new middleware filter to Natsukantou. Covers the middleware contract, the lang-attribute invariant, wizard registration, gemspec, and the required specs.
+---
+
+# Add a translator backend (or middleware filter)
+
+A backend is just a middleware class; there is no base class to inherit. Full annotated
+example (class + spec): [example-backend.md](example-backend.md). Closest real models:
+`lib/natsukantou/open_ai.rb` (chunked translation), `lib/natsukantou/deep_l.rb`
+(whole-document translation).
+
+## Procedure
+
+1. **Create `lib/natsukantou/<snake_name>.rb`** with class `Natsukantou::<CamelName>`:
+   - `include UtilityBase` (gives `dom`, `dom_node`, `logger`).
+   - `initialize(app, **keyword_args)` — `app` is the only positional arg. Store it as
+     `@app`. Every other arg must be a keyword arg.
+   - **Doc-comment rules are load-bearing** — the setup wizard YARD-parses this file at
+     runtime. Follow `.claude/skills/wizard-config-conventions/SKILL.md` (short version:
+     `@param` tag for every kwarg except `app`; string defaults in double quotes).
+   - `call(env)` must, in order:
+     a. Translate `env.dom.to_xml` whole, **or** if you support `translate_by_section:`
+        (a CSS selector), loop `env[:dom].css(selector)` skipping nodes with empty
+        `.text`, replacing each via `node.replace(dom_node(translated_xml))`.
+     b. Set `env[:dom].lang = env[:lang_to].code` — required invariant, spec-enforced.
+     c. End with `@app.call(env)`.
+   - Language codes: `env.lang_from.code` is lowercase `xx` or `xx-yy`; re-case for your
+     API if needed (DeepL upcases). Compare with `env[:lang_to].is?('zh-TW')` (asymmetric:
+     `en-gb`.is?(`en`) → true, reverse → false).
+   - Parse API responses with `dom(...)`/`dom_node(...)`, never `Oga.parse_xml`.
+   - Keep to the Ruby floor in the gemspec's `required_ruby_version`; `.gitlab-ci.yml`
+     lists the versions CI builds.
+
+2. **Register it** in `lib/natsukantou.rb` under the `# Translators` (or `# Middlewares`)
+   section:
+   ```ruby
+   autoload_and_register :translator, :CamelName, "natsukantou/snake_name"
+   ```
+
+3. **Add the API client gem** (if any) to `natsukantou.gemspec` as
+   `spec.add_dependency 'gem-name', '~> x.y'` with a comment naming the service
+   (match the existing `# DeepL` / `# Minhon` style), then `bundle install`.
+
+4. **Write the unit spec** `spec/natsukantou/<snake_name>_spec.rb` — see
+   [example-backend.md](example-backend.md). Minimum: `:middleware` metadata, stub the
+   private `translate` method (or the client), and `include_examples 'lang attribute'`
+   (this is what enforces invariant 1b). No network, no secrets, no VCR needed.
+
+5. **README.md**: add the service to the `### Translators` (or `### Middlewares`) list.
+
+6. Do NOT touch `CHANGELOG.md` / `version.rb` unless asked to cut a release.
+
+## Verify
+
+```sh
+bundle exec rspec spec/natsukantou/<snake_name>_spec.rb   # all green
+bundle exec rspec    # no failures beyond the baseline you saw before starting
+bundle exec rubocop lib/natsukantou/<snake_name>.rb spec/natsukantou/<snake_name>_spec.rb
+```
+
+Then confirm the wizard can parse your params (should print each kwarg with its default,
+no exception):
+
+```sh
+bundle exec ruby -Ilib -e '
+require "natsukantou"
+require "natsukantou/setup/config_prompt"
+comp = Natsukantou::Setup::Component.new(:CamelName, "lib/natsukantou/snake_name.rb")
+comp.initialize_method_param_tags.each do |t|
+  d = t.default_value_in_string
+  p [t.name, (d && d != "nil") ? t.default_value_in_tty : d]
+end
+'
+```
+
+## Gotchas
+
+- Copying `open_ai.rb` as a template? Don't copy its trailing `ChatGPT = OpenAi` alias
+  line — the `:ChatGpt` registry entry does not match it.
+- A `Hash`-typed param (like `request_params`) is fine — the wizard treats it as
+  raw-Ruby input automatically.
+- If the service returns invalid XML on large documents (Minhon does), offer
+  `translate_by_section:` instead of trying to repair output.

data/.claude/skills/add-translator-backend/example-backend.md

@@ -0,0 +1,137 @@
+# Reference: a complete backend + unit spec
+
+Modeled on `lib/natsukantou/open_ai.rb` and `spec/natsukantou/open_ai_spec.rb`.
+Replace `Acme` / `acme` throughout.
+
+## `lib/natsukantou/acme.rb`
+
+```ruby
+# frozen_string_literal: true
+
+require 'acme-client-gem'   # the API client added to natsukantou.gemspec
+
+# Machine translator
+#
+# Acme Translate
+# https://acme.example.com
+module Natsukantou
+  class Acme
+    include UtilityBase
+
+    # @param app [Hash]
+    # @param api_key [String] API key for Acme Translate
+    # @param host [String] URL of API endpoint
+    # @param request_params [Hash] other optional request parameters
+    #
+    # @param translate_by_section [String] CSS selector to translate matched elements
+    #   one by one, e.g. "body>p", for services that choke on large documents.
+    def initialize(
+      app, api_key:,
+      host: "https://api.acme.example.com",   # String defaults MUST be double-quoted
+      request_params: {},
+      translate_by_section: nil                # nil default => optional in the wizard
+    )
+      @app = app
+      @api_key = api_key
+      @host = host
+      @request_params = request_params
+
+      ### Non request related setting
+      @translate_by_section = translate_by_section
+    end
+
+    attr_reader :env
+    attr_reader :api_key, :host, :request_params
+    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)) if translated_xml
+        end
+      else
+        translated_xml = translate(env[:dom].to_xml)
+        env[:dom] = dom(translated_xml)
+      end
+
+      # Required invariant — enforced by the 'lang attribute' shared example.
+      env[:dom].lang = env[:lang_to].code
+
+      @app.call(env)
+    end
+
+    private
+
+    # Keep the network call isolated in one private method named `translate`,
+    # so the unit spec can stub it (the existing specs rely on this shape).
+    def translate(text)
+      # env.lang_from.code / env.lang_to.code are lowercase "xx" or "xx-yy";
+      # upcase or map here if the API needs it.
+      client.translate(
+        text,
+        from: env.lang_from.code,
+        to: env.lang_to.code,
+        **request_params,
+      )
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      logger.error(e.message)
+      nil
+    end
+
+    def client
+      @client ||= ::AcmeClient.new(api_key: api_key, host: host)
+    end
+  end
+end
+```
+
+Registration line for `lib/natsukantou.rb` (under `# Translators`):
+
+```ruby
+autoload_and_register :translator, :Acme, "natsukantou/acme"
+```
+
+## `spec/natsukantou/acme_spec.rb`
+
+```ruby
+# frozen_string_literal: true
+
+require 'rspec'
+
+RSpec.describe Natsukantou::Acme, :middleware do
+  let(:dom) { Oga.parse_xml('<foo>surface</foo>') }
+  let(:app) { ->(env) { env } }
+
+  subject do
+    described_class.new(
+      app,
+      api_key: 'api_key',
+    )
+  end
+
+  context 'lang attribute' do
+    before do
+      allow(subject).to receive(:translate).and_return(html)
+    end
+
+    include_examples 'lang attribute'
+  end
+end
+```
+
+Notes on the spec machinery:
+
+- `:middleware` metadata pulls in `spec/support/middleware_context.rb`
+  (default env `en → ja`, `expect_xml_to_eq` helper). The `let(:app)` /
+  `subject` above override its defaults where needed.
+- `include_examples 'lang attribute'` comes from `spec/support/lang_attribute.rb`;
+  it defines `html` and asserts the `lang` attribute lands on the `<html>` node.
+  It requires the translation itself to be stubbed — hence the `allow(...)`.
+- `RSpec.describe`, never bare `describe` — `disable_monkey_patching!` is on.
+- No VCR/request spec is required for a new backend — the unit spec suffices; if you add
+  one, follow `.claude/skills/run-and-record-specs/SKILL.md`.

data/.claude/skills/run-and-record-specs/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: run-and-record-specs
+description: Use when running the test suite, when a spec fails with VCR::Errors::UnhandledHTTPRequestError, when adding or re-recording a VCR cassette, or when specs complain about secrets. Covers VCR replay, re-recording, and the secret-handling rules.
+---
+
+# Run the specs / work with VCR cassettes
+
+## Running
+
+```sh
+bundle exec rspec
+bundle exec rspec <files touched>
+bundle exec rake # spec + rubocop, same as GitLab CI
+```
+
+If `VCR::Errors::UnhandledHTTPRequestError` is raised,
+do not loosen VCR matchers globally or delete the cassette.
+Re-record it (below), and only when the user asks.
+
+Rubocop: run `bundle exec rubocop <files touched>` rather than chasing the full-repo output.
+
+## Spec setup (spec/spec_helper.rb)
+
+- Unit specs (`spec/natsukantou/`) stub all network — no secrets or cassettes needed.
+- Request specs (`spec/requests/`) tag `:vcr`; the cassette path is derived from the
+  describe/context strings, e.g. `RSpec.describe 'DeepL'` + `it 'translates'` →
+  `spec/cassettes/DeepL/translates.yml`. Renaming an example orphans its cassette.
+- Record mode is `:once`: cassette exists → replay only; missing → record (needs real
+  creds). webmock blocks all other real HTTP.
+- Secrets: specs read the `SECRET` hash from `spec/secret.rb` (gitignored, real keys).
+  If absent, `spec/secret.example.rb` (dummy values) is loaded — replay still works
+  because requests are matched on method+URI, not credentials.
+- Every value in `SECRET` is scrubbed from recorded cassettes via
+  `filter_sensitive_data` → placeholders like `<key>`, `<secret>`, `<url>`. Caveat:
+  `minhon` and `deepl` both use the key name `key`, so both values map to the same
+  `<key>` placeholder — fine for replay of existing specs, but rename the key in
+  `SECRET` if you add a section whose overlap would be ambiguous.
+
+## Recording cassette
+
+1. Ensure `spec/secret.rb` exists (based from `spec/secret.example.rb`) with real credentials. Ask the user for keys — never invent them).
+2. When re-recording, delete only the target cassette
+3. Run just that spec example, which performs a real, billable API call.
+4. **Scrub check** — the real secret must not appear in the new cassette, e.g.:
+   ```sh
+   grep -rF "$(ruby -e 'require_relative "spec/secret"; print SECRET.dig(:deepl, :key)')" spec/cassettes/ && echo LEAKED || echo clean
+   ```
+5. Re-run the spec to confirm green replay, then commit the cassette YAML only.
+
+Never commit or print `spec/secret.rb`; never hardcode credentials in specs — always go through `SECRET.dig(...)`.
+
+## Verify
+
+`bundle exec rspec` → nothing failing that was not already failing before you started.
+A new failure is your change.

data/.claude/skills/wizard-config-conventions/SKILL.md

@@ -0,0 +1,69 @@
+---
+name: wizard-config-conventions
+description: Use before editing the `initialize` method or its doc comment on any class under lib/natsukantou/ (translators/middlewares), and when authoring or editing a translator_config.rb. The setup wizard YARD-parses these doc comments at runtime — a wrong quote style or missing @param silently breaks the wizard and no test catches it.
+---
+
+# Wizard schema rules (YARD doc comments are executable)
+
+`Setup::ConfigPrompt` (`lib/natsukantou/setup/config_prompt.rb`) builds the interactive
+setup wizard by YARD-parsing each registered component's **source file** and reading the
+`@param` tags on `initialize`. The file path comes from `autoload_and_register` in
+`lib/natsukantou.rb`. Consequences when touching any component's `initialize`:
+
+- Every keyword argument except `app` needs a `@param name [Type] description` tag.
+  The description becomes the on-screen prompt text ("Enter 'auth_key', <description>").
+- **String defaults must be double-quoted in the method signature**, e.g.
+  `host: "https://..."`. The wizard reads the raw source and `JSON.parse`s it
+  (`config_prompt.rb` `default_value_in_tty`) — a single-quoted default raises at
+  wizard runtime. RuboCop won't flag it (`Style/StringLiterals` is disabled).
+- Default handling: no default → required answer; default `nil` → optional/skippable;
+  any other default → pre-filled, and unchanged answers are omitted from the generated
+  config (the code default applies).
+- Types drive input handling: `Integer`/`Float` → converted; `Pathname` → file path
+  with existence validation; `Hash` → entered as a raw Ruby expression. To force
+  raw-Ruby entry for other params, list them in a `@fields_to_input_ruby name1 name2`
+  tag on `initialize` (custom tag defined in `config_prompt.rb`; `substitude_glossary.rb`
+  uses it). Raw-Ruby params are hidden from users who answer no to "Do you know Ruby?".
+- Renaming a class or file requires updating its `autoload_and_register` line, or the
+  wizard crashes (`Component#klass` is nil).
+
+## translator_config.rb shape
+
+Generated by `lib/natsukantou/setup/output.erb`; loaded by
+`Setup::ConfigLoadOrPrompt` via plain Ruby `load`, then checked with
+`defined?(NatsukantouTranslator)`. Real example: `spec/fixtures/translator_config.rb`.
+
+```ruby
+::NatsukantouTranslator = Middleware::Builder.new do
+  use Natsukantou::HandleRubyMarkup
+  use Natsukantou::SubstitudeGlossary, filepath: "glossary.tsv"   # filters first
+
+  use Natsukantou::DeepL, auth_key: "..."                         # translator LAST
+end
+```
+
+Rules: assign to the top-level constant `::NatsukantouTranslator`; middleware filters
+before the translator; kwargs only. Used as `natsukantou -c CONFIG_FILE XML_FILE`. The
+file is gitignored at repo root (it contains API keys) — never commit one outside
+`spec/fixtures/`, and never put real keys in the fixture.
+
+## Verify
+
+After editing any `initialize` signature/doc comment, confirm the wizard can still parse
+it (prints each kwarg + default, no exception) — substitute your class and path:
+
+```sh
+bundle exec ruby -Ilib -e '
+require "natsukantou"
+require "natsukantou/setup/config_prompt"
+comp = Natsukantou::Setup::Component.new(:DeepL, "lib/natsukantou/deep_l.rb")
+comp.initialize_method_param_tags.each do |t|
+  d = t.default_value_in_string
+  p [t.name, (d && d != "nil") ? t.default_value_in_tty : d]
+end
+'
+```
+
+A single-quoted string default fails this with "Please specify keyword argument default
+value in double quotes"; a missing registration or renamed class fails with
+`NoMethodError` on nil.

data/.rubocop.yml

@@ -1,3 +1,7 @@
+inherit_mode:
+  merge:
+    - Exclude
+
 AllCops:
   TargetRubyVersion: 2.7
   Exclude:
@@ -60,11 +64,14 @@ Style/IfUnlessModifier:
 Style/Documentation:
   Enabled: false
 
+Style/KeywordParametersOrder:
+  Enabled: false
+
 Layout/ArgumentAlignment:
   EnforcedStyle: with_fixed_indentation
 
 Layout/LineLength:
-  Max: 120
+  Enabled: false
 
 Layout/MultilineMethodCallIndentation:
   EnforcedStyle: indented

data/CHANGELOG.md

@@ -29,3 +29,14 @@
 ## [0.2.2] - 2023-10-10
 
 - Fix ChatGPT not able to distinguish content to be translated and our instructions.
+
+## [0.2.3] - 2026-09-08
+
+- Upgrade to deepl-rb 3.0 (maintainership change only, no migration needed)
+- Switch to ibsciss-middleware fork, fixing Ruby 3 keyword-argument errors
+- ChatGPT: configurable `model` and `temperature` (defaults `gpt-3.5-turbo`, `0.5`)
+- ChatGPT: report API and timeout errors and leave the node untranslated instead of aborting the run
+- ChatGPT: raise request timeout to 500s for slow single-paragraph translations
+- Accept extended language subtags such as `zh-hant`
+- Setup wizard: validate language codes, verify config and glossary files exist,
+  support parameters with multiple declared types, and cast Integer/Float inputs correctly

data/CLAUDE.md

@@ -0,0 +1,67 @@
+# Natsukantou — development guide
+
+Ruby gem that translates XML/EPUB documents between human languages via pluggable
+backends (DeepL, TexTra/Minhon, OpenAI) and middleware filters.
+
+## Architecture
+
+- **Everything is a Rack-style middleware.** There is no Translator base class. A
+  component (backend or filter) is a class with `initialize(app, **keyword_args)` and
+  `call(env)` that ends with `@app.call(env)`. Backends mix in `UtilityBase`
+  (`lib/natsukantou/utility/utility_base.rb`) for `dom`/`dom_node`/`logger`.
+- **`env`** is `Natsukantou::Env` (`lib/natsukantou/utility/env.rb`): a Hash delegator
+  requiring `:dom` (Oga document), `:lang_from`, `:lang_to` (coerced to `LanguageCode`).
+- **Pipeline** = user config file: `::NatsukantouTranslator = Middleware::Builder.new do
+  use ... end` — filters first, translator last. `exe/natsukantou` parses the XML, runs
+  the stack, writes `file.<lang_to>.ext`.
+- **Registration**: `lib/natsukantou.rb` `autoload_and_register :translator|:middleware,
+  :Constant, "path"`. This also records the source path so the setup wizard can
+  **YARD-parse the file at runtime** — doc comments on `initialize` are executable
+  schema, not documentation. See `.claude/skills/wizard-config-conventions/SKILL.md`.
+- `lib/monkey_patch/oga_document.rb` adds `lang`/`lang=` to Oga elements/documents,
+  `Document#interlace` (bilingual output), and a UTF-8 serialization fix.
+
+## Load-bearing conventions
+
+- `SubstitudeGlossary` — the misspelling ("substitude") is intentional public API
+  (README, registry, config files). Never rename or "fix" it.
+- A translator's `call` MUST set `env[:dom].lang = env[:lang_to].code` after
+  translating — enforced by the shared example in `spec/support/lang_attribute.rb`.
+- Parse XML with `dom(xml)` / `dom_node(xml)` from `UtilityBase`, never
+  `Oga.parse_xml` directly (they do strict parse → lenient fallback with logging).
+- `<skip>` tags mark already-translated content: `SubstitudeGlossary` emits them,
+  DeepL is configured with `ignore_tags: 'skip'` (`lib/natsukantou/deep_l.rb`).
+- `LanguageCode#is?` is asymmetric: `en-gb` is `en`, but `en` is not `en-gb`.
+- `lib/` must stay compatible with the oldest Ruby the gemspec's
+  `required_ruby_version` allows and `.gitlab-ci.yml` builds. Read both rather than
+  assuming; local dev runs a newer Ruby than either.
+
+## Commands
+
+- `bundle exec rspec` — run it before you change anything so you know the baseline; a
+  failure that was not there before is yours. Pre-existing failures are usually stale
+  VCR cassettes — see `.claude/skills/run-and-record-specs/SKILL.md`.
+- `bundle exec rubocop <files-you-touched>` — the full run has pre-existing offenses;
+  only keep your own files clean.
+- `bundle exec rake` — spec + rubocop; what GitLab CI runs (`.gitlab-ci.yml`).
+- Release: bump `lib/natsukantou/version.rb`, append a CHANGELOG.md entry **at the
+  bottom** (this file is ordered oldest→newest), then `bundle exec rake release`
+  (git tag + irreversible push to rubygems.org — requires maintainer confirmation).
+
+## Known issues — do not trip on these
+
+This section records the state at the time of writing and goes stale fastest; confirm
+an item still holds before relying on it.
+
+- `Natsukantou::ChatGpt` does not resolve: `lib/natsukantou.rb` registers `:ChatGpt`
+  while `open_ai.rb` names the alias `ChatGPT`. Use `Natsukantou::OpenAi` instead.
+- The DeepL cassette (`spec/cassettes/DeepL/translates.yml`) predates deepl-rb 3.x's
+  request format; re-recording requires a real API key.
+- `spec/secret.rb` (gitignored) holds real credentials — never commit or print it.
+
+## Skills
+
+- `.claude/skills/add-translator-backend/` — add a new backend or middleware filter.
+- `.claude/skills/run-and-record-specs/` — run the suite, handle VCR/secrets, re-record.
+- `.claude/skills/wizard-config-conventions/` — edit `initialize` signatures/doc
+  comments or author a `translator_config.rb`.

data/exe/natsukantou

@@ -40,8 +40,17 @@ Natsukantou::Setup::ConfigLoadOrPrompt.new.execute(
   config_path: options[:config_path],
 )
 
-lang_from = prompt.ask("Language code to translate from?")
-lang_to = prompt.ask("Language code to translate to?")
+def prompt.ask_lang(target)
+  ask("Language code to translate #{target}?") do |q|
+    q.validate(
+      /\A([[:alpha:]]{2}|[[:alpha:]]{2}-[[:alpha:]]*)\z/,
+      "Language code should be in the form of xx or xx-yy"
+    )
+  end
+end
+
+lang_from = prompt.ask_lang('from')
+lang_to = prompt.ask_lang('to')
 
 env = Natsukantou::Env.new(
   dom: dom, lang_from: lang_from, lang_to: lang_to

data/lib/natsukantou/chat_gpt.rb

@@ -18,15 +18,21 @@ module Natsukantou
 
     # @param app [Hash]
     # @param access_token [String] API access token
+    # @param model [String] LLM model name
+    # @param temperature [Float] Between 0 and 1. Higher temperatures introduce randomness, which is beneficial for creative writing. In contrast, a temperature of zero ensures consistent responses.
     #
     # @param translate_by_section [String] CSS selector to translate matched elements one by one.
     #   Specify a css path (e.g. "body>p") to translate in smaller chunks.
     def initialize(
       app, access_token:,
+      model: "gpt-3.5-turbo",
+      temperature: 0.5,
       translate_by_section:
     )
       @app = app
       @access_token = access_token
+      @model = model
+      @temperature = temperature
 
       ### Non request related setting
       @translate_by_section = translate_by_section
@@ -34,6 +40,8 @@ module Natsukantou
 
     attr_reader :env
     attr_reader :access_token
+    attr_reader :model
+    attr_reader :temperature
     attr_reader :translate_by_section
 
     def call(env)
@@ -44,7 +52,11 @@ module Natsukantou
           next if node.text.empty?
 
           translated_xml = translate(node.to_xml)
-          node.replace(dom_node(translated_xml))
+          next unless translated_xml
+
+          new_node = dom_node(translated_xml)
+          new_node.lang = env[:lang_to].code
+          node.replace(new_node)
         end
       else
         # TODO
@@ -63,28 +75,36 @@ module Natsukantou
       )
 
       parameters = {
-        model: "gpt-3.5-turbo",
+        model: model,
         messages: [
           { role: "system", content: system_message },
           { role: "user", content: text },
         ],
-        temperature: 0.7,
+        temperature: temperature,
       }
 
       response = client.chat(parameters: parameters)
 
+      raise response['error'].to_s if response.key?('error')
+
       translated_xml = response.dig("choices", 0, "message", "content")
 
       translated_xml.strip!
 
       translated_xml
-    rescue Net::OpenTimeout
-      sleep 10
-      retry
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      puts e.message
+      nil
+    rescue StandardError => e
+      puts e.message
+      nil
     end
 
     def client
-      @client ||= ::OpenAI::Client.new(access_token: access_token)
+      @client ||= ::OpenAI::Client.new(
+        access_token: access_token,
+        request_timeout: 500
+      )
     end
   end
 end

data/lib/natsukantou/setup/config_load_or_prompt.rb

@@ -18,7 +18,7 @@ module Natsukantou
             puts "Saved as translator_config.rb, which you can specify with -c flag next time.\n\n"
           end
 
-          Kernel.eval(config_content)
+          Kernel.eval(config_content) # rubocop:disable Security/Eval -- safe code generated by us
         end
 
         NatsukantouTranslator

data/lib/natsukantou/setup/config_prompt.rb

@@ -38,7 +38,7 @@ module Natsukantou
       end
     end
 
-    # Both a decorator to Yard tag object,
+    # Both a decorator to Yard @param tag object,
     # and where the user input is stored.
     # Assumption: only dealing with keyword argument
     class MethodParamTagDecorator < SimpleDelegator
@@ -49,7 +49,7 @@ module Natsukantou
       end
 
       def enter_ruby?
-        return true if type == 'Hash'
+        return true if primary_type?('Hash')
 
         list = initialize_method.tag('fields_to_input_ruby')
 
@@ -59,23 +59,28 @@ module Natsukantou
       end
 
       def convert
-        case type
-        when Integer
+        if primary_type? 'Integer'
           :integer
-        when Float
+        elsif primary_type? 'Float'
           :float
         else
           nil # do not convert and assume Ruby code
         end
       end
 
+      # @return [String] keyword argument default value **in Ruby syntax** as is.
+      #   This means for string args, the quote characters (' or ") will also be included.
       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'
+        if primary_type? 'String'
+          if !default_value_in_string.start_with?('"')
+            raise "Please specify keyword argument default value in double quotes for the wizard parsing to work."
+          end
+
           JSON.parse(default_value_in_string)
         else
           default_value_in_string
@@ -89,6 +94,12 @@ module Natsukantou
           user_input.inspect
         end
       end
+
+      # @param type_string [String] whether @param type has type_string as primary type
+      # TODO: use internal YARD parser to obtain list of types
+      def primary_type?(type_string)
+        type.start_with?(type_string)
+      end
     end
 
     class ConfigPrompt
@@ -167,6 +178,7 @@ module Natsukantou
           printf "Enter '#{tag.name}', #{tag.text}"
 
           ask_params[:convert] = tag.convert if tag.convert
+          set_file_path!(tag, ask_params)
 
           default = tag.default_value_in_string
           if default == 'nil'
@@ -199,6 +211,22 @@ module Natsukantou
 
         answers
       end
+
+      # @param params [Hash] ask params, this will be modified
+      def set_file_path!(tag, params)
+        return if !tag.primary_type?('Pathname')
+
+        params[:convert] = :filepath
+        params[:validate] = proc do |input|
+          if File.exist?(input)
+            true
+          else
+            # TODO: https://github.com/piotrmurach/tty-prompt/issues/197
+            puts 'File does not exist, please input again: '
+            false
+          end
+        end
+      end
     end
   end
 end

data/lib/natsukantou/substitude_glossary.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'tsv'
+require 'pathname'
 
 # Glossary isn't supported in some language
 # combinations (e.g. DeepL ja to zh).
@@ -16,14 +17,16 @@ module Natsukantou
       ja zh th lo
     }.freeze
 
-    # @param filepath [String] path to TSV glossary file.
+    # @param filepath [Pathname, 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
+      if filepath
+        @glossary.concat(parse_tsv(Pathname(filepath)))
+      end
 
       @glossary.uniq! { |row| row[0] }
 

data/lib/natsukantou/version.rb

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

data/lib/natsukantou.rb

@@ -2,10 +2,8 @@
 
 require 'logger'
 require 'middleware'
-require_relative "monkey_patch/builder"
 require 'oga'
 require_relative "monkey_patch/oga_document"
-require_relative "monkey_patch/runner"
 
 require_relative "natsukantou/version"
 require_relative "natsukantou/setup/registry"

data/natsukantou.gemspec

@@ -29,7 +29,7 @@ Gem::Specification.new do |spec|
   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 "ibsciss-middleware", "~> 0.4.3"
   spec.add_dependency "oga", "~> 3.4"
   spec.add_dependency "tsv", "~> 1.0"
 
@@ -37,7 +37,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "yard", "~> 0.9"
 
   # DeepL
-  spec.add_dependency "deepl-rb", "~> 2.5"
+  spec.add_dependency "deepl-rb", "~> 3.0"
 
   # Minhon
   spec.add_dependency 'oauth', '~> 0.5.1'

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: natsukantou
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - lulalala
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: middleware
+  name: ibsciss-middleware
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
   name: oga
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +85,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: oauth
   requirement: !ruby/object:Gem::Requirement
@@ -131,17 +130,20 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".claude/skills/add-translator-backend/SKILL.md"
+- ".claude/skills/add-translator-backend/example-backend.md"
+- ".claude/skills/run-and-record-specs/SKILL.md"
+- ".claude/skills/wizard-config-conventions/SKILL.md"
 - ".rspec"
 - ".rubocop.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - exe/natsukantou
-- lib/monkey_patch/builder.rb
 - lib/monkey_patch/oga_document.rb
-- lib/monkey_patch/runner.rb
 - lib/natsukantou.rb
 - lib/natsukantou/chat_gpt.rb
 - lib/natsukantou/deep_l.rb
@@ -168,7 +170,6 @@ 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
@@ -183,8 +184,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: human language translation library for XML documents
 test_files: []

data/lib/monkey_patch/builder.rb

@@ -1,14 +0,0 @@
-module Middleware
-  class Builder
-    def use(middleware, *args, **kwargs, &block)
-      if middleware.kind_of?(Builder)
-        # Merge in the other builder's stack into our own
-        self.stack.concat(middleware.stack)
-      else
-        self.stack << [middleware, args, kwargs, block]
-      end
-
-      self
-    end
-  end
-end

data/lib/monkey_patch/runner.rb

@@ -1,32 +0,0 @@
-module Middleware
-  class Runner
-    protected
-
-    def build_call_chain(stack)
-      stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
-        # Unpack the actual item
-        klass, args, kwargs, block = current_middleware
-
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class. Not what
-        # we want!
-        args ||= []
-
-        if klass.is_a?(Class)
-          # If the klass actually is a class, then instantiate it with
-          # the app and any other arguments given.
-          klass.new(next_middleware, *args, **kwargs, &block)
-        elsif klass.respond_to?(:call)
-          # Make it a lambda which calls the item then forwards up
-          # the chain.
-          lambda do |env|
-            klass.call(env)
-            next_middleware.call(env)
-          end
-        else
-          raise "Invalid middleware, doesn't respond to `call`: #{klass.inspect}"
-        end
-      end
-    end
-  end
-end