asciidoc-pubkit 0.1.1 → 0.6.0

data/data/writing/ja/criteria.md

@@ -0,0 +1,178 @@
+# Shared criteria for Japanese technical prose
+
+## Contents
+
+- Start with the paragraph's technical purpose
+- Replace abstraction with the thing being discussed
+- Give weak predicates a concrete action or consequence
+- Make relationships explicit
+- Keep claims within their evidence and purpose
+- Remove generated-prose patterns without flattening the meaning
+- Preserve exact technical terminology
+- Revise the complete paragraph
+- Headings and the relation to figures and code
+
+Apply these criteria in context. They identify patterns that deserve inspection,
+not words that must always be removed.
+
+## Start with the paragraph's technical purpose
+
+Before rewriting sentences, summarize each paragraph in one sentence:
+
+1. What implementation, behavior, or decision is this paragraph about?
+2. Who or what performs the action?
+3. Under what condition does it apply?
+4. What changes or follows as a result?
+5. What can an engineer decide or verify from it?
+
+If the summary is impossible, repair the paragraph's argument before polishing
+individual phrases. A short sentence is not automatically clear; omitted
+subjects, objects, complements, and referents must still be recoverable from the
+adjacent sentences.
+
+## Replace abstraction with the thing being discussed
+
+Abstract terms are valid when their referent is stated. Inspect terms such as:
+
+| Term | What must be identifiable |
+| --- | --- |
+| 費用・コスト | investigation time, maintenance work, CPU time, memory, network transfer, or money |
+| 契約 | accepted inputs, returned values and errors, compatibility, ownership, concurrency, or another promised behavior |
+| 境界 | the two components and the call, data transfer, or ownership transfer between them |
+| 観点 | the actual comparison axis, such as type safety, shutdown behavior, allocation count, or supported OS |
+| 書き方 | syntax, implementation technique, API shape, or document notation |
+| 範囲・射程 | supported readers, covered subjects, applicable versions, or behavior guaranteed by an API |
+
+Do not improve a sentence by replacing one abstraction with another. For
+example, changing `費用` to `コスト` says nothing unless the sentence identifies
+what increases.
+
+## Give weak predicates a concrete action or consequence
+
+Predicates such as `利用します`, `決めます`, `示します`, `扱います`, `整理します`,
+`表します`, `保てます`, `異なります`, `同じではありません`, `残します`, and
+`評価します` often omit the important information. Ask what is used for what,
+which value or policy is decided, what differs, where evidence is stored, and
+which result drives the decision.
+
+Prefer a precise action or consequence:
+
+- `検証結果を利用します` becomes `検証結果をAPIの見直し材料にします` when that
+  is the actual purpose.
+- `採用する機能を決めます` becomes `サポートするバージョンと互換性を基に採用を
+  判断します` when those are the criteria.
+- `結果を残します` becomes `実行したコマンドと結果をプルリクエストへ記録します`
+  when that is the storage location.
+
+Do not choose a more impressive synonym merely to vary sentence endings. Keep
+the technically correct verb when it names the real operation.
+
+## Make relationships explicit
+
+Inspect a sentence when it:
+
+- begins a new topic without connecting it to the preceding paragraph;
+- says two things differ without naming the differing property;
+- introduces a comparison without naming the alternatives and comparison axis;
+- uses `これ`, `それ`, `前者`, or `後者` when the referent requires rereading;
+- strings three or more abstract nouns together without explaining their
+  relationship;
+- uses an abrupt `読者は` even though the effect can be stated directly;
+- attaches `へ` or `から` to an abstract noun in phrases such as `判断へ戻す`;
+- uses a literal translation that is not an established term in the technical
+  domain.
+
+When a standalone sentence cannot identify its subject or object, use the
+surrounding paragraph to supply the missing noun. Do not repeat the subject in
+every sentence when it is already unambiguous.
+Use prose for a sequence in which one event causes or conditions the next; use
+a list when the items are genuinely parallel. Do not turn a causal explanation
+into disconnected bullets or impose an order on independent items.
+
+## Keep claims within their evidence and purpose
+
+State whether a claim comes from an implementation, a test, a cited study, or
+the author's inference. Match its scope to that evidence: a single example or
+test establishes what happened under its stated conditions, not a universal
+result. Preserve uncertainty when evidence does not settle the claim; do not
+weaken an established fact merely to sound cautious.
+
+Before adding a qualification, ask what decision or interpretation it changes.
+Correct an overbroad main claim at its source. Remove a following disclaimer if
+the preceding explanation already excludes that reading. When a limitation
+affects use, implementation, or verification, state the concrete condition and
+connect it to the relevant action or check. Do not delete a technical boundary
+merely because it uses negative wording.
+
+## Remove generated-prose patterns without flattening the meaning
+
+Common patterns that merit paragraph-level review include:
+
+- repeated `AではなくBです` or `AだけでなくBも` contrasts;
+- paired short slogans that omit the actor, object, condition, or consequence;
+- repeated endings such as `扱います`, `示します`, or `選びます`;
+- `重要なのは`, `ポイントは`, or `〜することです` standing in for the actual
+  technical fact;
+- a section opening that only announces what the section will discuss;
+- a section ending that only says the material was explained or organized;
+- metaphors such as `土台`, `器`, `橋渡し`, or `輪が閉じる` used instead of a
+  concrete technical operation;
+- a standalone qualification that only denies an overbroad reading already
+  excluded by the preceding explanation, such as a redundant
+  `という意味ではありません` or `保証ではありません`;
+- generic praise, warnings, or recommendations without the condition that makes
+  them true.
+
+Keep a contrast when the two alternatives and the difference that affects the
+decision are explicit. Keep necessary repetition when it improves technical
+accuracy.
+Do not shorten sentences or vary endings mechanically. Read the sequence aloud
+and repair the missing relationship rather than replacing one stock pattern
+with another.
+
+## Preserve exact technical terminology
+
+Check terminology against identifiers, surrounding code, the project's
+glossary, and primary documentation before changing it.
+
+- Distinguish an API from a function, method, interface, protocol, or command.
+- Distinguish an error value, operation failure, incident, and defect.
+- Distinguish resource ownership from the responsibility to close or stop it.
+- Use the project's chosen forms consistently, such as `goroutine` versus
+  `ゴルーチン`, or `reflection` versus `リフレクション`.
+- Replace unnecessary English words with established Japanese terms, but retain
+  identifiers and official names.
+- Do not describe a language operation with a loose everyday verb when the
+  domain has a precise term, such as name shadowing, method promotion, parsing,
+  serialization, cancellation, or resource release.
+
+Natural Japanese must not erase a technical distinction. If the original claim
+is ambiguous, inspect the code or authoritative documentation before editing.
+
+## Revise the complete paragraph
+
+Use a finding to understand the intended claim, then rewrite the paragraph so
+that every sentence connects to the next. Do not paste an isolated suggested
+sentence into the manuscript without adjusting its context. After editing,
+read the paragraph as continuous prose and verify subject, object, modifier,
+condition, cause, and effect.
+
+
+## Headings and the relation to figures and code
+
+Headings identify the subject, operation, or comparison actually explained.
+Do not promise a broader comparison than the text supports or replace the
+subject with an unexplained metaphor. Heading length and required section
+names belong to the book's format, not to universal prose quality.
+Do not force every heading into a conclusion sentence or the same template;
+make the section's content identifiable in the form the book uses.
+
+Introduce tables and figures with enough context to explain what is compared
+or traced, and explain what the reader can establish from them. Keep identifiers,
+values, ordering, and conditions consistent with the code or clearly label a
+simplified conceptual representation. Do not repeat every label as prose.
+
+File paths and type names belong where they help explain a specific operation;
+avoid a list of identifiers before the reader knows their roles. Bibliographic
+and implementation-file descriptions introduce the referenced material, rather
+than narrating the author's research activity.

