daidai 0.1.0

data/lib/daidai/resources/kwpos.csv

@@ -0,0 +1,93 @@
+id	kw	descr	ents
+1	adj-i	adjective (keiyoushi)	
+2	adj-na	adjectival nouns or quasi-adjectives (keiyodoshi)	
+3	adj-no	nouns which may take the genitive case particle 'no'	
+4	adj-pn	pre-noun adjectival (rentaishi)	
+5	adj-t	'taru' adjective	
+6	adv	adverb (fukushi)	
+7	adj-ix	adjective (keiyoushi) - yoi/ii class	
+8	adv-to	adverb taking the 'to' particle	
+9	aux	auxiliary	
+10	aux-adj	auxiliary adjective	
+11	aux-v	auxiliary verb	
+12	conj	conjunction	
+13	exp	expressions (phrases, clauses, etc.)	
+14	int	interjection (kandoushi)	
+15	cop	copula	
+17	n	noun (common) (futsuumeishi)	
+18	n-adv	adverbial noun (fukushitekimeishi)	
+19	n-suf	noun, used as a suffix	
+20	n-pref	noun, used as a prefix	
+21	n-t	noun (temporal) (jisoumeishi)	
+24	num	numeric	
+25	pref	prefix	
+26	prt	particle	
+27	suf	suffix	
+28	v1	Ichidan verb	
+29	v1-s	Ichidan verb - kureru special class	
+30	v5aru	Godan verb - -aru special class	
+31	v5b	Godan verb with 'bu' ending	
+32	v5g	Godan verb with 'gu' ending	
+33	v5k	Godan verb with 'ku' ending	
+34	v5k-s	Godan verb - Iku/Yuku special class	
+35	v5m	Godan verb with 'mu' ending	
+36	v5n	Godan verb with 'nu' ending	
+37	v5r	Godan verb with 'ru' ending	
+38	v5r-i	Godan verb with 'ru' ending (irregular verb)	
+39	v5s	Godan verb with 'su' ending	
+40	v5t	Godan verb with 'tsu' ending	
+41	v5u	Godan verb with 'u' ending	
+42	v5u-s	Godan verb with 'u' ending (special class)	
+43	v5uru	Godan verb - Uru old class verb (old form of Eru)	
+44	vi	intransitive verb	
+45	vk	Kuru verb - special class	
+46	vs	noun or participle which takes the aux. verb suru	
+47	vs-s	suru verb - special class	
+48	vs-i	suru verb - included	
+49	vz	Ichidan verb - zuru verb (alternative form of -jiru verbs)	
+50	vt	transitive verb	
+51	ctr	counter	
+52	vn	irregular nu verb	
+53	v4r	Yodan verb with 'ru' ending (archaic)	
+56	adj-f	noun or verb acting prenominally	
+58	vr	irregular ru verb, plain form ends with -ri	
+59	v2a-s	Nidan verb with 'u' ending (archaic)	
+60	v4h	Yodan verb with 'hu/fu' ending (archaic)	
+61	pn	pronoun	
+62	vs-c	su verb - precursor to the modern suru	
+63	adj-kari	'kari' adjective (archaic)	
+64	adj-ku	'ku' adjective (archaic)	
+65	adj-shiku	'shiku' adjective (archaic)	
+66	adj-nari	archaic/formal form of na-adjective	
+67	n-pr	proper noun	
+68	v-unspec	verb unspecified	
+69	v4k	Yodan verb with 'ku' ending (archaic)	
+70	v4g	Yodan verb with 'gu' ending (archaic)	
+71	v4s	Yodan verb with 'su' ending (archaic)	
+72	v4t	Yodan verb with 'tsu' ending (archaic)	
+73	v4n	Yodan verb with 'nu' ending (archaic)	
+74	v4b	Yodan verb with 'bu' ending (archaic)	
+75	v4m	Yodan verb with 'mu' ending (archaic)	
+76	v2k-k	Nidan verb (upper class) with 'ku' ending (archaic)	
+77	v2g-k	Nidan verb (upper class) with 'gu' ending (archaic)	
+78	v2t-k	Nidan verb (upper class) with 'tsu' ending (archaic)	
+79	v2d-k	Nidan verb (upper class) with 'dzu' ending (archaic)	
+80	v2h-k	Nidan verb (upper class) with 'hu/fu' ending (archaic)	
+81	v2b-k	Nidan verb (upper class) with 'bu' ending (archaic)	
+82	v2m-k	Nidan verb (upper class) with 'mu' ending (archaic)	
+83	v2y-k	Nidan verb (upper class) with 'yu' ending (archaic)	
+84	v2r-k	Nidan verb (upper class) with 'ru' ending (archaic)	
+85	v2k-s	Nidan verb (lower class) with 'ku' ending (archaic)	
+86	v2g-s	Nidan verb (lower class) with 'gu' ending (archaic)	
+87	v2s-s	Nidan verb (lower class) with 'su' ending (archaic)	
+88	v2z-s	Nidan verb (lower class) with 'zu' ending (archaic)	
+89	v2t-s	Nidan verb (lower class) with 'tsu' ending (archaic)	
+90	v2d-s	Nidan verb (lower class) with 'dzu' ending (archaic)	
+91	v2n-s	Nidan verb (lower class) with 'nu' ending (archaic)	
+92	v2h-s	Nidan verb (lower class) with 'hu/fu' ending (archaic)	
+93	v2b-s	Nidan verb (lower class) with 'bu' ending (archaic)	
+94	v2m-s	Nidan verb (lower class) with 'mu' ending (archaic)	
+95	v2y-s	Nidan verb (lower class) with 'yu' ending (archaic)	
+96	v2r-s	Nidan verb (lower class) with 'ru' ending (archaic)	
+97	v2w-s	Nidan verb (lower class) with 'u' ending and 'we' conjugation (archaic)	
+98	unc	unclassified	

