daidai 0.2.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71d9328e95b0ca6e9597020c5c60128f5a699a5bb68c1bb9e24881bf2ebd1276
-  data.tar.gz: 7e34ce14c5054479b186423bb1623dd519af4f05888a8fd63e5c1d3f12965e75
+  metadata.gz: 38b5d131989c0801d446ed50e9ab3399fef4813bb017a62304a0fed9629922a1
+  data.tar.gz: c5eafa61481b4291fc945ce43354a221c6093a9dd44a68d2535e6a2d6b2c8ba0
 SHA512:
-  metadata.gz: 2a8d2ac93b3bfe2f44ba0c8e38c3a070703b76a1e197d001b7646cb0b439dd12e0fb440f208f33ab9326b438667c3c103ecd5a350a8b7820f0369f0341e88ba6
-  data.tar.gz: bb4b1505f2646ea62d4fbcf7749f149ca0ac3d378c34fa7950194d20ac0759a13aec3840ec9aff5b37695b9c12b4951375cbc5d828de23906cd51093bb8402a2
+  metadata.gz: f307a1904436405e4a06298a583fe7638b8578d57d68a7e4535457437417f8713b7c1ea71b4d54e5a6c0806c801f86719e494a42ba84dc71871db4857b29bf04
+  data.tar.gz: 45cc7171d85e261559e9074945274bd6d9e16ac3a435f6a5a0ea4b77b5248c2272545547b4ebce19d05974528a6cd67f6c7b7f09ec94a9864aa5a5eef5c2786d

data/CHANGELOG.md