data/lib/asciidoc_pubkit/cli.rb

@@ -3,9 +3,11 @@
 module AsciidocPubkit
   class CLI
     HELP = <<~TEXT
-      Usage: asciidoc-pubkit review <command> [options] <input>
+      Usage: asciidoc-pubkit <group> <command> [options] [input]
 
       Commands:
+        writing criteria      Print the shared Japanese prose criteria
+        writing prompt        Generate a Japanese technical writing prompt
         review scan FILE       Collect Japanese prose and review candidates
         review prompt SESSION  Generate an English review prompt with Japanese source excerpts
         review verify SESSION  Compare edited sources with the saved baseline
@@ -14,30 +16,38 @@ module AsciidocPubkit
         --help                 Show help (also supported for each command)
         --version              Show the version
 
+      Use --lang ja with writing commands and review commands. Other review and
+      writing languages are not supported yet and return an error.
       No command edits manuscript files or invokes an AI service.
     TEXT
 
-    def self.run(arguments, out: $stdout, err: $stderr)
+    def self.run(arguments, out: $stdout, err: $stderr, input: $stdin)
       args = arguments.dup
       if args == ['--version']
         out.puts VERSION
         return 0
       end
-      if args.empty? || args == ['--help'] || args == ['-h'] || args == ['review', '--help']
+      if args.empty? || args == ['--help'] || args == ['-h'] || %w[review writing].any? { |group| args == [group, '--help'] }
         out.puts HELP
         return 0
       end
       group, command = args.shift(2)
