asciidoc-pubkit 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8340a490160e7c0c2ca089657884c882eca5861dd27206dc9a3513ab1b5cfa2d
-  data.tar.gz: b4c2428c0408f2301563ee3e4586e9422c7b4875f927779146d9ebacec678568
+  metadata.gz: 1302c0c833ffbfdb14eff663bc8a30c80449ddf6ab065fc440c85e103189a87d
+  data.tar.gz: 47c5bc1c86b79a3130406f562cd099cd4b76cf4e7a6aa95c17122c14835fcee1
 SHA512:
-  metadata.gz: b919c53366fb83912221bf4a642b23db13725535c82449e54f6859d6a6bc76a04582c7b859eb4fb4f9cde814637dd535625eea31ffd62af48f02a6a71642c4f5
-  data.tar.gz: 18d123157532330403229b1365b97e2dcba308de2ed5d07aa16583c973d801bfa1e6aac001f299be7ab445beaf7a1600f204ff058362f1cd84dc7362f7466aca
+  metadata.gz: bd1665669a9d3de5c4b27218c3886e6c0de4c03410f533de318278644c26a8ac467665af74f9026cc39b3243c05afba6fb98ede1bf9c7e4fa922ca6db0fb941e
+  data.tar.gz: a5090e7e0efbcb464e694f413312e942c6e88bf4d84749763d0e40971ee3b0f4cffe564f174d8c8c5368f81ffd7fa353cbccebf0d84117e81d051c5ff1e44f45

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.8.3 — 2026-10-02
+
+- Refine shared Japanese writing and review criteria for established technical
+  terminology, precise operations, direct predicates, and evidence-based tone.
+  Preserve distinctions between assumptions, requirements, and capabilities.
+- Add scoped review candidates for unusual translations, everyday operation
+  wording, indirect predicates, and author-centered emphasis; reuse existing
+  noun, verb, and qualification rules instead of fixed automatic replacements.
+
+## 0.8.2 — 2026-10-02
+
+- Report replacement rule errors with the original YAML filename and one-based
+  line number on the first line and the existing reason on the following line.
+  Track imported rules, pattern arrays, specs, and runtime replacement references
+  without changing exit codes or applying invalid plans.
+
 ## 0.8.1 — 2026-10-01
 
 - Add an opening README feature table and describe prose replacements before

data/README.md

@@ -7,7 +7,7 @@
 
 A toolkit for authoring and reviewing AsciiDoc books.
 
-Version 0.8.1 provides shared Japanese technical writing criteria, an authoring
+Version 0.8.3 provides shared Japanese technical writing criteria, an authoring
 prompt, separate prose and heading review prompts, manuscript scoring, and
 baseline verification for edited manuscripts, plus explicit prose-only mechanical
 replacements using a limited prh-format rule set.
@@ -16,7 +16,7 @@ Japanese text is retained in manuscript excerpts, rule dictionaries, and fixture
 
 ## Available features
 
-The following commands are available in version 0.8.1.
+The following commands are available in version 0.8.3.
 
 | Feature | Commands | Behavior |
 | --- | --- | --- |
@@ -107,7 +107,7 @@ Add the gem to your project's `Gemfile` to manage its version with Bundler:
 
 ```ruby
 source 'https://rubygems.org'
-gem 'asciidoc-pubkit', '~> 0.8.1'
+gem 'asciidoc-pubkit', '~> 0.8.3'
 ```
 
 Then install dependencies and run the CLI through Bundler:
@@ -129,7 +129,7 @@ git clone https://github.com/cybergarage/asciidoc-pubkit.git
 cd asciidoc-pubkit
 bundle install
 gem build asciidoc-pubkit.gemspec
-gem install ./asciidoc-pubkit-0.8.1.gem
+gem install ./asciidoc-pubkit-0.8.3.gem
 asciidoc-pubkit --version
 ```
 
@@ -153,7 +153,7 @@ asciidoc-pubkit writing prompt --lang ja --output writing-prompt.md
 ```
 
 For example, `--lang en` exits with an unsupported-language error. No English
-review or writing criteria are shipped in 0.8.1.
+review or writing criteria are shipped in 0.8.3.
 
 For a small trial, use `examples/book.adoc` as the scan input. Its Japanese
 paragraphs deliberately contain review candidates; its code block must remain