@@ -6,6 +6,28 @@ follow [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-09-07
+
+### Added
+
+- Deinflection candidates expose `word_classes` and `matches_pos?` for JMdict
+  part-of-speech validation. An ichidan candidate such as かかる from かかなかった
+  can now be rejected when the dictionary entry is godan.
+- Suru-noun bases such as 勉強 from 勉強しました, nominal predicates such as
+  静か from 静かだった, and standalone copula forms.
+- Forward conjugation of だ with the JMdict `cop` tag.
+- Automatic copula resolution for だ, です, だった, and でした.
+
+### Fixed
+
+- Automatic POS resolution preserves the irregular classes of 問う, いい,
+  くださる, なさる, and いらっしゃる. Automatic past forms now include 問うた
+  and よかった rather than 問った and いかった.
+- Polite representative forms such as しましたり now deinflect to する.
+- Negative polite imperatives such as 死になさるな now deinflect to their base.
+- Irregular subclasses validate their final transformation against the forward
+  paradigm, so 行いた cannot match 行く tagged `v5k-s`.
+
 ## [0.2.5] - 2026-08-03
 
 ### Removed

data/README.md

@@ -190,7 +190,10 @@ d = Daidai.deinflect("食べてる").find { |x| x.term == "食べる" }
 d.term              # => "食べる"             (the candidate dictionary form)
 d.inflections       # => ["-いる", "-て"]      (rule names, surface to dictionary)
 d.labels            # => ["progressive", "te-form"]   (friendly English names)
-d.dictionary_form?  # => true                (chain lands on a known dictionary form)
+d.dictionary_form?  # => true                (chain reaches a dictionary-form class)
+d.word_classes      # => ["v1"]
+d.matches_pos?(["v1", "vt"])  # => true
+d.base_surface      # => "食べて"           (surface before the final rule)
 d.to_s              # => "食べる [-いる, -て]"
 ```
 
@@ -202,11 +205,20 @@ labels downstream if your app is multilingual.
 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.
+the candidates whose `term` is a real entry and whose `matches_pos?` accepts that
+entry's JMdict part-of-speech codes. `dictionary_form?` checks the grammatical
+shape, not whether the word exists. For example, かかなかった produces かかる as
+an ichidan candidate; it must not match a godan かかる entry.
+
+Suru nouns and nominal predicates are dictionary candidates too: 勉強しました
+can reach 勉強 with class `vs-noun`, and 静かだった can reach 静か with classes
+`adj-na` and `n`. `matches_pos?` maps these to JMdict tags. For irregular
+subclasses it also checks supported final transformations against the forward
+paradigm. The check retains the intermediate `base_surface`, so a valid
+contraction around an irregular verb is not mistaken for a regularized form.
 
 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
+each candidate `term`, validate its part of speech, and you have the lemma 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.)

data/lib/daidai/conjugator.rb

@@ -81,7 +81,9 @@ module Daidai
       def inflect(strat, text, row)
         return nil if text.nil? || text.empty?
 
-        if strat[:suffix]
+        if strat[:copula]
+          row.okuri.to_s
+        elsif strat[:suffix]
           # Copula forms are whole suffixes appended to the citation form
           # (静か → 静かだ / 静かではない); no stem stripping or euphony.
           text + row.okuri.to_s
@@ -113,6 +115,8 @@ module Daidai
           { pos_id: Tables.pos_ids.fetch(code), kind: kind }
         elsif code == "adj-na"
           { pos_id: COPULA_POS, kind: :na_adjective, suffix: true }
+        elsif code == "cop"
+          { pos_id: COPULA_POS, kind: :copula, copula: true }
         elsif code == "vs"
           { pos_id: SURU_POS, kind: :suru, append: "する" }
         end

data/lib/daidai/deinflector.rb

@@ -6,14 +6,39 @@ 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.
+  # on a dictionary-form grammatical class. This does not establish that the
+  # term exists; callers must check the spelling and part of speech in a dictionary.
   #
   #   Daidai.deinflect("食べてる")   # candidate base forms, each with named inflections;
   #                                  # one is #<Daidai::Deinflection 食べる [-いる, -て]>
-  Deinflection = Struct.new(:term, :inflections, :dictionary_form, keyword_init: true) do
+  Deinflection = Struct.new(:term, :inflections, :dictionary_form, :word_classes, :base_surface, keyword_init: true) do
     def dictionary_form? = dictionary_form
 
+    def matches_pos?(pos_codes)
+      Array(pos_codes).any? do |code|
+        next true if code.to_s == "vs" && Array(word_classes).include?("vs-noun")
+
+        word_class = case code.to_s
+                     when /\Av1(?:-|\z)/ then "v1"
+                     when /\Av5/ then "v5"
+                     when /\Avs(?:-|\z)/ then "vs"
+                     when "adj-ix" then "adj-i"
+                     when "cop" then "copula"
+                     else code.to_s
+                     end
+        Array(word_classes).include?(word_class) && compatible_irregular_form?(code.to_s)
+      end
+    end
+
+    def compatible_irregular_form?(code)
+      return true unless base_surface && Deinflector::IRREGULAR_POS.include?(code) &&
+                         Deinflector::GENERATED_RULES.include?(inflections.last)
+
+      word = Daidai.conjugate(term, code)
+      word&.any? { |form| form.text == base_surface }
+    end
+    private :compatible_irregular_form?
+
     # The inflections as friendly English labels for display (e.g. "-いる" =>
     # "progressive", "-て" => "te-form"), via Deinflector.label. Localise these
     # downstream (i18n) if your app is multilingual.
@@ -38,6 +63,8 @@ module Daidai
   # offline, string-rule deinflection.
   module Deinflector
     DATA_FILE = File.expand_path("resources/japanese-transforms.json", __dir__)
+    IRREGULAR_POS = %w[v5k-s v5u-s v5r-i v5aru v1-s adj-ix vs-s].freeze
+    GENERATED_RULES = %w[-た -て -ます negative -ば -たら -たり potential passive causative volitional imperative].freeze
 
     # Friendly English labels for the deinflection rule names #deinflect emits.
     # The underlying names (ported from Yomitan) are terse and sometimes symbolic
@@ -47,6 +74,7 @@ module Daidai
     # these rather than maintain their own map. Keyed by the rule name; see
     # Deinflector.label for the lookup (which falls back to the name itself).
     LABELS = {
+      "suru" => "suru verb", "copula" => "copula", "-なら" => "conditional (-nara)",
       "-いる" => "progressive", "-て" => "te-form", "-た" => "past",
       "-ます" => "polite", "negative" => "negative", "passive" => "passive",
       "potential" => "potential", "potential or passive" => "potential / passive",
@@ -108,9 +136,9 @@ module Daidai
       # `term`; callers without one can keep only `dictionary_form?` candidates.
       def deinflect(text)
         transform(text)
-          .reject { |t| t.trace.empty? }
+          .reject { |t| t.trace.empty? || t.text.empty? }
           .map { |t| to_deinflection(t) }
-          .uniq { |d| [ d.term, d.inflections ] }
+          .uniq { |d| [ d.term, d.inflections, d.word_classes, d.base_surface ] }
       end
 
       # Friendly English label for a deinflection rule name (the strings in a
@@ -159,7 +187,11 @@ module Daidai
           # 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 },
-          dictionary_form: transformed.conditions.anybits?(dictionary_mask)
+          dictionary_form: transformed.conditions.anybits?(dictionary_mask),
+          base_surface: transformed.trace.first&.fetch(:text),
+          word_classes: data["conditions"].filter_map do |name, condition|
+            name if condition["isDictionaryForm"] && transformed.conditions.anybits?(condition_flags.fetch(name))
+          end.freeze
         )
       end
 

data/lib/daidai/kabosu.rb

@@ -38,7 +38,10 @@ module Daidai
     # can't distinguish (irregular okurigana inside an otherwise-regular row).
     LEMMA_POS = {
       "行く" => "v5k-s", "逝く" => "v5k-s", "往く" => "v5k-s",
-      "有る" => "v5r-i", "在る" => "v5r-i", "ある" => "v5r-i"
+      "有る" => "v5r-i", "在る" => "v5r-i", "ある" => "v5r-i",
+      "問う" => "v5u-s",
+      "くださる" => "v5aru", "なさる" => "v5aru", "いらっしゃる" => "v5aru",
+      "いい" => "adj-ix"
     }.freeze
 
     class << self
@@ -85,11 +88,12 @@ module Daidai
           CONJUGATION_TYPE[pos[4]] || (pos[4].to_s.start_with?("上一段", "下一段") ? "v1" : nil)
         when "形容詞" then "adj-i"
         when "形状詞" then "adj-na"
+        when "助動詞" then "cop" if %w[助動詞-ダ 助動詞-デス].include?(pos[4])
         end
       end
 
       def inflecting?(pos)
-        %w[動詞 形容詞 形状詞].include?(pos[0])
+        !from_conjugation_type(pos).nil?
       end
 
       def suru?(pos) = pos[4] == "サ行変格"

data/lib/daidai/resources/japanese-transforms.json

@@ -1,5 +1,25 @@
 {
   "conditions": {
+    "vs-noun": {
+      "name": "Suru verbal noun",
+      "isDictionaryForm": true,
+      "subConditions": null
+    },
+    "adj-na": {
+      "name": "Na adjective",
+      "isDictionaryForm": true,
+      "subConditions": null
+    },
+    "n": {
+      "name": "Noun",
+      "isDictionaryForm": true,
+      "subConditions": null
+    },
+    "copula": {
+      "name": "Copula attached to a nominal predicate",
+      "isDictionaryForm": true,
+      "subConditions": null
+    },
     "v": {
       "name": "Verb",
       "isDictionaryForm": false,
@@ -127,6 +147,71 @@
     }
   },
   "transforms": {
+    "-なら": {
+      "name": "-なら",
+      "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": ["copula"],
+          "inflected": "なら",
+          "deinflected": "だ"
+        }
+      ]
+    },
+    "suru": {
+      "name": "suru",
+      "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": [
+            "copula"
+          ],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "です",
+          "deinflected": "だ"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "だった",
+          "deinflected": "だ"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "でした",
+          "deinflected": "です"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": ["vs"],
+          "conditionsOut": ["vs-noun"],
+          "inflected": "する",
+          "deinflected": ""
+        }
+      ]
+    },
+    "copula": {
+      "name": "copula",
+      "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": ["copula"],
+          "conditionsOut": ["adj-na", "n"],
+          "inflected": "だ",
+          "deinflected": ""
+        }
+      ]
+    },
     "-ば": {
       "name": "-ば",
       "description": "1. Conditional form; shows that the previous stated condition's establishment is the condition for the latter stated condition to occur.\n2. Shows a trigger for a latter stated perception or judgment.\nUsage: Attach ば to the hypothetical form (仮定形) of verbs and i-adjectives.",
@@ -1905,6 +1990,20 @@
       "name": "-たら",
       "description": "1. Denotes the latter stated event is a continuation of the previous stated event.\n2. Assumes that a matter has been completed or concluded.\nUsage: Attach たら to the continuative form (連用形) of verbs after euphonic change form, かったら to the stem of i-adjectives.",
       "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": ["copula"],
+          "inflected": "だったら",
+          "deinflected": "だ"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": ["copula"],
+          "inflected": "でしたら",
+          "deinflected": "です"
+        },
         {
           "type": "suffix",
           "conditionsIn": [],
@@ -2244,6 +2343,13 @@
       "name": "-たり",
       "description": "1. Shows two actions occurring back and forth (when used with two verbs).\n2. Shows examples of actions and states (when used with multiple verbs and adjectives).\nUsage: Attach たり to the continuative form (連用形) of verbs after euphonic change form, かったり to the stem of i-adjectives",
       "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": ["-ます"],
+          "inflected": "ましたり",
+          "deinflected": "ます"
+        },
         {
           "type": "suffix",
           "conditionsIn": [],
@@ -5213,6 +5319,61 @@
       "name": "negative",
       "description": "1. Negative form of verbs.\n2. Expresses a feeling of solicitation to the other party.\nUsage: Attach ない to the irrealis form (未然形) of verbs, くない to the stem of i-adjectives. ない itself conjugates as i-adjective. ます becomes ません.",
       "rules": [
+        {
+          "type": "suffix",
+          "conditionsIn": [
+            "adj-i",
+            "copula"
+          ],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "ではない",
+          "deinflected": "だ"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [
+            "adj-i",
+            "copula"
+          ],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "じゃない",
+          "deinflected": "だ"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [
+            "copula",
+            "-ません"
+          ],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "ではありません",
+          "deinflected": "です"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [
+            "copula",
+            "-ません"
+          ],
+          "conditionsOut": [
+            "copula"
+          ],
+          "inflected": "じゃありません",
+          "deinflected": "です"
+        },
+        {
+          "type": "suffix",
+          "conditionsIn": [],
+          "conditionsOut": ["-なさい"],
+          "inflected": "なさるな",
+          "deinflected": "なさい"
+        },
         {
           "type": "suffix",
           "conditionsIn": [

data/lib/daidai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Daidai
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daidai
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
 platform: ruby
 authors:
 - davafons
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-03 00:00:00.000000000 Z
+date: 2026-09-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: csv