-      raise Error, 'Expected review scan, review prompt, or review verify. Use --help.' unless group == 'review' && %w[scan prompt verify].include?(command)
+      valid = (group == 'review' && %w[scan prompt verify].include?(command)) ||
+              (group == 'writing' && %w[criteria prompt].include?(command))
+      raise Error, 'Unknown command. Use --help.' unless valid
       options = { attributes: {} }
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: asciidoc-pubkit review #{command} [options] #{command == 'scan' ? 'FILE' : 'SESSION'}"
-        opts.on('-o', '--output PATH', command == 'scan' ? 'New session directory (default: .pubkit/review)' : 'New output file (default: standard output)') { |v| options[:output] = v }
-        if command == 'scan'
+        input_name = group == 'writing' ? '' : (command == 'scan' ? ' FILE' : ' SESSION')
+        opts.banner = "Usage: asciidoc-pubkit #{group} #{command} [options]#{input_name}"
+        opts.on('-o', '--output PATH', group == 'review' && command == 'scan' ? 'New session directory (default: .pubkit/review)' : 'New output file (default: standard output)') { |v| options[:output] = v }
+        opts.on('--lang LANG', 'Language (ja only in this release)') { |v| options[:language] = v }
+        if group == 'review' && command == 'scan'
+          opts.on('-y', '--yes', 'Answer yes to replacement confirmation') { options[:yes] = true }
+          opts.on('--no-input', 'Never prompt; fail on existing output unless --yes') { options[:no_input] = true }
           opts.on('--only FILE', 'Review one included file in the book context') { |v| options[:only] = v }
           opts.on('--config FILE', 'Use an explicit YAML configuration') { |v| options[:config] = v }
+          opts.on('--rules FILE', 'Replace default review rules with a YAML rule set') { |v| options[:rules] = v }
           opts.on('--base-dir DIR', 'Set the Asciidoctor base directory') { |v| options[:base_dir] = v }
-          opts.on('--lang LANG', 'Prose language (ja only)') { |v| options[:language] = v }
           opts.on('--tokenizer NAME', 'mecab (default) or literal (limited phrase matching)') { |v| options[:tokenizer] = v }
           opts.on('--style STYLE', 'preserve (default), desu-masu, or dearu') { |v| options[:style] = v }
           opts.on('-a', '--attribute NAME=VALUE', 'Set an Asciidoctor attribute; repeat as needed') do |v|
@@ -45,7 +55,7 @@ module AsciidocPubkit
             raise Error, 'Attribute name cannot be empty.' if key.nil? || key.empty?
             options[:attributes][key] = value || ''
           end
-        elsif command == 'prompt'
+        elsif group == 'review' && command == 'prompt'
           opts.on('--mode MODE', 'revise (default) or diagnose') { |v| options[:mode] = v }
         end
         opts.on('-h', '--help', 'Show command help') { options[:help] = true }
