lindera 6.0.0 → 6.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/src/schema.rs ADDED
@@ -0,0 +1,568 @@
1
+ //! Dictionary schema definitions.
2
+ //!
3
+ //! This module provides schema structures that define the format and fields
4
+ //! of dictionary entries. The field-management logic is delegated to
5
+ //! [`lindera_binding_core::CoreSchema`]; this module only adds the magnus wrappers.
6
+
7
+ use magnus::prelude::*;
8
+ use magnus::{Error, RArray, Ruby, function, method};
9
+
10
+ use lindera::dictionary::{FieldDefinition, FieldType, Schema};
11
+ use lindera_binding_core::{CoreFieldDefinition, CoreFieldType, CoreSchema};
12
+
13
+ /// Field type in dictionary schema.
14
+ ///
15
+ /// Defines the type of a field in the dictionary entry.
16
+ #[magnus::wrap(class = "Lindera::FieldType", free_immediately, size)]
17
+ #[derive(Debug, Clone)]
18
+ pub struct RbFieldType {
19
+ /// Internal field type variant.
20
+ inner: RbFieldTypeKind,
21
+ }
22
+
23
+ /// Internal enum for field type kind.
24
+ #[derive(Debug, Clone)]
25
+ enum RbFieldTypeKind {
26
+ /// Surface form (word text).
27
+ Surface,
28
+ /// Left context ID for morphological analysis.
29
+ LeftContextId,
30
+ /// Right context ID for morphological analysis.
31
+ RightContextId,
32
+ /// Word cost (used in path selection).
33
+ Cost,
34
+ /// Custom field (morphological features).
35
+ Custom,
36
+ }
37
+
38
+ impl RbFieldType {
39
+ /// Returns the string representation of the field type.
40
+ fn to_s(&self) -> &str {
41
+ match self.inner {
42
+ RbFieldTypeKind::Surface => "surface",
43
+ RbFieldTypeKind::LeftContextId => "left_context_id",
44
+ RbFieldTypeKind::RightContextId => "right_context_id",
45
+ RbFieldTypeKind::Cost => "cost",
46
+ RbFieldTypeKind::Custom => "custom",
47
+ }
48
+ }
49
+
50
+ /// Returns the inspect representation of the field type.
51
+ fn inspect(&self) -> String {
52
+ format!("#<Lindera::FieldType: {}>", self.to_s())
53
+ }
54
+ }
55
+
56
+ impl From<CoreFieldType> for RbFieldType {
57
+ fn from(field_type: CoreFieldType) -> Self {
58
+ let inner = match field_type {
59
+ CoreFieldType::Surface => RbFieldTypeKind::Surface,
60
+ CoreFieldType::LeftContextId => RbFieldTypeKind::LeftContextId,
61
+ CoreFieldType::RightContextId => RbFieldTypeKind::RightContextId,
62
+ CoreFieldType::Cost => RbFieldTypeKind::Cost,
63
+ CoreFieldType::Custom => RbFieldTypeKind::Custom,
64
+ };
65
+ RbFieldType { inner }
66
+ }
67
+ }
68
+
69
+ impl From<RbFieldType> for CoreFieldType {
70
+ fn from(field_type: RbFieldType) -> Self {
71
+ match field_type.inner {
72
+ RbFieldTypeKind::Surface => CoreFieldType::Surface,
73
+ RbFieldTypeKind::LeftContextId => CoreFieldType::LeftContextId,
74
+ RbFieldTypeKind::RightContextId => CoreFieldType::RightContextId,
75
+ RbFieldTypeKind::Cost => CoreFieldType::Cost,
76
+ RbFieldTypeKind::Custom => CoreFieldType::Custom,
77
+ }
78
+ }
79
+ }
80
+
81
+ impl From<FieldType> for RbFieldType {
82
+ fn from(field_type: FieldType) -> Self {
83
+ RbFieldType::from(CoreFieldType::from(field_type))
84
+ }
85
+ }
86
+
87
+ impl From<RbFieldType> for FieldType {
88
+ fn from(field_type: RbFieldType) -> Self {
89
+ FieldType::from(CoreFieldType::from(field_type))
90
+ }
91
+ }
92
+
93
+ /// Field definition in dictionary schema.
94
+ ///
95
+ /// Describes a single field in the dictionary entry format.
96
+ #[magnus::wrap(class = "Lindera::FieldDefinition", free_immediately, size)]
97
+ #[derive(Debug, Clone)]
98
+ pub struct RbFieldDefinition {
99
+ /// Field index in the schema.
100
+ pub index: usize,
101
+ /// Field name.
102
+ pub name: String,
103
+ /// Field type.
104
+ pub field_type: RbFieldType,
105
+ /// Optional description.
106
+ pub description: Option<String>,
107
+ }
108
+
109
+ impl RbFieldDefinition {
110
+ /// Returns the index of the field.
111
+ fn index(&self) -> usize {
112
+ self.index
113
+ }
114
+
115
+ /// Returns the name of the field.
116
+ fn name(&self) -> String {
117
+ self.name.clone()
118
+ }
119
+
120
+ /// Returns the field type.
121
+ fn field_type(&self) -> RbFieldType {
122
+ self.field_type.clone()
123
+ }
124
+
125
+ /// Returns the description of the field.
126
+ fn description(&self) -> Option<String> {
127
+ self.description.clone()
128
+ }
129
+
130
+ /// Returns the string representation of the field definition.
131
+ fn to_s(&self) -> String {
132
+ format!("FieldDefinition(index={}, name={})", self.index, self.name)
133
+ }
134
+
135
+ /// Returns the inspect representation of the field definition.
136
+ fn inspect(&self) -> String {
137
+ format!(
138
+ "#<Lindera::FieldDefinition: index={}, name='{}', field_type={:?}, description={:?}>",
139
+ self.index, self.name, self.field_type.inner, self.description
140
+ )
141
+ }
142
+ }
143
+
144
+ impl From<CoreFieldDefinition> for RbFieldDefinition {
145
+ fn from(field_def: CoreFieldDefinition) -> Self {
146
+ RbFieldDefinition {
147
+ index: field_def.index,
148
+ name: field_def.name,
149
+ field_type: field_def.field_type.into(),
150
+ description: field_def.description,
151
+ }
152
+ }
153
+ }
154
+
155
+ impl From<RbFieldDefinition> for CoreFieldDefinition {
156
+ fn from(field_def: RbFieldDefinition) -> Self {
157
+ CoreFieldDefinition {
158
+ index: field_def.index,
159
+ name: field_def.name,
160
+ field_type: field_def.field_type.into(),
161
+ description: field_def.description,
162
+ }
163
+ }
164
+ }
165
+
166
+ impl From<FieldDefinition> for RbFieldDefinition {
167
+ fn from(field_def: FieldDefinition) -> Self {
168
+ RbFieldDefinition::from(CoreFieldDefinition::from(field_def))
169
+ }
170
+ }
171
+
172
+ impl From<RbFieldDefinition> for FieldDefinition {
173
+ fn from(field_def: RbFieldDefinition) -> Self {
174
+ FieldDefinition::from(CoreFieldDefinition::from(field_def))
175
+ }
176
+ }
177
+
178
+ /// Dictionary schema definition.
179
+ ///
180
+ /// A thin magnus wrapper over [`lindera_binding_core::CoreSchema`], which owns
181
+ /// the field storage, the name-to-index map, and the field lookups.
182
+ #[magnus::wrap(class = "Lindera::Schema", free_immediately, size)]
183
+ #[derive(Debug, Clone)]
184
+ pub struct RbSchema {
185
+ /// The backing binding-core schema.
186
+ inner: CoreSchema,
187
+ }
188
+
189
+ impl RbSchema {
190
+ /// Creates a new `RbSchema` from a list of field names.
191
+ ///
192
+ /// # Arguments
193
+ ///
194
+ /// * `fields` - List of field names.
195
+ ///
196
+ /// # Returns
197
+ ///
198
+ /// A new `RbSchema` instance.
199
+ fn new(fields: Vec<String>) -> Self {
200
+ Self {
201
+ inner: CoreSchema::new(fields),
202
+ }
203
+ }
204
+
205
+ /// Creates a default schema for IPADIC-style dictionaries.
206
+ ///
207
+ /// # Returns
208
+ ///
209
+ /// A new `RbSchema` with default IPADIC fields.
210
+ fn create_default() -> Self {
211
+ Self {
212
+ inner: CoreSchema::create_default(),
213
+ }
214
+ }
215
+
216
+ /// Returns the list of field names as a Ruby array.
217
+ fn fields(&self) -> Vec<String> {
218
+ self.inner.fields().to_vec()
219
+ }
220
+
221
+ /// Returns the index of the specified field name.
222
+ ///
223
+ /// # Arguments
224
+ ///
225
+ /// * `field_name` - Name of the field.
226
+ ///
227
+ /// # Returns
228
+ ///
229
+ /// The index of the field, or None if not found.
230
+ fn get_field_index(&self, field_name: String) -> Option<usize> {
231
+ self.inner.get_field_index(&field_name)
232
+ }
233
+
234
+ /// Returns the number of fields in the schema.
235
+ ///
236
+ /// # Returns
237
+ ///
238
+ /// The number of fields.
239
+ fn field_count(&self) -> usize {
240
+ self.inner.field_count()
241
+ }
242
+
243
+ /// Returns the name of the field at the specified index.
244
+ ///
245
+ /// # Arguments
246
+ ///
247
+ /// * `index` - Index of the field.
248
+ ///
249
+ /// # Returns
250
+ ///
251
+ /// The field name, or None if the index is out of bounds.
252
+ fn get_field_name(&self, index: usize) -> Option<String> {
253
+ self.inner.get_field_name(index).map(str::to_string)
254
+ }
255
+
256
+ /// Returns the custom fields (fields after the first 4 standard fields).
257
+ ///
258
+ /// # Returns
259
+ ///
260
+ /// A list of custom field names.
261
+ fn get_custom_fields(&self) -> Vec<String> {
262
+ self.inner.get_custom_fields().to_vec()
263
+ }
264
+
265
+ /// Returns all field names.
266
+ ///
267
+ /// # Returns
268
+ ///
269
+ /// A list of all field names.
270
+ fn get_all_fields(&self) -> Vec<String> {
271
+ self.inner.fields().to_vec()
272
+ }
273
+
274
+ /// Returns the field definition for the specified field name.
275
+ ///
276
+ /// # Arguments
277
+ ///
278
+ /// * `name` - Name of the field.
279
+ ///
280
+ /// # Returns
281
+ ///
282
+ /// The field definition, or None if not found.
283
+ fn get_field_by_name(&self, name: String) -> Option<RbFieldDefinition> {
284
+ self.inner
285
+ .get_field_by_name(&name)
286
+ .map(RbFieldDefinition::from)
287
+ }
288
+
289
+ /// Validates a CSV record against the schema.
290
+ ///
291
+ /// # Arguments
292
+ ///
293
+ /// * `record` - List of field values.
294
+ ///
295
+ /// # Returns
296
+ ///
297
+ /// `Ok(())` if valid, or an error if the record is invalid.
298
+ fn validate_record(&self, record: RArray) -> Result<(), Error> {
299
+ let ruby = Ruby::get().expect("Ruby runtime not initialized");
300
+ let values: Vec<String> = record.to_vec()?;
301
+
302
+ self.inner
303
+ .validate_record(&values)
304
+ .map_err(|err| Error::new(ruby.exception_arg_error(), err.to_string()))
305
+ }
306
+
307
+ /// Returns the string representation of the schema.
308
+ fn to_s(&self) -> String {
309
+ format!("Schema(fields={})", self.inner.field_count())
310
+ }
311
+
312
+ /// Returns the inspect representation of the schema.
313
+ fn inspect(&self) -> String {
314
+ format!("#<Lindera::Schema: fields={:?}>", self.inner.fields())
315
+ }
316
+ }
317
+
318
+ impl RbSchema {
319
+ /// Internal constructor for use from other modules (not exposed to Ruby).
320
+ pub fn new_internal(fields: Vec<String>) -> Self {
321
+ Self::new(fields)
322
+ }
323
+
324
+ /// Internal default constructor for use from other modules (not exposed to Ruby).
325
+ pub fn create_default_internal() -> Self {
326
+ Self::create_default()
327
+ }
328
+ }
329
+
330
+ impl From<CoreSchema> for RbSchema {
331
+ fn from(schema: CoreSchema) -> Self {
332
+ RbSchema { inner: schema }
333
+ }
334
+ }
335
+
336
+ impl From<RbSchema> for CoreSchema {
337
+ fn from(schema: RbSchema) -> Self {
338
+ schema.inner
339
+ }
340
+ }
341
+
342
+ impl From<RbSchema> for Schema {
343
+ fn from(schema: RbSchema) -> Self {
344
+ schema.inner.into()
345
+ }
346
+ }
347
+
348
+ impl From<Schema> for RbSchema {
349
+ fn from(schema: Schema) -> Self {
350
+ RbSchema {
351
+ inner: CoreSchema::from(schema),
352
+ }
353
+ }
354
+ }
355
+
356
+ /// Defines Schema, FieldDefinition, and FieldType classes in the given Ruby module.
357
+ ///
358
+ /// # Arguments
359
+ ///
360
+ /// * `ruby` - Ruby runtime handle.
361
+ /// * `module` - Parent Ruby module.
362
+ ///
363
+ /// # Returns
364
+ ///
365
+ /// `Ok(())` on success, or a Magnus `Error` on failure.
366
+ pub fn define(ruby: &Ruby, module: &magnus::RModule) -> Result<(), Error> {
367
+ let field_type_class = module.define_class("FieldType", ruby.class_object())?;
368
+ field_type_class.define_method("to_s", method!(RbFieldType::to_s, 0))?;
369
+ field_type_class.define_method("inspect", method!(RbFieldType::inspect, 0))?;
370
+
371
+ let field_def_class = module.define_class("FieldDefinition", ruby.class_object())?;
372
+ field_def_class.define_method("index", method!(RbFieldDefinition::index, 0))?;
373
+ field_def_class.define_method("name", method!(RbFieldDefinition::name, 0))?;
374
+ field_def_class.define_method("field_type", method!(RbFieldDefinition::field_type, 0))?;
375
+ field_def_class.define_method("description", method!(RbFieldDefinition::description, 0))?;
376
+ field_def_class.define_method("to_s", method!(RbFieldDefinition::to_s, 0))?;
377
+ field_def_class.define_method("inspect", method!(RbFieldDefinition::inspect, 0))?;
378
+
379
+ let schema_class = module.define_class("Schema", ruby.class_object())?;
380
+ schema_class.define_singleton_method("new", function!(RbSchema::new, 1))?;
381
+ schema_class
382
+ .define_singleton_method("create_default", function!(RbSchema::create_default, 0))?;
383
+ schema_class.define_method("fields", method!(RbSchema::fields, 0))?;
384
+ schema_class.define_method("get_field_index", method!(RbSchema::get_field_index, 1))?;
385
+ schema_class.define_method("field_count", method!(RbSchema::field_count, 0))?;
386
+ schema_class.define_method("get_field_name", method!(RbSchema::get_field_name, 1))?;
387
+ schema_class.define_method("get_custom_fields", method!(RbSchema::get_custom_fields, 0))?;
388
+ schema_class.define_method("get_all_fields", method!(RbSchema::get_all_fields, 0))?;
389
+ schema_class.define_method("get_field_by_name", method!(RbSchema::get_field_by_name, 1))?;
390
+ schema_class.define_method("validate_record", method!(RbSchema::validate_record, 1))?;
391
+ schema_class.define_method("to_s", method!(RbSchema::to_s, 0))?;
392
+ schema_class.define_method("inspect", method!(RbSchema::inspect, 0))?;
393
+
394
+ Ok(())
395
+ }
396
+
397
+ #[cfg(test)]
398
+ mod tests {
399
+ use super::*;
400
+
401
+ #[test]
402
+ fn test_rb_field_type_surface_to_lindera() {
403
+ let rb = RbFieldType {
404
+ inner: RbFieldTypeKind::Surface,
405
+ };
406
+ let lindera: FieldType = rb.into();
407
+ assert!(matches!(lindera, FieldType::Surface));
408
+ }
409
+
410
+ #[test]
411
+ fn test_rb_field_type_custom_to_lindera() {
412
+ let rb = RbFieldType {
413
+ inner: RbFieldTypeKind::Custom,
414
+ };
415
+ let lindera: FieldType = rb.into();
416
+ assert!(matches!(lindera, FieldType::Custom));
417
+ }
418
+
419
+ #[test]
420
+ fn test_lindera_field_type_surface_to_rb() {
421
+ let rb: RbFieldType = FieldType::Surface.into();
422
+ assert!(matches!(rb.inner, RbFieldTypeKind::Surface));
423
+ }
424
+
425
+ #[test]
426
+ fn test_lindera_field_type_custom_to_rb() {
427
+ let rb: RbFieldType = FieldType::Custom.into();
428
+ assert!(matches!(rb.inner, RbFieldTypeKind::Custom));
429
+ }
430
+
431
+ #[test]
432
+ fn test_rb_schema_new_builds_index_map() {
433
+ let fields = vec!["a".to_string(), "b".to_string(), "c".to_string()];
434
+ let schema = RbSchema::new_internal(fields);
435
+ assert_eq!(schema.get_field_index("a".to_string()), Some(0));
436
+ assert_eq!(schema.get_field_index("b".to_string()), Some(1));
437
+ assert_eq!(schema.get_field_index("c".to_string()), Some(2));
438
+ assert_eq!(schema.get_field_index("d".to_string()), None);
439
+ }
440
+
441
+ #[test]
442
+ fn test_rb_schema_field_count() {
443
+ let fields = vec!["x".to_string(), "y".to_string()];
444
+ let schema = RbSchema::new_internal(fields);
445
+ assert_eq!(schema.field_count(), 2);
446
+ }
447
+
448
+ #[test]
449
+ fn test_rb_schema_get_custom_fields_with_more_than_4() {
450
+ let fields = vec![
451
+ "surface".to_string(),
452
+ "left_context_id".to_string(),
453
+ "right_context_id".to_string(),
454
+ "cost".to_string(),
455
+ "major_pos".to_string(),
456
+ "reading".to_string(),
457
+ ];
458
+ let schema = RbSchema::new_internal(fields);
459
+ let custom = schema.get_custom_fields();
460
+ assert_eq!(custom, vec!["major_pos", "reading"]);
461
+ }
462
+
463
+ #[test]
464
+ fn test_rb_schema_get_custom_fields_with_4_or_fewer() {
465
+ let fields = vec![
466
+ "surface".to_string(),
467
+ "left_context_id".to_string(),
468
+ "right_context_id".to_string(),
469
+ "cost".to_string(),
470
+ ];
471
+ let schema = RbSchema::new_internal(fields);
472
+ assert!(schema.get_custom_fields().is_empty());
473
+ }
474
+
475
+ #[test]
476
+ fn test_rb_schema_create_default() {
477
+ let schema = RbSchema::create_default_internal();
478
+ assert_eq!(schema.field_count(), 13);
479
+ assert_eq!(schema.fields()[0], "surface");
480
+ assert_eq!(schema.fields()[3], "cost");
481
+ assert_eq!(schema.fields()[5], "pos_detail_1");
482
+ }
483
+
484
+ #[test]
485
+ fn test_rb_schema_get_field_by_name() {
486
+ let schema = RbSchema::create_default_internal();
487
+ let surface = schema.get_field_by_name("surface".to_string()).unwrap();
488
+ assert_eq!(surface.index, 0);
489
+ assert!(matches!(surface.field_type.inner, RbFieldTypeKind::Surface));
490
+
491
+ let custom = schema
492
+ .get_field_by_name("pos_detail_1".to_string())
493
+ .unwrap();
494
+ assert_eq!(custom.index, 5);
495
+ assert!(matches!(custom.field_type.inner, RbFieldTypeKind::Custom));
496
+
497
+ assert!(schema.get_field_by_name("nope".to_string()).is_none());
498
+ }
499
+
500
+ #[test]
501
+ fn test_rb_schema_to_lindera_schema() {
502
+ let fields = vec!["a".to_string(), "b".to_string(), "c".to_string()];
503
+ let rb_schema = RbSchema::new_internal(fields.clone());
504
+ let lindera_schema: Schema = rb_schema.into();
505
+ assert_eq!(lindera_schema.get_all_fields(), &fields);
506
+ }
507
+
508
+ #[test]
509
+ fn test_lindera_schema_to_rb_schema() {
510
+ let fields = vec!["x".to_string(), "y".to_string(), "z".to_string()];
511
+ let lindera_schema = Schema::new(fields.clone());
512
+ let rb_schema: RbSchema = lindera_schema.into();
513
+ assert_eq!(rb_schema.fields(), fields);
514
+ assert_eq!(rb_schema.get_field_index("x".to_string()), Some(0));
515
+ assert_eq!(rb_schema.get_field_index("z".to_string()), Some(2));
516
+ }
517
+
518
+ #[test]
519
+ fn test_rb_schema_roundtrip() {
520
+ let fields = vec![
521
+ "surface".to_string(),
522
+ "left_context_id".to_string(),
523
+ "right_context_id".to_string(),
524
+ "cost".to_string(),
525
+ "reading".to_string(),
526
+ ];
527
+ let rb_schema = RbSchema::new_internal(fields.clone());
528
+ let lindera_schema: Schema = rb_schema.into();
529
+ let back: RbSchema = lindera_schema.into();
530
+ assert_eq!(back.fields(), fields);
531
+ assert_eq!(back.field_count(), 5);
532
+ }
533
+
534
+ #[test]
535
+ fn test_rb_field_definition_to_lindera() {
536
+ let rb_def = RbFieldDefinition {
537
+ index: 2,
538
+ name: "right_context_id".to_string(),
539
+ field_type: RbFieldType {
540
+ inner: RbFieldTypeKind::RightContextId,
541
+ },
542
+ description: Some("Right context ID".to_string()),
543
+ };
544
+ let lindera_def: FieldDefinition = rb_def.into();
545
+ assert_eq!(lindera_def.index, 2);
546
+ assert_eq!(lindera_def.name, "right_context_id");
547
+ assert!(matches!(lindera_def.field_type, FieldType::RightContextId));
548
+ assert_eq!(
549
+ lindera_def.description,
550
+ Some("Right context ID".to_string())
551
+ );
552
+ }
553
+
554
+ #[test]
555
+ fn test_lindera_field_definition_to_rb() {
556
+ let lindera_def = FieldDefinition {
557
+ index: 4,
558
+ name: "major_pos".to_string(),
559
+ field_type: FieldType::Custom,
560
+ description: None,
561
+ };
562
+ let rb_def: RbFieldDefinition = lindera_def.into();
563
+ assert_eq!(rb_def.index, 4);
564
+ assert_eq!(rb_def.name, "major_pos");
565
+ assert!(matches!(rb_def.field_type.inner, RbFieldTypeKind::Custom));
566
+ assert!(rb_def.description.is_none());
567
+ }
568
+ }