daidai 0.1.0

data/NOTICE

@@ -0,0 +1,42 @@
+Daidai
+Copyright (c) davafons
+
+This product bundles conjugation data and ports the conjugation algorithm from
+the JMdictDB project, which are distributed under the GNU General Public
+License. Because of this lineage, Daidai itself is licensed under the GPL-3.0
+(see LICENSE).
+
+-------------------------------------------------------------------------------
+jconj
+-------------------------------------------------------------------------------
+The conjugation tables vendored under lib/daidai/resources/ (conj.csv,
+conjo.csv, conotes.csv, kwpos.csv) are copied verbatim from jconj, and Daidai's
+conjugation algorithm is a faithful port of jconj's.
+
+    jconj — by Stuart McGraw
+    https://gitlab.com/yamagoya/jconj
+    Licensed under the GNU General Public License.
+
+-------------------------------------------------------------------------------
+Yomitan
+-------------------------------------------------------------------------------
+The deinflector (lib/daidai/deinflector.rb) and its rule set vendored under
+lib/daidai/resources/japanese-transforms.json are ported from Yomitan's
+Japanese language transforms and LanguageTransformer.
+
+    Yomitan — by the Yomitan Authors
+    https://github.com/yomidevs/yomitan
+    Licensed under the GNU General Public License v3.0.
+
+-------------------------------------------------------------------------------
+JMdict / JMdictDB (EDRDG)
+-------------------------------------------------------------------------------
+The conjugation tables and the part-of-speech taxonomy originate in the
+JMdictDB / JMdict project, maintained by Jim Breen's Electronic Dictionary
+Research and Development Group (EDRDG).
+
+    JMdict / JMdictDB
+    https://www.edrdg.org/
+    Used under the EDRDG Licence.
+
+Please retain this NOTICE file and the attributions above in any redistribution.

data/README.md