@@ -55,9 +65,29 @@ module AsciidocPubkit
         out.puts parser
         return 0
       end
+      if group == 'writing'
+        raise Error, 'Writing commands do not accept an input file. Use --help.' unless args.empty?
+        language = Language.validate!(options.fetch(:language, Language::DEFAULT), operation: 'writing')
+        content = command == 'criteria' ? Writing.criteria(language) : Writing.prompt(language)
+        output(content, options[:output], out)
+        return 0
+      end
       raise Error, 'Exactly one input is required. Use --help.' unless args.length == 1
+      Language.validate!(options[:language], operation: 'review') if options[:language]
       if command == 'scan'
-        result = Session.scan(args.first, options)
+        result = Session.scan(args.first, options) do |destination|
+          if options[:yes]
+            true
+          elsif options[:no_input] || !input.tty?
+            raise Error, "Output already exists: #{destination}. Use --yes to replace it or --output for a new session."
+          else
+            err.print "Output already exists: #{destination}. Replace it? [y/N] "
+            err.flush
+            answer = input.gets
+            raise Error, 'Scan cancelled; existing session was kept.' unless answer && %w[y yes].include?(answer.strip.downcase)
+            true
+          end
+        end
         out.puts "Scanned #{result['paragraphs']} paragraphs; found #{result['findings']} review candidates."
         out.puts "Tokenizer: #{result['tokenizer']}#{result['tokenizer'] == 'literal' ? ' (limited phrase matching; no morphological analysis)' : ' (UTF-8 IPADIC)'}"
         out.puts "Coverage notices: #{result['coverage_notices']}. See document.json for limitations."
@@ -65,6 +95,10 @@ module AsciidocPubkit
         return 0
       end
       session = Session.new(args.first)
+      saved_language = Language.validate!(session.language, operation: 'review')
+      if options[:language] && options[:language] != saved_language
+        raise Error, "Requested language #{options[:language].inspect} does not match session language #{saved_language.inspect}."
+      end
       if command == 'prompt'
         output(session.prompt(options.fetch(:mode, 'revise')), options[:output], out)
         return 0

data/lib/asciidoc_pubkit/document.rb

@@ -26,6 +26,11 @@ module AsciidocPubkit
           super(*args)
         end
         doc.parse
+        document_language = doc.attr('lang')
+        if document_language && document_language != settings.fetch('language')
+          Language.validate!(document_language, operation: 'review')
+          raise Error, "Document language #{document_language.inspect} does not match review language #{settings.fetch('language').inspect}."
+        end
         @line_index = Hash.new { |hash, key| hash[key] = [] }
         @source_lines = @sources.to_h do |path, raw|
           lines = raw.lines.map { |line| line.delete_suffix("\n").delete_suffix("\r") }

data/lib/asciidoc_pubkit/language.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AsciidocPubkit
+  module Language
+    WRITING = %w[ja].freeze
+    REVIEW = %w[ja].freeze
+    DEFAULT = 'ja'
+
+    def self.validate!(value, operation:)
+      supported = { 'writing' => WRITING, 'review' => REVIEW }.fetch(operation)
+      return value if supported.include?(value)
+
+      raise Error, "Unsupported #{operation} language #{value.inspect}; supported: #{supported.join(', ')}."
+    end
+  end
+end