@@ -180,6 +180,19 @@ authorizes source replacement without prompting. Successful diff/apply commands
 return 0; invalid rules, conflicts, unsafe edits, and input/output failures return
 2. Check/diff accept `--output` for a new file only; apply rejects `--output`.
 
+Starting with version 0.8.2, invalid rule files report their original YAML file
+and one-based line number on the first error line, followed by the existing
+reason on the next line. Imported files and entries in pattern arrays retain
+their own source locations. For example:
+
+```text
+Error: /path/to/prh.yml:162
+Unsupported regex flags; only optional i is supported (all matches are collected).
+```
+
+Rules are validated before any manuscript is replaced. All replacement commands
+stop with exit code 2 on invalid rules, including errors found in imported files.
+
 All three accept `--lang ja`, `--base-dir`, `--config`, and `--only` (an included
 source file). Normal configuration discovery and `review.base_dir`, `language`,
 `attributes`, and `exclude` control parsing and selection. `--rules` is required;
@@ -992,6 +1005,18 @@ These are candidates for contextual review, not banned expressions. A necessary
 condition, uncertainty, or distinction must survive a revision; a redundant
 disclaimer can instead be removed or folded into a more precise main claim.
 
+Version 0.8.3 also includes scoped candidates such as `構築入口`,
+`エラーを回収する`, `ツールを呼ぶ`, `したりできます`, and `設計の肝`.
+These additions use the exact surfaces listed in the YAML in both modes;
+they do not add general inflection coverage or ban everyday verbs. Existing
+`木`, `持つ`, `書く`, `別です`, and `ではありません` rules cover related examples.
+The shared criteria explain context-dependent terminology, precise operations,
+direct predicates, and objective tone. They distinguish invocation from
+execution, configuration text from configuration changes, assumptions from
+requirements, and collecting errors from catching them. Suggested alternatives
+are not automatic replacement rules. Start a new review session to include
+updated rules and criteria; existing sessions retain their saved versions.
+
 Metaphorical-operation candidates include limited exact surfaces of
 `地味に効く`, `静かに壊れる`, `時間を溶かす`, and `側に倒す`, including selected polite,
 past, and connective forms listed in the packaged YAML. They use contextual
@@ -1044,12 +1069,12 @@ reports analyzer changes instead of treating results from different dictionaries
 as directly comparable. Prompt generation uses saved evidence and does not need
 MeCab. Changed rules or dictionary settings require a new scan.
 
-Sessions from earlier tool versions are not compatible with 0.8.1 (session schema 2). Keep the original baseline for
+Sessions from earlier tool versions are not compatible with 0.8.3 (session schema 2). Keep the original baseline for
 an ongoing review and finish it with the original version, or start a new review
 pass in a different directory:
 
 ```sh
-asciidoc-pubkit review scan book.adoc --output .pubkit/review-0.8.1
+asciidoc-pubkit review scan book.adoc --output .pubkit/review-0.8.3
 ```
 
 Severity describes review priority, not proof of an error. There is no AI-authorship

data/data/review-rules.ja.yml

@@ -135,6 +135,25 @@ terms:
     # Retain this specific phrase for existing allow lists and fuller evidence.
     - わけではありません
     - 別です
+    # Unusual technical translations; shared criteria own the alternatives.
+    - 構築入口
+    - 実装の読解
+    - エラーを回収する
+    - エラーを回収します
+    - 介入パターン
+    # Object-specific everyday verbs, not general bans on these verbs.
+    - ツールを呼ぶ
+    - ツールを呼びます
+    - 責務を持つ
+    - 指示を読み取る
+    - 指示を読み取ります
+    - 設定を書く
+    - 値を拾う
+    - 値を拾います
+    - 切り出す合図です
+    # Indirect capabilities and prerequisites; preserve their modality.
+    - したりできます
+    - することが前提です
     # Compressed noun relationships; suggestions are not automatic replacements.
     - 明示選択
     - 欠落理由
@@ -158,7 +177,8 @@ terms:
     - でもありません
     - してはいけません
     - 表してはいません
-    question: Check whether the phrase adds a condition that changes the reader's
+    question: Apply the shared prose criteria to terminology, operation wording,
+      indirect predicates, and qualifications. Check whether the phrase adds a condition that changes the reader's
       interpretation or action. If it only denies an overbroad reading already
       excluded by the main claim, revise that claim or remove the qualification.
       Preserve necessary negation, uncertainty, and technical boundaries. For