@@ -0,0 +1,267 @@
+<h1 align="center">Daidai</h1>
+
+<p align="center">
+  <a href="https://rubygems.org/gems/daidai"><img src="https://img.shields.io/gem/v/daidai" alt="Gem Version"></a>
+  <a href="https://github.com/basecamp/gh-signoff"><img src="https://img.shields.io/badge/CI-signoff-blue" alt="Signoff"></a>
+  <a href="https://github.com/davafons/daidai/blob/main/LICENSE"><img src="https://img.shields.io/github/license/davafons/daidai" alt="License"></a>
+  <a href="https://rubygems.org/gems/daidai"><img src="https://img.shields.io/gem/dt/daidai" alt="Downloads"></a>
+</p>
+
+Pure-Ruby Japanese verb and adjective conjugation. Daidai (橙) is table-driven: all the grammar lives in the conjugation tables from [JMdictDB](https://gitlab.com/yamagoya/jmdictdb) (Jim Breen's [EDRDG](https://www.edrdg.org/)), the same tables that power EDRDG's live conjugator, applied by a faithful Ruby port of [jconj](https://gitlab.com/yamagoya/jconj)'s algorithm. No native extension, no runtime services, just the tables and a small, app-friendly API.
+
+```ruby
+verb = Daidai.conjugate("書く", "v5k")    # a word + its JMdict part of speech
+
+verb.past                        # => 書いた
+verb.past(polite: true)          # => 書きました
+verb.te                          # => 書いて
+verb.non_past(negative: true)    # => 書かない
+verb.polite.negative.past        # => 書きませんでした   (fluent, and chainable)
+
+# Don't know the part of speech? Let kabosu (Sudachi) resolve it, even from an
+# already-inflected word:
+Daidai.conjugate("食べている").word   # => "食べる"
+```
+
+## Installation
+
+- Ruby >= 3.1
+
+Add to your Gemfile:
+
+```ruby
+gem "daidai"
+```
+
+Then install:
+
+```sh
+bundle install
+```
+
+The conjugation tables ship vendored inside the gem, so there is nothing to download; conjugation works offline out of the box.
+
+## Usage
+
+Pass a dictionary-form word and its [JMdict part-of-speech code](https://www.edrdg.org/jmdictdb/cgi-bin/edhelpq.py?svc=jmdict&sid=#kw_pos). `Daidai.conjugate` returns a `Daidai::Word`, or `nil` when nothing is conjugatable.
+
+```ruby
+require "daidai"
+
+verb = Daidai.conjugate("書く", "v5k")   # word + JMdict POS code
+
+verb.past          # => #<Daidai::Form past: 書いた>
+verb.past.to_s     # => "書いた"   (Form#to_s, works directly in "#{...}")
+verb.te            # => 書いて
+verb.potential     # => 書ける
+verb.volitional    # => 書こう
+```
+
+The `reading` is **optional**: conjugation only ever rewrites the okurigana, which is already in the surface form, so the kanji forms need no reading. Pass one only when you also want each form's kana:
+
+```ruby
+verb = Daidai.conjugate("書く", "v5k", reading: "かく")
+verb.past.kanji    # => "書いた"
+verb.past.reading  # => "かいた"
+
+# A kana-only word is its own reading:
+Daidai.conjugate("する", "vs-i").past.to_s   # => "した"
+```
+
+### Negative & polite
+
+Polarity and formality are named. Use keyword modifiers (canonical) or chainable fluent views (sugar):
+
+```ruby
+verb = Daidai.conjugate("書く", "v5k")
+
+# keyword modifiers
+verb.non_past(negative: true)            # => 書かない
+verb.past(polite: true)                  # => 書きました
+verb.past(negative: true, polite: true)  # => 書きませんでした
+
+# fluent views, read like grammar, and chain
+verb.polite.past                # => 書きました
+verb.negative.non_past          # => 書かない
+verb.polite.negative.non_past   # => 書きません
+```
+
+### The forms
+
+A `Daidai::Word` is `Enumerable` and exposes every form **by name**, with no integer ids:
+
+```ruby
+Daidai::FORMS.keys
+# => [:non_past, :past, :te, :provisional, :potential, :passive, :causative,
+#     :causative_passive, :volitional, :imperative, :conditional, :alternative, :stem]
+
+verb.conjugations                    # => the form names present for this word
+verb.forms                           # => every Daidai::Form
+verb.each { |form| ... }             # Enumerable
+verb[:past, polite: true]            # dynamic access (== verb.past(polite: true))
+verb.variants(:te, negative: true)   # every accepted variant: 書かなくて, 書かないで
+```
+
+A `Daidai::Form`:
+
+```ruby
+form = verb.past(polite: true)
+form.to_s       # => "書きました"   - the kanji form, or the kana if there is no kanji
+form.kanji      # => "書きました"
+form.reading    # => nil unless a reading was supplied
+form.name       # => :past
+form.label      # => "Past"
+form.negative?  # => false
+form.polite?    # => true
+```
+
+### Word classes
+
+```ruby
+Daidai.conjugate("食べる", "v1").kind     # => :ichidan
+Daidai.conjugate("来る", "vk").kind        # => :kuru          (来る / くる both handled)
+Daidai.conjugate("高い", "adj-i").kind     # => :i_adjective
+Daidai.conjugate("静か", "adj-na").kind    # => :na_adjective  (conjugated via the copula だ)
+```
+
+### Checking conjugatability
+
+`Daidai.conjugatable?` takes a single JMdict code or an array, and is true when at least one is conjugatable. Handy for deciding whether to show a conjugation table for a dictionary entry:
+
+```ruby
+Daidai.conjugatable?("v5k")            # => true
+Daidai.conjugatable?("n")              # => false
+Daidai.conjugatable?(["n", "v1"])      # => true   - first conjugatable code wins
+```
+
+When `pos` is an array, `Daidai.conjugate` likewise picks the first conjugatable code.
+
+## Conjugate by word alone (optional)
+
+Don't have the part of speech? Omit it, and Daidai uses the optional [`kabosu`](https://github.com/davafons/kabosu) gem (Ruby bindings for the [Sudachi](https://github.com/WorksApplications/sudachi.rs) morphological analyzer) to resolve the dictionary form, POS and reading from any input, **including inflected ones**:
+
+```ruby
+Daidai.conjugate("食べている").word   # => "食べる"   (progressive → its dictionary verb)
+Daidai.conjugate("行った").word       # => "行く"     (irregular v5k-s, correctly identified)
+Daidai.conjugate("高くない").word     # => "高い"     (negative adjective → adj-i)
+Daidai.conjugate("勉強した").word     # => "勉強"     (noun + する → vs)
+Daidai.conjugate("猫")               # => nil        (not conjugatable)
+```
+
+This resolves the word so you can conjugate it (forward inflection from a dictionary entry). To go the other way and *name* the inflection ("…is the progressive of…"), see [Deinflection](#deinflection-inflected-form-to-dictionary-form) below. For lemma lookup in a larger app you likely already have a tokenizer; this is a convenience for the conjugation use case.
+
+`kabosu` and a Sudachi dictionary are **not** dependencies of Daidai; the gem stays pure Ruby. Add them only if you want this path:
+
+```ruby
+# Gemfile
+gem "daidai"
+gem "kabosu"
+```
+
+```sh
+bundle exec rake kabosu:install   # download a Sudachi dictionary (one-time)
+```
+
+Without them, the POS-less path raises `Daidai::Kabosu::MissingDependency`. The escape hatch is always to pass the POS yourself, and then kabosu never loads:
+
+```ruby
+Daidai.conjugate("食べる", "v1")   # pure Ruby, no kabosu
+```
+
+## Deinflection (inflected form to dictionary form)
+
+`Daidai.deinflect` is the inverse of `conjugate`: give it an inflected surface
+form and it returns the dictionary form(s) it could come from, **naming each
+inflection** along the way. It is pure Ruby and offline, with no Sudachi/kabosu
+needed, and it covers colloquial contractions (てる, ちゃう, とく, …):
+
+```ruby
+Daidai.deinflect("食べてる")
+# includes #<Daidai::Deinflection 食べる [-いる, -て]>   (the progressive of 食べる)
+
+Daidai.deinflect("読まなかった")
+# includes #<Daidai::Deinflection 読む [-た, negative]>   (negative past of 読む)
+```
+
+Each result is a `Daidai::Deinflection`:
+
+```ruby
+d = Daidai.deinflect("食べてる").find { |x| x.term == "食べる" }
+d.term              # => "食べる"             (the candidate dictionary form)
+d.inflections       # => ["-いる", "-て"]      (rule names, surface to dictionary)
+d.dictionary_form?  # => true                (chain lands on a known dictionary form)
+d.to_s              # => "食べる [-いる, -て]"
+```
+
+Deinflection is rule-based and **dictionary-free**, so it returns *every* base
+form the rules can reach — many of which are not real words (食べてる also yields
+食べつ as a hypothetical potential). It is meant to feed a dictionary lookup: keep
+the candidates whose `term` is a real entry. If you have no dictionary, filtering
+to `dictionary_form?` candidates keeps the plausible lemmas.
+
+This pairs naturally with a dictionary like JMdict: deinflect the query, look up
+each candidate `term`, and you have the lemma, its part of speech, and the named
+inflection — without a morphological analyzer. (For a single authoritative lemma
++ reading from arbitrary text, including full sentences, the kabosu path above is
+still the tool; the two are complementary.)
+
+The rule set is ported from [Yomitan](https://github.com/yomidevs/yomitan)'s
+Japanese language transforms and is vendored as JSON under
+`lib/daidai/resources/`. Both Yomitan and Daidai are GPL-3.0; see `NOTICE`.
+
+## Data & tables
+
+All of the linguistic knowledge lives in four tab-separated tables vendored under `lib/daidai/resources/`, taken from **JMdictDB** (the maintained home of these tables; jconj is the standalone reference implementation Daidai ports):
+
+| File | Contents |
+|------|----------|
+| `conj.csv` | conjugation ids and their names |
+| `conjo.csv` | okurigana rules (one per pos / conjugation / negative / polite / variant) |
+| `conotes.csv` | usage notes attached to conjugations |
+| `kwpos.csv` | JMdict part-of-speech keywords and their numeric ids |
+
+The conjugator just applies these rules: it drops the citation-form okurigana, applies any euphonic change, and appends the conjugated ending. Nothing is hard-coded per verb, so keeping the tables current keeps the whole gem current. (Japanese conjugation grammar is stable, so these tables change rarely.)
+
+Refresh the vendored tables from upstream with:
+
+```sh
+rake daidai:sync
+```
+
+This downloads the latest `conj.csv`, `conjo.csv`, `conotes.csv`, and `kwpos.csv` from the [JMdictDB repository](https://gitlab.com/yamagoya/jmdictdb) and writes them into `lib/daidai/resources/`. Review the diff before committing. `rake daidai:check_resources` fails if the bundled tables have drifted from upstream.
+
+## Data & attribution
+
+The conjugation algorithm and tables are not original to Daidai. They come from:
+
+- **JMdictDB** (<https://gitlab.com/yamagoya/jmdictdb>), by Stuart McGraw: the actively-maintained home of the conjugation tables and part-of-speech taxonomy, under Jim Breen's **Electronic Dictionary Research and Development Group (EDRDG)**, <https://www.edrdg.org/>.
+- **jconj** (<https://gitlab.com/yamagoya/jconj>): the standalone, table-based conjugator whose algorithm Daidai ports to Ruby.
+
+Because the upstream work is GPL-licensed, Daidai inherits that lineage and is distributed under the **GPL-3.0** license. The JMdict/JMdictDB data is used under the EDRDG licence; please retain the attribution above and the `NOTICE` file in any redistribution.
+
+## Development
+
+```sh
+bundle install
+
+bundle exec rake test    # Run the test suite
+bundle exec rake lint    # RuboCop
+bundle exec rake         # lint + test (default)
+```
+
+### Signing off
+
+This project uses [gh-signoff](https://github.com/basecamp/gh-signoff) instead of cloud CI: you run the checks locally and sign off on the commit, which sets a `signoff` status check that branch protection requires.
+
+```sh
+gh extension install basecamp/gh-signoff   # one-time
+bundle exec rake signoff                   # runs lint + test, signs off ONLY if they pass
+```
+
+`rake signoff` makes `lint` and `test` prerequisites, so it won't sign off a red commit. (Running `gh signoff create -f` by hand skips that gate; gh-signoff is trust-based.) The `-f` flag is needed because jj leaves git's HEAD detached.
+
+`gh signoff install` configures `main` to require the signoff status. To refresh the vendored conjugation tables from upstream, see `rake daidai:sync` above.
+
+## License
+
+Daidai is released under the [GPL-3.0](LICENSE) license, in keeping with its JMdictDB / jconj lineage. See `LICENSE` and `NOTICE` for the full terms and upstream attribution.

data/lib/daidai/conjugator.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "tables"
+require_relative "word"
+
+module Daidai
+  # Turns a dictionary-form word + its JMdict part-of-speech into the full
+  # conjugation paradigm. This is a faithful Ruby port of jconj's table-driven
+  # algorithm (Stuart McGraw / EDRDG; GPL) — all the linguistic knowledge lives
+  # in the vendored tables, this just applies them.
+  module Conjugator
+    # The four (negative?, polite?) quadrants every conjugation is generated in.
+    QUADRANTS = [ [ false, false ], [ false, true ], [ true, false ], [ true, true ] ].freeze
+
+    # JMdict codes whose full paradigm lives directly in conjo.csv, mapped to a
+    # coarse kind for grouping. Archaic classes (v2*, v4*) and bare nouns are
+    # deliberately absent — they simply aren't offered for conjugation.
+    DIRECT = {
+      "adj-i" => :i_adjective, "adj-ix" => :i_adjective,
+      "v1" => :ichidan, "v1-s" => :ichidan,
+      "v5aru" => :godan, "v5b" => :godan, "v5g" => :godan, "v5k" => :godan,
+      "v5k-s" => :godan, "v5m" => :godan, "v5n" => :godan, "v5r" => :godan,
+      "v5r-i" => :godan, "v5s" => :godan, "v5t" => :godan, "v5u" => :godan,
+      "v5u-s" => :godan,
+      "vk" => :kuru, "vs-i" => :suru, "vs-s" => :suru
+    }.freeze
+
+    COPULA_POS = 15  # the copula だ — na-adjectives conjugate through it
+    SURU_POS   = 48  # vs-i (する) — `vs` nouns conjugate by appending する
+
+    class << self
+      # True if any of `pos` (a JMdict code or array of codes) can be conjugated.
+      def conjugatable?(pos)
+        Array(pos).any? { |code| strategy(code.to_s) }
+      end
+
+      # Conjugate `kanji`/`reading` (dictionary forms) according to `pos`. When
+      # `pos` is an array the first conjugatable code wins. Returns a Result, or
+      # nil when nothing is conjugatable.
+      def conjugate(kanji:, reading:, pos:)
+        code = Array(pos).map(&:to_s).find { |c| strategy(c) }
+        return nil unless code
+
+        strat   = strategy(code)
+        kanji   = nil if kanji.to_s.empty?
+        reading = reading.to_s
+        return nil if kanji.nil? && reading.empty?
+
+        forms = build(strat, kanji, reading)
+        forms.empty? ? nil : Word.new(word: kanji || reading, pos: code, kind: strat[:kind], forms: forms)
+      end
+
+      private
+
+      # Walk every (conjugation, quadrant, onum) row defined for this pos and
+      # construct the inflected kanji + reading.
+      def build(strat, kanji, reading)
+        if strat[:append]
+          kanji = (kanji || reading) + strat[:append]
+          reading += strat[:append]
+        end
+
+        Tables.conj.keys.sort.flat_map do |conj_id|
+          QUADRANTS.flat_map do |negative, polite|
+            (1..9).filter_map do |onum|
+              row = Tables.conjo[[ strat[:pos_id], conj_id, negative, polite, onum ]]
+              next unless row
+
+              kf = inflect(strat, kanji, row)
+              rf = inflect(strat, reading, row)
+              next if kf.nil? && rf.nil?
+
+              Form.new(name: FORM_BY_ID[conj_id],
+                       negative: negative, polite: polite, onum: onum,
+                       kanji: kf, reading: rf)
+            end
+          end
+        end
+      end
+
+      def inflect(strat, text, row)
+        return nil if text.nil? || text.empty?
+
+        if strat[:suffix]
+          # Copula forms are whole suffixes appended to the citation form
+          # (静か → 静かだ / 静かではない); no stem stripping or euphony.
+          text + row.okuri.to_s
+        else
+          construct(text, row.stem, row.okuri, row.euphr, row.euphk)
+        end
+      end
+
+      # Port of jconj `construct()`: drop `stem` trailing characters (plus one
+      # more when a euphonic change applies to this script), then append the
+      # euphonic stem char and the okurigana. Whether `text` is treated as kana
+      # (euphr) or kanji (euphk) is decided by its next-to-last character — the
+      # one that actually inflects.
+      def construct(text, stem, okuri, euphr, euphk)
+        return nil if text.length < 2
+
+        kana = text[-2] > "あ" && text[-2] <= "ん"
+        euph = kana ? euphr : euphk
+        stem += 1 if euph
+        cut = text.length - stem
+        return nil if cut.negative?
+
+        text[0, cut] + (euph || "") + okuri.to_s
+      end
+
+      # JMdict code => { pos_id:, kind:, [suffix:|append:] }, or nil.
+      def strategy(code)
+        if (kind = DIRECT[code])
+          { pos_id: Tables.pos_ids.fetch(code), kind: kind }
+        elsif code == "adj-na"
+          { pos_id: COPULA_POS, kind: :na_adjective, suffix: true }
+        elsif code == "vs"
+          { pos_id: SURU_POS, kind: :suru, append: "する" }
+        end
+      end
+    end
+  end
+end

data/lib/daidai/deinflector.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Daidai
+  # A single deinflection candidate: a base-form `term` reached from the input by
+  # applying `inflections` (transform names, ordered from the surface form inward
+  # to the dictionary form). `dictionary_form?` is true when the rule chain lands
+  # on a recognised dictionary form (a likely real lemma) — useful for callers
+  # without their own dictionary to look the term up in.
+  #
+  #   Daidai.deinflect("食べてる")   # candidate base forms, each with named inflections;
+  #                                  # one is #<Daidai::Deinflection 食べる [-いる, -て]>
+  Deinflection = Struct.new(:term, :inflections, :conditions, :dictionary_form, keyword_init: true) do
+    def dictionary_form? = dictionary_form
+
+    def to_s = inflections.empty? ? term : "#{term} [#{inflections.join(", ")}]"
+
+    def inspect = "#<Daidai::Deinflection #{self}>"
+  end
+
+  # Rule-based Japanese deinflector: turns an inflected surface form back into its
+  # dictionary form(s), naming each inflection along the way ("食べてる" is the
+  # progressive of "食べる"). This is the inverse of Daidai's forward conjugation.
+  #
+  # The rule set is ported from Yomitan's Japanese language transforms
+  # (ext/js/language/ja/japanese-transforms.js), vendored as JSON under
+  # resources/; the algorithm is a port of Yomitan's LanguageTransformer. Both are
+  # GPL-3.0 — see NOTICE. Unlike Daidai's forward tables, these rules also cover
+  # colloquial contractions (てる, ちゃう, とく, …).
+  #
+  # Unlike `Daidai.conjugate(word)`, this needs no Sudachi/kabosu — it is pure,
+  # offline, string-rule deinflection.
+  module Deinflector
+    DATA_FILE = File.expand_path("resources/japanese-transforms.json", __dir__)
+
+    # One deinflection rule: a test for the inflected form and how to undo it.
+    Rule = Struct.new(:is_inflected, :deinflect, :conditions_in, :conditions_out, keyword_init: true)
+
+    # A named group of rules (one grammatical transformation, e.g. "negative").
+    Transform = Struct.new(:id, :name, :rules, :heuristic, keyword_init: true)
+
+    # An intermediate (or final) deinflected form during the search.
+    TransformedText = Struct.new(:text, :conditions, :trace, keyword_init: true)
+
+    class << self
+      # Every deinflection candidate for `text`, faithful to the transformer: each
+      # term the rules can reach, with its named inflection chain. Excludes the
+      # trivial zero-transform identity. Callers with a dictionary look up each
+      # `term`; callers without one can keep only `dictionary_form?` candidates.
+      def deinflect(text)
+        transform(text)
+          .reject { |t| t.trace.empty? }
+          .map { |t| to_deinflection(t) }
+          .uniq { |d| [ d.term, d.inflections ] }
+      end
+
+      # The raw transformer output (a TransformedText per reachable form, including
+      # the identity). Mirrors Yomitan's LanguageTransformer#transform.
+      def transform(source_text)
+        results = [ TransformedText.new(text: source_text, conditions: 0, trace: []) ]
+        i = 0
+        while i < results.length
+          current = results[i]
+          transforms.each do |transform|
+            next unless transform.heuristic.match?(current.text)
+
+            transform.rules.each_with_index do |rule, j|
+              next unless conditions_match?(current.conditions, rule.conditions_in)
+              next unless rule.is_inflected.match?(current.text)
+              next if cycle?(current.trace, transform.id, j, current.text)
+
+              results << TransformedText.new(
+                text: rule.deinflect.call(current.text),
+                conditions: rule.conditions_out,
+                trace: [ { transform: transform.id, rule_index: j, text: current.text } ] + current.trace
+              )
+            end
+          end
+          i += 1
+        end
+        results
+      end
+
+      def reload!
+        @data = @condition_flags = @dictionary_mask = @transforms = @transforms_by_id = nil
+      end
+
+      private
+
+      def to_deinflection(transformed)
+        Deinflection.new(
+          term: transformed.text,
+          # trace is newest-first (innermost rule first); reverse so the names read
+          # from the surface form inward to the dictionary form.
+          inflections: transformed.trace.reverse.map { |frame| transforms_by_id[frame[:transform]].name },
+          conditions: transformed.conditions,
+          dictionary_form: transformed.conditions.anybits?(dictionary_mask)
+        )
+      end
+
+      def conditions_match?(current, following)
+        current.zero? || current.anybits?(following)
+      end
+
+      def cycle?(trace, transform_id, rule_index, text)
+        trace.any? { |f| f[:transform] == transform_id && f[:rule_index] == rule_index && f[:text] == text }
+      end
+
+      def data
+        @data ||= JSON.parse(File.read(DATA_FILE))
+      end
+
+      def transforms
+        @transforms ||= build_transforms
+      end
+
+      def transforms_by_id
+        @transforms_by_id ||= transforms.to_h { |t| [ t.id, t ] }
+      end
+
+      def build_transforms
+        flags = condition_flags
+        data["transforms"].map do |id, t|
+          rules = t["rules"].map { |r| build_rule(r, flags) }
+          heuristic = Regexp.new(rules.map { |r| r.is_inflected.source }.join("|"))
+          Transform.new(id: id, name: t["name"], rules: rules, heuristic: heuristic)
+        end
+      end
+
+      # Build a rule's matcher + undo closure. The inflected/deinflected fragments
+      # are literal kana/kanji (no regex metacharacters), matched verbatim as in
+      # Yomitan's helpers.
+      def build_rule(rule, flags)
+        inflected, deinflected = rule.values_at("inflected", "deinflected")
+        is_inflected, deinflect =
+          case rule["type"]
+          when "suffix"
+            [ /#{inflected}$/, ->(text) { text[0...(text.length - inflected.length)] + deinflected } ]
+          when "wholeWord"
+            [ /\A#{inflected}\z/, ->(_text) { deinflected } ]
+          when "prefix"
+            [ /\A#{inflected}/, ->(text) { deinflected + text[inflected.length..] } ]
+          else
+            raise Error, "Unknown deinflection rule type: #{rule["type"]}"
+          end
+        Rule.new(
+          is_inflected: is_inflected,
+          deinflect: deinflect,
+          conditions_in: strict_flags(flags, rule["conditionsIn"]),
+          conditions_out: strict_flags(flags, rule["conditionsOut"])
+        )
+      end
+
+      # Bitmask of every dictionary-form condition, for tagging terminal lemmas.
+      def dictionary_mask
+        @dictionary_mask ||= data["conditions"].sum do |type, c|
+          c["isDictionaryForm"] ? condition_flags[type] : 0
+        end
+      end
+
+      # Assign each leaf condition a distinct bit; a condition with subConditions
+      # gets the OR of theirs. Resolved iteratively since a parent may precede its
+      # children (a port of LanguageTransformer#_getConditionFlagsMap).
+      def condition_flags
+        @condition_flags ||= compute_condition_flags
+      end
+
+      def compute_condition_flags
+        conditions = data["conditions"]
+        flags = {}
+        next_index = 0
+        targets = conditions.keys
+        until targets.empty?
+          remaining = []
+          targets.each do |type|
+            sub = conditions[type]["subConditions"]
+            if sub.nil?
+              raise Error, "Too many deinflection conditions (max 32)" if next_index >= 32
+
+              flags[type] = 1 << next_index
+              next_index += 1
+            else
+              resolved = strict_flags(flags, sub) { remaining << type }
+              flags[type] = resolved if resolved
+            end
+          end
+          raise Error, "Cycle in deinflection sub-conditions" if remaining.size == targets.size
+
+          targets = remaining
+        end
+        flags
+      end
+
+      # OR the flags of every named condition. Yields (and returns nil) when one
+      # isn't assigned yet, so condition resolution can defer it to a later pass.
+      def strict_flags(flags, types)
+        result = 0
+        types.each do |type|
+          flag = flags[type]
+          if flag.nil?
+            yield if block_given?
+            return nil
+          end
+          result |= flag
+        end
+        result
+      end
+    end
+  end
+end