data/lib/daidai/tables.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Daidai
+  # Loads and memoizes the JMdictDB conjugation tables vendored under
+  # `resources/`. The files are tab-separated and copied verbatim from jconj
+  # (Stuart McGraw / EDRDG) — see NOTICE. Keep them in sync with upstream via
+  # `rake daidai:sync`.
+  module Tables
+    DIR = File.expand_path("resources", __dir__)
+
+    # One okurigana rule: how to turn a dictionary form into one conjugation.
+    Okurigana = Struct.new(:stem, :okuri, :euphr, :euphk, keyword_init: true)
+
+    class << self
+      # conjugation id (Integer) => human name ("Past (~ta)", …)
+      def conj
+        @conj ||= read("conj.csv").to_h { |r| [ r["id"].to_i, r["name"] ] }
+      end
+
+      # [pos_id, conj_id, negative?, polite?, onum] => Okurigana
+      def conjo
+        @conjo ||= read("conjo.csv").each_with_object({}) do |r, table|
+          key = [ r["pos"].to_i, r["conj"].to_i, r["neg"] == "t", r["fml"] == "t", r["onum"].to_i ]
+          table[key] = Okurigana.new(
+            stem: r["stem"].to_i,
+            okuri: r["okuri"].to_s,
+            euphr: presence(r["euphr"]),
+            euphk: presence(r["euphk"])
+          )
+        end
+      end
+
+      # JMdict POS keyword ("v5k", "adj-i", …) => conjo pos id (Integer)
+      def pos_ids
+        @pos_ids ||= read("kwpos.csv").to_h { |r| [ r["kw"], r["id"].to_i ] }
+      end
+
+      def reload!
+        @conj = @conjo = @pos_ids = nil
+      end
+
+      private
+
+      def read(file, headers: true)
+        CSV.read(File.join(DIR, file), col_sep: "\t", headers: headers, quote_char: '"')
+      end
+
+      def presence(value)
+        value.nil? || value.empty? ? nil : value
+      end
+    end
+  end
+end

data/lib/daidai/version.rb

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