@@ -176,6 +196,10 @@ terms:
     - まとめると
     - このように
     - 要するに
+    # Author-centered discovery, indirect explanation, and unsupported emphasis.
+    - 見えてきます
+    - 理由がここにあります
+    - 設計の肝
     question: Check whether this opening or recap adds a claim, scope, or consequence
       beyond the surrounding prose. Keep useful framing; otherwise state the
       substantive claim directly. Do not force a uniform sentence pattern.

data/data/writing/ja/criteria.md

@@ -66,6 +66,21 @@ Prefer a precise action or consequence:
 - `結果を残します` becomes `実行したコマンドと結果をプルリクエストへ記録します`
   when that is the storage location.
 
+For everyday verbs, identify the operation before choosing terminology:
+
+| Wording to inspect | Revision when supported by context |
+| --- | --- |
+| ツールを呼ぶ | 呼び出す for invocation; 実行する only for execution |
+| 責務を持つ | 責務を担う when describing responsibility, not stored state or ownership |
+| 指示を読み取る | 解析する for parsing or analysis; 抽出する for selecting information |
+| 設定を書く・設定を書きます | 設定を記述する・定義する for authoring a definition; 設定する for actually configuring something |
+| 値を拾う | 取得する for retrieval; 抽出する for selection from existing data |
+| 切り出す合図です | 切り出す目安です for a judgment criterion; シグナルです only for an actual signal |
+
+A familiar verb is not wrong merely because it is simple. Prefer the most direct
+accurate verb; do not introduce jargon or claim parsing, execution, or a state
+change that the evidence does not establish.
+
 Do not choose a more impressive synonym merely to vary sentence endings. Keep
 the technically correct verb when it names the real operation.
 
@@ -156,6 +171,27 @@ Common patterns that merit paragraph-level review include:
 Keep a contrast when the two alternatives and the difference that affects the
 decision are explicit. Keep necessary repetition when it improves technical
 accuracy.
+Inspect indirect predicates and author-centered emphasis as well:
+
+- Simplify `無効化したりできます` to `無効化できます` when it describes a single
+  capability. Preserve `たり` when it marks a meaningful non-exhaustive list.
+- For `提供することが前提です`, identify whose prerequisite or assumption is
+  stated. Use `提供する必要があります` only when the source establishes an actual
+  requirement; do not turn an assumption into an obligation.
+- For `宣言することは別です`, name what is compared and how it differs. A form such
+  as `宣言することとは異なります` needs an explicit, correctly oriented comparison.
+- For `そうではありません`, state the specific fact or negate the specific claim.
+  `実際には異なります` alone can retain the same missing referent. Preserve negation.
+- For `〜が見えてきます`, state the property the explanation makes identifiable.
+  `理解しやすくなります` is still a reader-effect claim that needs support; retain
+  literal visibility when discussing a display or visualization.
+- For `理由がここにあります`, connect the cause and result directly, for example
+  `これが〜の理由です` when `これ` has a clear referent.
+- For `設計の肝です`, identify the central responsibility or design decision.
+  `重要なポイントです` is not sufficient when it merely replaces one emphasis
+  phrase with another. Remove emotional, essay-like, or promotional emphasis
+  that supplies no technical fact; retain supported judgments and their basis.
+
 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.
@@ -170,12 +206,27 @@ glossary, and primary documentation before changing it.
 - 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.
+- Prefer established terminology in the technical domain, whether Japanese or
+  katakana. Avoid forced literal translations and unnecessary English; retain
+  identifiers, official names, and the project's chosen terminology.
 - 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.
 
+Review unusual translations against the actual concept:
+
+| Wording to inspect | Context-dependent terminology |
+| --- | --- |
+| 木 | ツリー when referring to the data structure; keep literal trees and established mathematical usage |
+| 構築入口 | ビルドのエントリポイント only when the entry point starts a build, not object construction or initialization |
+| 実装の読解 | コードリーディング for reading code; 実装の解析 when analysis is the actual task |
+| エラーを回収する | エラーを捕捉する for catching; ハンドリングする for handling; preserve aggregation or collection when that is the behavior |
+| 介入パターン | フックパターン only when a hook mechanism is established, not arbitrary human intervention |
+
+These alternatives are not interchangeable replacements. Confirm the operation
+and the domain's established usage from code, the glossary, or primary
+documentation; record uncertainty rather than inventing a mechanism.
+
 Natural Japanese must not erase a technical distinction. If the original claim
 is ambiguous, inspect the code or authoritative documentation before editing.
 Preserve numerical values, versions, settings, responsibility, causal claims,