data/lib/asciidoc_pubkit/rule_set.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module AsciidocPubkit
+  class RuleSet
+    DEFAULT_PATH = File.expand_path('../../data/review-rules.ja.yml', __dir__)
+    CATEGORIES = %w[abstract-reference weak-predicate vague-degree contextual-phrase generic-framing].freeze
+    KEYS = %w[schema_version terms verbs sahen negative_only compound_nouns].freeze
+
+    def self.default_path(language)
+      Language.validate!(language, operation: 'review')
+      File.expand_path("../../data/review-rules.#{language}.yml", __dir__)
+    end
+
+    def self.load(path = DEFAULT_PATH)
+      validate(YAML.safe_load(AsciidocPubkit.read_text(path), permitted_classes: [], aliases: false))
+    rescue Psych::Exception => e
+      raise Error, "Invalid rule YAML in #{path}: #{e.message}"
+    end
+
+    def self.mapping(value, keys, label)
+      unless value.is_a?(Hash) && (value.keys - keys).empty? && (keys - value.keys).empty?
+        raise Error, "#{label} must contain exactly these keys: #{keys.join(', ')}."
+      end
+    end
+
+    def self.strings(value, label)
+      unless value.is_a?(Array) && value.all? { |s| s.is_a?(String) && !s.strip.empty? } && value.uniq == value
+        raise Error, "#{label} must be an array of unique nonempty strings."
+      end
+    end
+
+    def self.validate(data)
+      mapping(data, KEYS, 'Rule set')
+      raise Error, 'Rule schema_version must be integer 1.' unless data['schema_version'].is_a?(Integer) && data['schema_version'] == 1
+      mapping(data['terms'], CATEGORIES, 'Rule terms')
+      data['terms'].each do |category, entry|
+        mapping(entry, %w[terms question], category)
+        strings(entry['terms'], "#{category}.terms")
+        raise Error, "#{category}.question must be a nonempty string." unless entry['question'].is_a?(String) && !entry['question'].strip.empty?
+      end
+      verbs = data['verbs']
+      raise Error, 'verbs must be a mapping of canonical forms to lemma arrays.' unless verbs.is_a?(Hash)
+      verbs.each do |canonical, forms|
+        raise Error, 'Verb canonical forms must be nonempty strings.' unless canonical.is_a?(String) && !canonical.strip.empty?
+        strings(forms, "verbs.#{canonical}")
+        raise Error, "verbs.#{canonical} must contain at least one lemma." if forms.empty?
+      end
+      aliases = verbs.values.flatten
+      raise Error, 'Verb lemmas must have only one canonical form.' unless aliases.uniq == aliases
+      %w[sahen negative_only compound_nouns].each { |key| strings(data[key], key) }
+      canonical_forms = verbs.keys + data['sahen'].map { |noun| noun + 'する' }
+      raise Error, 'negative_only must refer to configured canonical predicates.' unless (data['negative_only'] - canonical_forms).empty?
+      raise Error, 'compound_nouns must also appear in abstract-reference terms.' unless (data['compound_nouns'] - data['terms']['abstract-reference']['terms']).empty?
+      data
+    end
+  end
+end

data/lib/asciidoc_pubkit/rules.rb