data/lib/daidai/word.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Daidai
+  # The conjugation forms daidai generates, in table order, with display labels.
+  # These names replace the numeric conjugation ids of the underlying tables.
+  FORMS = {
+    non_past: "Non-past",
+    past: "Past",
+    te: "Te-form",
+    provisional: "Provisional (~eba)",
+    potential: "Potential",
+    passive: "Passive",
+    causative: "Causative",
+    causative_passive: "Causative-passive",
+    volitional: "Volitional",
+    imperative: "Imperative",
+    conditional: "Conditional (~tara)",
+    alternative: "Alternative (~tari)",
+    stem: "Continuative (~i)"
+  }.freeze
+
+  # conjo.csv conjugation id (1..13) => form name, in the same order as FORMS.
+  FORM_BY_ID = FORMS.keys.each_with_index.to_h { |name, i| [ i + 1, name ] }.freeze
+
+  # A single conjugated form. `kanji` and `reading` hold the inflected surface
+  # and its kana; either may be nil (a kana-only word has no `kanji`, and the
+  # `reading` is only filled in when one was supplied). `onum` distinguishes
+  # equally-valid variants of the same form (e.g. ～なくて vs ～ないで).
+  Form = Struct.new(:name, :negative, :polite, :onum, :kanji, :reading, keyword_init: true) do
+    def negative? = negative
+    def polite?   = polite
+
+    # The primary (most standard) variant for its form/polarity/formality; see
+    # Word#variants for the alternatives (e.g. ～なくて beside ～ないで).
+    def primary? = onum == 1
+
+    # Human label for this form ("Past", "Te-form", …).
+    def label = FORMS[name]
+
+    # The text to show: the kanji writing if there is one, otherwise the kana.
+    def to_s = (kanji || reading).to_s
+    alias_method :text, :to_s
+
+    def inspect = "#<Daidai::Form #{name}#{" negative" if negative}#{" polite" if polite}: #{self}>"
+  end
+
+  # A conjugated word — the full paradigm for one dictionary-form input.
+  #
+  # Forms are reached by name, with optional negative:/polite: modifiers:
+  #
+  #   word.past                      #=> Form  (plain affirmative)
+  #   word.past(polite: true)        #=> Form
+  #   word.non_past(negative: true)  #=> Form
+  #
+  # …or through fluent views that read like grammar (and chain):
+  #
+  #   word.polite.past
+  #   word.negative.non_past
+  #   word.polite.negative.te
+  #
+  # `word[:past, polite: true]` does the same dynamically, and a Word is
+  # Enumerable over all of its forms.
+  class Word
+    include Enumerable
+
+    attr_reader :word, :pos, :kind, :forms
+
+    def initialize(word:, pos:, kind:, forms:)
+      @word  = word
+      @pos   = pos
+      @kind  = kind
+      @forms = forms
+      @index = forms.group_by { |f| [ f.name, f.negative, f.polite ] }
+    end
+
+    # The primary Form for `name` in the given polarity/formality, or nil.
+    def [](name, negative: false, polite: false)
+      @index[[ name, negative, polite ]]&.min_by(&:onum)
+    end
+    alias form []
+
+    # Every accepted variant (all onums) for a form, primary first.
+    def variants(name, negative: false, polite: false)
+      (@index[[ name, negative, polite ]] || []).sort_by(&:onum)
+    end
+
+    def each(&) = @forms.each(&)
+
+    # The form names present for this word, in table order.
+    def conjugations
+      present = @forms.map(&:name).uniq
+      FORMS.keys.select { |name| present.include?(name) }
+    end
+
+    # Fluent views — a lens with polarity/formality pre-applied.
+    def polite      = View.new(self, negative: false, polite: true)
+    def plain       = View.new(self, negative: false, polite: false)
+    def negative    = View.new(self, negative: true, polite: false)
+    def affirmative = View.new(self, negative: false, polite: false)
+
+    FORMS.each_key do |name|
+      define_method(name) do |negative: false, polite: false|
+        self[name, negative: negative, polite: polite]
+      end
+    end
+
+    alias dictionary non_past
+    alias te_form te
+
+    def inspect = "#<Daidai::Word #{word} (#{pos}, #{kind}): #{@forms.size} forms>"
+  end
+
+  # A polarity/formality lens over a Word, returned by Word#polite etc. Calling
+  # a form name on it applies the accumulated modifiers; modifiers chain.
+  class View
+    def initialize(word, negative:, polite:)
+      @word     = word
+      @negative = negative
+      @polite   = polite
+    end
+
+    def polite      = View.new(@word, negative: @negative, polite: true)
+    def plain       = View.new(@word, negative: @negative, polite: false)
+    def negative    = View.new(@word, negative: true, polite: @polite)
+    def affirmative = View.new(@word, negative: false, polite: @polite)
+
+    FORMS.each_key do |name|
+      define_method(name) { @word[name, negative: @negative, polite: @polite] }
+    end
+
+    alias dictionary non_past
+    alias te_form te
+  end
+end