data/lib/asciidoc_pubkit/replacement.rb

@@ -5,56 +5,82 @@ require 'tempfile'
 require 'open3'
 
 module AsciidocPubkit
+  class ReplacementRuleError < Error
+    def initialize(path, node, message, line: nil)
+      super("#{path}:#{line || (node ? node.start_line + 1 : 1)}\n#{message}")
+    end
+  end
+
   class ReplacementRules
+    def self.field(node, name)
+      return unless node.is_a?(Psych::Nodes::Mapping)
+      pair = node.children.each_slice(2).find { |key, _| key.respond_to?(:value) && key.value == name }
+      pair && pair.last
+    end
+
+    def self.item(node, index)
+      node.is_a?(Psych::Nodes::Sequence) ? node.children[index] : node
+    end
+
     def self.load(path)
-      collect(path, [], {}).each_with_index.map do |rule, index|
-        unless rule.is_a?(Hash) && (rule.keys - %w[expected pattern patterns specs]).empty? &&
-               rule['expected'].is_a?(String) && (rule.key?('pattern') ^ rule.key?('patterns'))
-          raise Error, "Rule #{index + 1} requires expected and exactly one of pattern or patterns; unsupported keys are rejected."
-        end
-        patterns = rule.key?('pattern') ? rule['pattern'] : rule['patterns']
-        patterns = [patterns] if rule.key?('pattern') && patterns.is_a?(String)
-        unless patterns.is_a?(Array) && !patterns.empty? && patterns.all? { |p| p.is_a?(String) && !p.empty? }
-          raise Error, 'Replacement patterns must be nonempty strings.'
-        end
-        compiled = patterns.map do |pattern|
-          if pattern.start_with?('/')
-            match = pattern.match(%r{\A/(.*)/([a-z]*)\z}m)
-            unless match && ['', 'i'].include?(match[2])
-              raise Error, 'Unsupported regex flags; only optional i is supported (all matches are collected).'
-            end
-            body = match[1]
-            # Deliberately small common JavaScript/Ruby subset; Ruby-only escapes
-            # and engine-specific groups must not silently change JS semantics.
-            if body.match?(/\\[^\\\/.*+?()\[\]{}^$|nrtdDsSwWbB-]/) || body.match?(/\(\?(?![:=!]|<[=!])/) || body.include?('&&')
-              raise Error, 'Unsupported regex syntax in replacement rule.'
-            end
-            ignore_case = match[2] == 'i'
-            body = javascript_boundaries(body, ignore_case: ignore_case)
-            Regexp.new(body.gsub('\\/', '/'), ignore_case ? Regexp::IGNORECASE : 0, timeout: 0.1)
-          else
-            Regexp.new(Regexp.escape(pattern), timeout: 0.1)
-          end
-        end
-        compiled.each do |regex|
-          regex.match('') # Detect common empty matches; runtime checks cover contextual ones.
-          raise Error, 'Zero-length replacement matches are unsupported.' if regex.match('')
-        end
-        specs = rule.fetch('specs', [])
-        raise Error, 'specs must be an array.' unless specs.is_a?(Array)
-        specs.each do |spec|
-          RuleSet.mapping(spec, %w[from to], 'Replacement spec')
-          raise Error, 'Spec from/to must be strings.' unless spec.values.all? { |v| v.is_a?(String) }
-          result = spec['from'].dup
-          edits = matches(spec['from'], compiled, rule['expected'])
-          reject_overlaps!(edits)
-          edits.reverse_each { |edit| result[edit[:start]...edit[:finish]] = edit[:after] }
-          raise Error, "Replacement spec failed for rule #{index + 1}." unless result == spec['to']
-        end
-        { id: "rule-#{index + 1}", patterns: compiled, expected: rule['expected'] }
+      collect(path, [], {}).each_with_index.map { |source, index| compile(source, index) }
+    end
+
+    def self.compile(source, index)
+      rule = source[:value]
+      location = source[:node]
+      unless rule.is_a?(Hash) && (rule.keys - %w[expected pattern patterns specs]).empty? &&
+             rule['expected'].is_a?(String) && (rule.key?('pattern') ^ rule.key?('patterns'))
+        raise Error, "Rule #{index + 1} requires expected and exactly one of pattern or patterns; unsupported keys are rejected."
+      end
+      pattern_node = field(source[:node], rule.key?('pattern') ? 'pattern' : 'patterns')
+      location = pattern_node
+      patterns = rule.key?('pattern') ? rule['pattern'] : rule['patterns']
+      patterns = [patterns] if rule.key?('pattern') && patterns.is_a?(String)
+      unless patterns.is_a?(Array) && !patterns.empty? && patterns.all? { |p| p.is_a?(String) && !p.empty? }
+        raise Error, 'Replacement patterns must be nonempty strings.'
       end
+      compiled = patterns.each_with_index.map do |pattern, pattern_index|
+        location = item(pattern_node, pattern_index)
+        regex = if pattern.start_with?('/')
+                  match = pattern.match(%r{\A/(.*)/([a-z]*)\z}m)
+                  unless match && ['', 'i'].include?(match[2])
+                    raise Error, 'Unsupported regex flags; only optional i is supported (all matches are collected).'
+                  end
+                  body = match[1]
+                  # Deliberately small common JavaScript/Ruby subset; Ruby-only escapes
+                  # and engine-specific groups must not silently change JS semantics.
+                  if body.match?(/\\[^\\\/.*+?()\[\]{}^$|nrtdDsSwWbB-]/) || body.match?(/\(\?(?![:=!]|<[=!])/) || body.include?('&&')
+                    raise Error, 'Unsupported regex syntax in replacement rule.'
+                  end
+                  ignore_case = match[2] == 'i'
+                  body = javascript_boundaries(body, ignore_case: ignore_case)
+                  Regexp.new(body.gsub('\\/', '/'), ignore_case ? Regexp::IGNORECASE : 0, timeout: 0.1)
+                else
+                  Regexp.new(Regexp.escape(pattern), timeout: 0.1)
+                end
+        raise Error, 'Zero-length replacement matches are unsupported.' if regex.match('')
+        regex
+      end
+      location = field(source[:node], 'specs') || source[:node]
+      specs = rule.fetch('specs', [])
+      raise Error, 'specs must be an array.' unless specs.is_a?(Array)
+      specs.each_with_index do |spec, spec_index|
+        location = item(field(source[:node], 'specs'), spec_index)
+        RuleSet.mapping(spec, %w[from to], 'Replacement spec')
+        raise Error, 'Spec from/to must be strings.' unless spec.values.all? { |v| v.is_a?(String) }
+        result = spec['from'].dup
+        edits = matches(spec['from'], compiled, rule['expected'])
+        reject_overlaps!(edits)
+        edits.reverse_each { |edit| result[edit[:start]...edit[:finish]] = edit[:after] }
+        raise Error, "Replacement spec failed for rule #{index + 1}." unless result == spec['to']
+      end
+      { id: "rule-#{index + 1}", patterns: compiled, expected: rule['expected'],
+        path: source[:path], node: source[:node], pattern_node: pattern_node }
     rescue RegexpError, Regexp::TimeoutError => e
-      raise Error, "Invalid replacement regex: #{e.message}"
+      raise ReplacementRuleError.new(source[:path], location, "Invalid replacement regex: #{e.message}")
+    rescue Error => e
+      raise ReplacementRuleError.new(source[:path], location, e.message)
     end
 
     # prh uses Unicode JS regexes: word characters are ASCII letters/digits/_;
@@ -92,25 +118,35 @@ module AsciidocPubkit
     end
 
     def self.collect(path, active, visited)
+      path = File.expand_path(path)
+      location = nil
       path = File.realpath(path)
       if active.include?(path)
         raise Error, "Circular replacement imports: #{(active + [path]).join(' -> ')}"
       end
       return [] if visited[path]
       raise Error, 'Replacement imports exceed the maximum depth of 100 files.' if active.length >= 100
-      data = YAML.safe_load(AsciidocPubkit.read_text(path), permitted_classes: [], aliases: false)
+      text = AsciidocPubkit.read_text(path)
+      tree = Psych.parse_stream(text, filename: path)
+      root = tree.children.first&.root
+      location = root
+      data = YAML.safe_load(text, permitted_classes: [], aliases: false)
       unless data.is_a?(Hash) && data.key?('version') && (data.keys - %w[version rules imports]).empty?
         raise Error, "Replacement rules in #{path} require version and accept only rules and imports."
       end
+      location = field(root, 'version')
       unless data['version'].is_a?(Integer) && data['version'] == 1
         raise Error, "Replacement version in #{path} must be integer 1."
       end
       rules = data.fetch('rules', [])
       rules = [] if rules.nil?
       imports = data.fetch('imports', [])
+      location = field(root, 'rules')
       raise Error, "rules in #{path} must be an array." unless rules.is_a?(Array)
+      location = field(root, 'imports')
       raise Error, "imports in #{path} must be an array." unless imports.is_a?(Array)
-      imported = imports.flat_map do |entry|
+      imported = imports.each_with_index.flat_map do |entry, index|
+        location = item(field(root, 'imports'), index)
         if entry.is_a?(Hash)
           RuleSet.mapping(entry, ['path'], "Replacement import in #{path}")
           entry = entry['path']
@@ -121,9 +157,14 @@ module AsciidocPubkit
         collect(File.expand_path(entry, File.dirname(path)), active + [path], visited)
       end
       visited[path] = true
-      imported + rules
+      imported + rules.each_with_index.map { |rule, index| { value: rule, path: path, node: item(field(root, 'rules'), index) } }
+    rescue ReplacementRuleError
+      raise
     rescue Psych::Exception => e
-      raise Error, "Invalid replacement YAML in #{path}: #{e.message}"
+      raise ReplacementRuleError.new(path, location, "Invalid replacement YAML in #{path}: #{e.message}",
+                                     line: e.respond_to?(:line) ? e.line : nil)
+    rescue Error, SystemCallError => e
+      raise ReplacementRuleError.new(path, location, e.message)
     end
 
     def self.expand(template, match)
@@ -138,16 +179,23 @@ module AsciidocPubkit
       end
     end
 
-    def self.matches(text, patterns, expected)
-      patterns.flat_map do |regex|
-        text.to_enum(:scan, regex).map do
-          match = Regexp.last_match
-          raise Error, 'Zero-length replacement matches are unsupported.' if match.begin(0) == match.end(0)
-          { start: match.begin(0), finish: match.end(0), before: match[0], after: expand(expected, match) }
+    def self.matches(text, patterns, expected, source: nil)
+      patterns.each_with_index.flat_map do |regex, index|
+        begin
+          text.to_enum(:scan, regex).map do
+            match = Regexp.last_match
+            raise Error, 'Zero-length replacement matches are unsupported.' if match.begin(0) == match.end(0)
+            { start: match.begin(0), finish: match.end(0), before: match[0], after: expand(expected, match) }
+          end
+        rescue Error, Regexp::TimeoutError => e
+          message = e.is_a?(Regexp::TimeoutError) ? 'Replacement regex timed out.' : e.message
+          if source
+            location = message.start_with?('Unsupported replacement reference:') ? field(source[:node], 'expected') : item(source[:pattern_node], index)
+            raise ReplacementRuleError.new(source[:path], location, message)
+          end
+          raise Error, message
         end
       end.reject { |edit| edit[:before] == edit[:after] }.uniq.sort_by { |edit| edit[:start] }
-    rescue Regexp::TimeoutError
-      raise Error, 'Replacement regex timed out.'
     end
 
     def self.reject_overlaps!(edits)
@@ -181,7 +229,7 @@ module AsciidocPubkit
         line_offsets = [0]
         lines.each { |line| line_offsets << line_offsets.last + line.length }
         rules.each do |rule|
-          ReplacementRules.matches(text, rule[:patterns], rule[:expected]).each do |edit|
+          ReplacementRules.matches(text, rule[:patterns], rule[:expected], source: rule).each do |edit|
             next if protected_ranges.any? { |range| edit[:start] < range.end && edit[:finish] > range.begin }
             # Keep physical line boundaries intact, including CRLF.
             raise Error, 'Replacement matches and results must stay on one line.' if (edit[:before] + edit[:after]).match?(/[\r\n]/)

data/lib/asciidoc_pubkit.rb

@@ -9,7 +9,7 @@ require 'pathname'
 require 'optparse'
 
 module AsciidocPubkit
-  VERSION = '0.8.1'
+  VERSION = '0.8.3'
   class Error < StandardError; end
 
   def self.hash_text(text)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciidoc-pubkit
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - CyberGarage