@@ -3,30 +3,14 @@
 module AsciidocPubkit
   class Rules
     INLINE = /`[^`\n]*`|\+\+\+.*?\+\+\+|\+\+[^\n]*?\+\+|(?<!\w)\+[^+\n]+\+|「[^」\n]*」|『[^』\n]*』|\{[^}\n]+\}|<<[^>\n]+>>|\[\[[^\]\n]+\]\]|(?:link|xref|image|footnote|pass):[^\s\[]*\[[^\]\n]*\]|https?:\/\/[^\s\[\]<>]+(?:\[[^\]\n]*\])?/m
-    TERMS = {
-      'abstract-reference' => [%w[コスト 境界 契約 観点 土台 橋渡し 入口 記述 場所 意図 役割 一続き 根拠 部品 開発者], 'Identify the concrete referent, components, or measurable work. Keep established technical meanings.'],
-      'weak-predicate' => [%w[利用します 整理します 扱います 示します 変わります 把握します 分けられます そろえます まとまっています 加えます 探します 到達しません 扱いません そろいます 選べます 成り立たせています 確かめます 書き換える 絞れます 渡します あります], 'Check whether the purpose, operation, or result is clear from the surrounding paragraph. Preserve negation and conditions.'],
-      'vague-degree' => [%w[浅い 深い], 'Identify the concrete depth, level, scope, or comparison. Keep literal measurements and established technical meanings.'],
-      'contextual-phrase' => [%w[これらを であることだけでは あるものとします わけではありません], 'Check the referent, assumption, or qualification against the surrounding explanation. Preserve conditions and negation.'],
-      'generic-framing' => [%w[重要なのは ポイントは 本章では ここでは まとめると], 'Check whether this framing adds useful scope or information instead of repeating the explanation.']
-    }.freeze
-    VERBS = {
-      '扱う' => %w[扱う], '示す' => %w[示す], '変わる' => %w[変わる],
-      '分ける' => %w[分ける], 'そろえる' => %w[そろえる 揃える],
-      'まとまる' => %w[まとまる 纏まる], '加える' => %w[加える],
-      '探す' => %w[探す], 'そろう' => %w[そろう 揃う],
-      '選ぶ' => %w[選ぶ 選べる], '成り立つ' => %w[成り立つ],
-      '確かめる' => %w[確かめる], '書き換える' => %w[書き換える],
-      '絞る' => %w[絞る 絞れる], '渡す' => %w[渡す], 'ある' => %w[ある]
-    }.freeze
-    SAHEN = %w[利用 整理 把握 到達].freeze
-
     def self.mask(text)
       # Keep character offsets stable while excluding common inline constructs.
       text.gsub(INLINE) { |match| match.gsub(/[^\n]/, ' ') }
     end
 
     def self.scan(paragraphs, settings, tokenizer: nil)
+      rules = RuleSet.validate(settings.fetch('rules') { RuleSet.load })
+      terms = rules.fetch('terms').transform_values { |entry| entry.values_at('terms', 'question') }
       findings = []
       if settings.fetch('tokenizer', 'mecab') == 'mecab'
         tokenizer ||= Morphology.new(settings)
@@ -34,14 +18,8 @@ module AsciidocPubkit
       token_groups = tokenizer ? tokenize_paragraphs(paragraphs, tokenizer) : []
       paragraphs.each_with_index do |paragraph, index|
         text = mask(paragraph.fetch('text'))
-        scan_morphemes(findings, paragraph, text, token_groups[index], settings) if tokenizer
-        TERMS.each do |rule, (terms, question)|
-          next if tokenizer && !%w[generic-framing contextual-phrase].include?(rule)
-          terms.each do |term|
-            next if settings.fetch('allows').include?(term)
-            find_term(findings, paragraph, text, term, rule, 'hint', question)
-          end
-        end
+        scan_morphemes(findings, paragraph, text, token_groups[index], settings, rules, terms) if tokenizer
+        scan_literal_terms(findings, paragraph, text, terms, settings, morphological: !!tokenizer)
         settings.fetch('glossary').each do |canonical, variants|
           variants.each do |variant|
             find_term(findings, paragraph, text, variant, 'glossary-variant', 'warning', "Use #{canonical.inspect} when this variant refers to the same concept; preserve identifiers and quotations.")
@@ -90,8 +68,8 @@ module AsciidocPubkit
       end
     end
 
-    def self.scan_morphemes(findings, paragraph, text, tokens, settings)
-      phrase_ranges = TERMS['contextual-phrase'][0].flat_map do |phrase|
+    def self.scan_morphemes(findings, paragraph, text, tokens, settings, rules, terms)
+      phrase_ranges = terms['contextual-phrase'][0].flat_map do |phrase|
         text.to_enum(:scan, Regexp.new(Regexp.escape(phrase))).map do
           match = Regexp.last_match
           match.begin(0)...match.end(0)
@@ -102,40 +80,48 @@ module AsciidocPubkit
         lemma = token['lemma']
         rule = nil
         finish_index = index
-        compound = %w[一続き 開発者].find do |term|
-          following = tokens[index + 1]
-          following && token['pos'] == '名詞' && following['pos'] == '名詞' &&
-            !following['unknown'] && token['end_offset'] == following['offset'] &&
-            token['surface'] + following['surface'] == term
+        compound = rules.fetch('compound_nouns').find do |term|
+          surface = +''
+          cursor = index
+          while (member = tokens[cursor]) && member['pos'] == '名詞' && !member['unknown']
+            break if cursor > index && tokens[cursor - 1]['end_offset'] != member['offset']
+            surface << member['surface']
+            break unless term.start_with?(surface)
+            if surface == term
+              finish_index = cursor
+              break
+            end
+            cursor += 1
+          end
+          surface == term
         end
         if compound
           lemma = compound
-          finish_index = index + 1
           rule = 'abstract-reference'
-        elsif token['pos'] == '名詞' && TERMS['abstract-reference'][0].include?(lemma)
+        elsif token['pos'] == '名詞' && token['pos_detail'] == 'サ変接続' && rules.fetch('sahen').include?(lemma) &&
+              (following = tokens[index + 1]) && following['pos'] == '動詞' &&
+              %w[する できる].include?(following['lemma']) && adjacent?(token, following, text)
+          lemma += 'する'
+          rule = 'weak-predicate'
+          finish_index = predicate_end(tokens, index + 1, text)
+        elsif token['pos'] == '名詞' && terms['abstract-reference'][0].include?(lemma)
           rule = 'abstract-reference'
-        elsif token['pos'] == '形容詞' && TERMS['vague-degree'][0].include?(lemma)
+        elsif token['pos'] == '形容詞' && terms['vague-degree'][0].include?(lemma)
           rule = 'vague-degree'
           finish_index = predicate_end(tokens, index, text)
-        elsif token['pos'] == '動詞' && (entry = VERBS.find { |_canonical, forms| forms.include?(lemma) })
+        elsif token['pos'] == '動詞' && (entry = rules.fetch('verbs').find { |_canonical, forms| forms.include?(lemma) })
           lemma = entry[0]
           rule = 'weak-predicate'
           finish_index = predicate_end(tokens, index, text)
-        elsif token['pos'] == '名詞' && token['pos_detail'] == 'サ変接続' && SAHEN.include?(lemma)
-          following = tokens[index + 1]
-          next unless following && following['pos'] == '動詞' && following['lemma'] == 'する' && adjacent?(token, following, text)
-          lemma += 'する'
-          rule = 'weak-predicate'
-          finish_index = predicate_end(tokens, index + 1, text)
         end
         next unless rule
         members = tokens[index..finish_index]
         negative = members.any? { |member| member['pos'] == '助動詞' && %w[ない ぬ ん].include?(member['lemma']) }
-        next if lemma == '到達する' && !negative
+        next if rules.fetch('negative_only').include?(lemma) && !negative
         surface = text[token['offset']...tokens[finish_index]['end_offset']]
         allows = settings.fetch('allows')
         next if [lemma, token['lemma'], surface, surface + '。'].any? { |form| allows.include?(form) }
-        add(findings, paragraph, text, token['offset'], surface, rule, 'hint', TERMS.fetch(rule)[1])
+        add(findings, paragraph, text, token['offset'], surface, rule, 'hint', terms.fetch(rule)[1])
         findings.last.merge!('lemma' => lemma, 'part_of_speech' => token['pos'], 'negative' => negative,
                              'detector' => 'mecab-ipadic')
       end
@@ -157,6 +143,25 @@ module AsciidocPubkit
       finish
     end
 
+    def self.scan_literal_terms(findings, paragraph, text, terms, settings, morphological:)
+      candidates = []
+      terms.each do |rule, (surfaces, question)|
+        next if morphological && !%w[generic-framing contextual-phrase].include?(rule)
+        surfaces.each do |surface|
+          text.to_enum(:scan, Regexp.new(Regexp.escape(surface))).each do
+            match = Regexp.last_match
+            candidates << [match.begin(0), match.end(0), surface, rule, question]
+          end
+        end
+      end
+      # Keep the most specific phrase, including when it is explicitly allowed.
+      candidates.each do |start, finish, surface, rule, question|
+        next if candidates.any? { |left, right, *_| left <= start && right >= finish && right - left > finish - start }
+        next if settings.fetch('allows').include?(surface)
+        add(findings, paragraph, text, start, surface, rule, 'hint', question)
+      end
+    end
+
     def self.find_term(findings, paragraph, text, term, rule, severity, question)
       text.to_enum(:scan, Regexp.new(Regexp.escape(term))).each do
         match = Regexp.last_match