data/lib/daidai.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "daidai/version"
+require_relative "daidai/conjugator"
+require_relative "daidai/kabosu"
+require_relative "daidai/deinflector"
+
+# Daidai (橙) — Japanese verb and adjective conjugation in pure Ruby.
+#
+# The conjugation knowledge comes from the JMdictDB tables developed by Jim
+# Breen's EDRDG project (via jconj); Daidai ports the table-driven algorithm and
+# exposes a small, app-friendly API. Named after the bitter orange, a sibling of
+# sudachi and kabosu.
+#
+#   Daidai.conjugate(kanji: "書く", reading: "かく", pos: "v5k")
+#   #=> Daidai::Result
+#
+#   Daidai.conjugatable?("n")   #=> false
+#   Daidai.conjugatable?("v1")  #=> true
+module Daidai
+  class << self
+    # Conjugate a dictionary-form word.
+    #
+    #   Daidai.conjugate("書く", "v5k")                 # kanji surface forms
+    #   Daidai.conjugate("書く", "v5k", reading: "かく")  # + the kana of each form
+    #   Daidai.conjugate("する", "vs-i")                # kana word (is its own reading)
+    #
+    # `word` is the dictionary form (kanji surface or kana). `pos` is a JMdict
+    # part-of-speech code ("v5k", "adj-i", …) or an array of them — the first
+    # conjugatable one wins. `reading` is optional: pass it only when you also
+    # want each form's kana (conjugation rewrites the okurigana, which is already
+    # in the surface, so the kanji forms need no reading). Returns a Daidai::Word,
+    # or nil when nothing is conjugatable.
+    #
+    # `pos` may be omitted, in which case the optional `kabosu` gem (Sudachi)
+    # resolves the dictionary form, POS and reading from `word` — even when `word`
+    # is itself inflected ("食べている" → conjugations of 食べる). This raises
+    # Daidai::Kabosu::MissingDependency if kabosu/a dictionary isn't installed.
+    def conjugate(word, pos = nil, reading: nil)
+      return nil if word.nil? || word.to_s.empty?
+
+      if pos.nil?
+        resolved = Kabosu.resolve(word) or return nil
+        word, pos, reading = resolved.values_at(:word, :pos, :reading)
+      end
+
+      kanji = word.match?(/\p{Han}/) ? word : nil
+      reading ||= kanji ? nil : word
+      Conjugator.conjugate(kanji: kanji, reading: reading, pos: pos)
+    end
+
+    # Whether `pos` (a code or array of codes) describes a conjugatable word.
+    def conjugatable?(pos)
+      Conjugator.conjugatable?(pos)
+    end
+
+    # Deinflect an inflected surface form back to its dictionary form(s), naming
+    # each inflection along the way (the inverse of #conjugate):
+    #
+    #   # each result has a `term` and its named `inflections` (surface -> dictionary):
+    #   Daidai.deinflect("食べてる")    # includes #<Daidai::Deinflection 食べる [-いる, -て]>
+    #   Daidai.deinflect("読まなかった") # includes #<Daidai::Deinflection 読む [-た, negative]>
+    #
+    # Returns every candidate the rules can reach (each a Daidai::Deinflection);
+    # the rules are string-based and dictionary-free, so many candidates are not
+    # real words. A caller with a dictionary looks up each `term`; one without can
+    # keep only `dictionary_form?` candidates. Pure and offline — unlike the
+    # POS-less #conjugate, it needs no kabosu.
+    def deinflect(text)
+      return [] if text.nil? || text.to_s.empty?
+
+      Deinflector.deinflect(text)
+    end
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: daidai
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- davafons
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: csv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Daidai is a table-driven, pure-Ruby port of jconj's conjugation algorithm,
+  built on the JMdictDB conjugation tables. It conjugates Japanese verbs and adjectives
+  from a dictionary-form word and its JMdict part-of-speech code, with no native extension
+  and nothing to download at runtime.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- NOTICE
+- README.md
+- lib/daidai.rb
+- lib/daidai/conjugator.rb
+- lib/daidai/deinflector.rb
+- lib/daidai/kabosu.rb
+- lib/daidai/resources/conj.csv
+- lib/daidai/resources/conjo.csv
+- lib/daidai/resources/conotes.csv
+- lib/daidai/resources/japanese-transforms.json
+- lib/daidai/resources/kwpos.csv
+- lib/daidai/tables.rb
+- lib/daidai/version.rb
+- lib/daidai/word.rb
+homepage: https://github.com/davafons/daidai
+licenses:
+- GPL-3.0-only
+metadata:
+  source_code_uri: https://github.com/davafons/daidai
+  bug_tracker_uri: https://github.com/davafons/daidai/issues
+  changelog_uri: https://github.com/davafons/daidai/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Pure-Ruby Japanese verb and adjective conjugation
+test_files: []