tree_sitter_language_pack 1.15.12 → 1.16.2

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.
Files changed (6) hide show
  1. checksums.yaml +4 -4
  2. data/ext/ts_pack_core_rb/native/Cargo.lock +7 -7
  3. data/ext/ts_pack_core_rb/native/Cargo.toml +4 -4
  4. data/ext/ts_pack_core_rb/src/lib.rs +1026 -409
  5. data/lib/tree_sitter_language_pack/version.rb +2 -2
  6. metadata +5 -5
data/ext/ts_pack_core_rb/src/lib.rs CHANGED
@@ -1,5 +1,5 @@
1
1
  // This file is auto-generated by alef. DO NOT EDIT.
2
- // alef:hash:79bc9eb2e7ae23e3ac94ecd8e1bbb9cb239dfb72a68a1e8f965d1c5323425f75
2
+ // alef:hash:c3615d7c5390fb2f911fcfde880fe0b9856216e28c6b830e42ce58db41dc60f1
3
3
  // Re-generate with: alef generate
4
4
  #![allow(dead_code, unused_imports, unused_variables)]
5
5
  #![allow(
@@ -99,14 +99,24 @@ impl ByteRange {
99
99
  let (kwargs_opt,) = args.optional;
100
100
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
101
101
  Ok(Self {
102
- start: kwargs
103
- .get(ruby.to_symbol("start"))
104
- .and_then(|v| usize::try_convert(v).ok())
105
- .unwrap_or_default(),
106
- end: kwargs
107
- .get(ruby.to_symbol("end"))
108
- .and_then(|v| usize::try_convert(v).ok())
109
- .unwrap_or_default(),
102
+ start: match kwargs.get(ruby.to_symbol("start")) {
103
+ Some(v) => usize::try_convert(v).map_err(|e| {
104
+ magnus::Error::new(
105
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
106
+ format!("invalid value for `start`: {}", e),
107
+ )
108
+ })?,
109
+ None => Default::default(),
110
+ },
111
+ end: match kwargs.get(ruby.to_symbol("end")) {
112
+ Some(v) => usize::try_convert(v).map_err(|e| {
113
+ magnus::Error::new(
114
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
115
+ format!("invalid value for `end`: {}", e),
116
+ )
117
+ })?,
118
+ None => Default::default(),
119
+ },
110
120
  })
111
121
  }
112
122
 
@@ -175,42 +185,87 @@ impl ChunkContext {
175
185
  let (kwargs_opt,) = args.optional;
176
186
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
177
187
  Ok(Self {
178
- language: kwargs
179
- .get(ruby.to_symbol("language"))
180
- .and_then(|v| String::try_convert(v).ok())
181
- .unwrap_or_default(),
182
- chunk_index: kwargs
183
- .get(ruby.to_symbol("chunk_index"))
184
- .and_then(|v| usize::try_convert(v).ok())
185
- .unwrap_or_default(),
186
- total_chunks: kwargs
187
- .get(ruby.to_symbol("total_chunks"))
188
- .and_then(|v| usize::try_convert(v).ok())
189
- .unwrap_or_default(),
190
- node_types: kwargs
191
- .get(ruby.to_symbol("node_types"))
192
- .and_then(|v| <Vec<String>>::try_convert(v).ok())
193
- .unwrap_or_default(),
194
- context_path: kwargs
195
- .get(ruby.to_symbol("context_path"))
196
- .and_then(|v| <Vec<String>>::try_convert(v).ok())
197
- .unwrap_or_default(),
198
- symbols_defined: kwargs
199
- .get(ruby.to_symbol("symbols_defined"))
200
- .and_then(|v| <Vec<String>>::try_convert(v).ok())
201
- .unwrap_or_default(),
202
- comments: kwargs
203
- .get(ruby.to_symbol("comments"))
204
- .and_then(|v| <Vec<CommentInfo>>::try_convert(v).ok())
205
- .unwrap_or_default(),
206
- docstrings: kwargs
207
- .get(ruby.to_symbol("docstrings"))
208
- .and_then(|v| <Vec<DocstringInfo>>::try_convert(v).ok())
209
- .unwrap_or_default(),
210
- has_error_nodes: kwargs
211
- .get(ruby.to_symbol("has_error_nodes"))
212
- .and_then(|v| bool::try_convert(v).ok())
213
- .unwrap_or_default(),
188
+ language: match kwargs.get(ruby.to_symbol("language")) {
189
+ Some(v) => String::try_convert(v).map_err(|e| {
190
+ magnus::Error::new(
191
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
192
+ format!("invalid value for `language`: {}", e),
193
+ )
194
+ })?,
195
+ None => Default::default(),
196
+ },
197
+ chunk_index: match kwargs.get(ruby.to_symbol("chunk_index")) {
198
+ Some(v) => usize::try_convert(v).map_err(|e| {
199
+ magnus::Error::new(
200
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
201
+ format!("invalid value for `chunk_index`: {}", e),
202
+ )
203
+ })?,
204
+ None => Default::default(),
205
+ },
206
+ total_chunks: match kwargs.get(ruby.to_symbol("total_chunks")) {
207
+ Some(v) => usize::try_convert(v).map_err(|e| {
208
+ magnus::Error::new(
209
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
210
+ format!("invalid value for `total_chunks`: {}", e),
211
+ )
212
+ })?,
213
+ None => Default::default(),
214
+ },
215
+ node_types: match kwargs.get(ruby.to_symbol("node_types")) {
216
+ Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
217
+ magnus::Error::new(
218
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
219
+ format!("invalid value for `node_types`: {}", e),
220
+ )
221
+ })?,
222
+ None => Default::default(),
223
+ },
224
+ context_path: match kwargs.get(ruby.to_symbol("context_path")) {
225
+ Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
226
+ magnus::Error::new(
227
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
228
+ format!("invalid value for `context_path`: {}", e),
229
+ )
230
+ })?,
231
+ None => Default::default(),
232
+ },
233
+ symbols_defined: match kwargs.get(ruby.to_symbol("symbols_defined")) {
234
+ Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
235
+ magnus::Error::new(
236
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
237
+ format!("invalid value for `symbols_defined`: {}", e),
238
+ )
239
+ })?,
240
+ None => Default::default(),
241
+ },
242
+ comments: match kwargs.get(ruby.to_symbol("comments")) {
243
+ Some(v) => <Vec<CommentInfo>>::try_convert(v).map_err(|e| {
244
+ magnus::Error::new(
245
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
246
+ format!("invalid value for `comments`: {}", e),
247
+ )
248
+ })?,
249
+ None => Default::default(),
250
+ },
251
+ docstrings: match kwargs.get(ruby.to_symbol("docstrings")) {
252
+ Some(v) => <Vec<DocstringInfo>>::try_convert(v).map_err(|e| {
253
+ magnus::Error::new(
254
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
255
+ format!("invalid value for `docstrings`: {}", e),
256
+ )
257
+ })?,
258
+ None => Default::default(),
259
+ },
260
+ has_error_nodes: match kwargs.get(ruby.to_symbol("has_error_nodes")) {
261
+ Some(v) => bool::try_convert(v).map_err(|e| {
262
+ magnus::Error::new(
263
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
264
+ format!("invalid value for `has_error_nodes`: {}", e),
265
+ )
266
+ })?,
267
+ None => Default::default(),
268
+ },
214
269
  })
215
270
  }
216
271
 
@@ -304,30 +359,60 @@ impl CodeChunk {
304
359
  let (kwargs_opt,) = args.optional;
305
360
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
306
361
  Ok(Self {
307
- content: kwargs
308
- .get(ruby.to_symbol("content"))
309
- .and_then(|v| String::try_convert(v).ok())
310
- .unwrap_or_default(),
311
- start_byte: kwargs
312
- .get(ruby.to_symbol("start_byte"))
313
- .and_then(|v| usize::try_convert(v).ok())
314
- .unwrap_or_default(),
315
- end_byte: kwargs
316
- .get(ruby.to_symbol("end_byte"))
317
- .and_then(|v| usize::try_convert(v).ok())
318
- .unwrap_or_default(),
319
- start_line: kwargs
320
- .get(ruby.to_symbol("start_line"))
321
- .and_then(|v| usize::try_convert(v).ok())
322
- .unwrap_or_default(),
323
- end_line: kwargs
324
- .get(ruby.to_symbol("end_line"))
325
- .and_then(|v| usize::try_convert(v).ok())
326
- .unwrap_or_default(),
327
- metadata: kwargs
328
- .get(ruby.to_symbol("metadata"))
329
- .and_then(|v| ChunkContext::try_convert(v).ok())
330
- .unwrap_or_default(),
362
+ content: match kwargs.get(ruby.to_symbol("content")) {
363
+ Some(v) => String::try_convert(v).map_err(|e| {
364
+ magnus::Error::new(
365
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
366
+ format!("invalid value for `content`: {}", e),
367
+ )
368
+ })?,
369
+ None => Default::default(),
370
+ },
371
+ start_byte: match kwargs.get(ruby.to_symbol("start_byte")) {
372
+ Some(v) => usize::try_convert(v).map_err(|e| {
373
+ magnus::Error::new(
374
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
375
+ format!("invalid value for `start_byte`: {}", e),
376
+ )
377
+ })?,
378
+ None => Default::default(),
379
+ },
380
+ end_byte: match kwargs.get(ruby.to_symbol("end_byte")) {
381
+ Some(v) => usize::try_convert(v).map_err(|e| {
382
+ magnus::Error::new(
383
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
384
+ format!("invalid value for `end_byte`: {}", e),
385
+ )
386
+ })?,
387
+ None => Default::default(),
388
+ },
389
+ start_line: match kwargs.get(ruby.to_symbol("start_line")) {
390
+ Some(v) => usize::try_convert(v).map_err(|e| {
391
+ magnus::Error::new(
392
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
393
+ format!("invalid value for `start_line`: {}", e),
394
+ )
395
+ })?,
396
+ None => Default::default(),
397
+ },
398
+ end_line: match kwargs.get(ruby.to_symbol("end_line")) {
399
+ Some(v) => usize::try_convert(v).map_err(|e| {
400
+ magnus::Error::new(
401
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
402
+ format!("invalid value for `end_line`: {}", e),
403
+ )
404
+ })?,
405
+ None => Default::default(),
406
+ },
407
+ metadata: match kwargs.get(ruby.to_symbol("metadata")) {
408
+ Some(v) => ChunkContext::try_convert(v).map_err(|e| {
409
+ magnus::Error::new(
410
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
411
+ format!("invalid value for `metadata`: {}", e),
412
+ )
413
+ })?,
414
+ None => Default::default(),
415
+ },
331
416
  })
332
417
  }
333
418
 
@@ -412,21 +497,42 @@ impl CommentInfo {
412
497
  let (kwargs_opt,) = args.optional;
413
498
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
414
499
  Ok(Self {
415
- text: kwargs
416
- .get(ruby.to_symbol("text"))
417
- .and_then(|v| String::try_convert(v).ok())
418
- .unwrap_or_default(),
419
- kind: kwargs
420
- .get(ruby.to_symbol("kind"))
421
- .and_then(|v| CommentKind::try_convert(v).ok())
422
- .unwrap_or(CommentKind::Line),
423
- span: kwargs
424
- .get(ruby.to_symbol("span"))
425
- .and_then(|v| Span::try_convert(v).ok())
426
- .unwrap_or_default(),
427
- associated_node: kwargs
428
- .get(ruby.to_symbol("associated_node"))
429
- .and_then(|v| String::try_convert(v).ok()),
500
+ text: match kwargs.get(ruby.to_symbol("text")) {
501
+ Some(v) => String::try_convert(v).map_err(|e| {
502
+ magnus::Error::new(
503
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
504
+ format!("invalid value for `text`: {}", e),
505
+ )
506
+ })?,
507
+ None => Default::default(),
508
+ },
509
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
510
+ Some(v) => CommentKind::try_convert(v).map_err(|e| {
511
+ magnus::Error::new(
512
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
513
+ format!("invalid value for `kind`: {}", e),
514
+ )
515
+ })?,
516
+ None => CommentKind::Line,
517
+ },
518
+ span: match kwargs.get(ruby.to_symbol("span")) {
519
+ Some(v) => Span::try_convert(v).map_err(|e| {
520
+ magnus::Error::new(
521
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
522
+ format!("invalid value for `span`: {}", e),
523
+ )
524
+ })?,
525
+ None => Default::default(),
526
+ },
527
+ associated_node: match kwargs.get(ruby.to_symbol("associated_node")) {
528
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
529
+ magnus::Error::new(
530
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
531
+ format!("invalid value for `associated_node`: {}", e),
532
+ )
533
+ })?),
534
+ None => None,
535
+ },
430
536
  })
431
537
  }
432
538
 
@@ -497,18 +603,33 @@ impl DataAttribute {
497
603
  let (kwargs_opt,) = args.optional;
498
604
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
499
605
  Ok(Self {
500
- name: kwargs
501
- .get(ruby.to_symbol("name"))
502
- .and_then(|v| String::try_convert(v).ok())
503
- .unwrap_or_default(),
504
- value: kwargs
505
- .get(ruby.to_symbol("value"))
506
- .and_then(|v| String::try_convert(v).ok())
507
- .unwrap_or_default(),
508
- span: kwargs
509
- .get(ruby.to_symbol("span"))
510
- .and_then(|v| Span::try_convert(v).ok())
511
- .unwrap_or_default(),
606
+ name: match kwargs.get(ruby.to_symbol("name")) {
607
+ Some(v) => String::try_convert(v).map_err(|e| {
608
+ magnus::Error::new(
609
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
610
+ format!("invalid value for `name`: {}", e),
611
+ )
612
+ })?,
613
+ None => Default::default(),
614
+ },
615
+ value: match kwargs.get(ruby.to_symbol("value")) {
616
+ Some(v) => String::try_convert(v).map_err(|e| {
617
+ magnus::Error::new(
618
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
619
+ format!("invalid value for `value`: {}", e),
620
+ )
621
+ })?,
622
+ None => Default::default(),
623
+ },
624
+ span: match kwargs.get(ruby.to_symbol("span")) {
625
+ Some(v) => Span::try_convert(v).map_err(|e| {
626
+ magnus::Error::new(
627
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
628
+ format!("invalid value for `span`: {}", e),
629
+ )
630
+ })?,
631
+ None => Default::default(),
632
+ },
512
633
  })
513
634
  }
514
635
 
@@ -525,7 +646,7 @@ impl DataAttribute {
525
646
  }
526
647
  }
527
648
 
528
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
649
+ #[derive(Clone, Debug, serde::Serialize)]
529
650
  #[serde(default)]
530
651
  #[magnus::wrap(class = "TreeSitterLanguagePack::DataNode")]
531
652
  pub struct DataNode {
@@ -564,6 +685,14 @@ impl magnus::TryConvert for DataNode {
564
685
  }
565
686
 
566
687
  unsafe impl TryConvertOwned for DataNode {}
688
+ impl<'de> serde::Deserialize<'de> for DataNode {
689
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
690
+ where
691
+ D: serde::Deserializer<'de>,
692
+ {
693
+ <tree_sitter_language_pack::DataNode as serde::Deserialize>::deserialize(deserializer).map(Into::into)
694
+ }
695
+ }
567
696
 
568
697
  impl Default for DataNode {
569
698
  fn default() -> Self {
@@ -578,28 +707,60 @@ impl DataNode {
578
707
  let (kwargs_opt,) = args.optional;
579
708
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
580
709
  Ok(Self {
581
- kind: kwargs
582
- .get(ruby.to_symbol("kind"))
583
- .and_then(|v| DataNodeKind::try_convert(v).ok())
584
- .unwrap_or(DataNodeKind::KeyValue),
585
- key: kwargs
586
- .get(ruby.to_symbol("key"))
587
- .and_then(|v| String::try_convert(v).ok()),
588
- value: kwargs
589
- .get(ruby.to_symbol("value"))
590
- .and_then(|v| String::try_convert(v).ok()),
591
- attributes: kwargs
592
- .get(ruby.to_symbol("attributes"))
593
- .and_then(|v| <Vec<DataAttribute>>::try_convert(v).ok())
594
- .unwrap_or_default(),
595
- children: kwargs
596
- .get(ruby.to_symbol("children"))
597
- .and_then(|v| <Vec<DataNode>>::try_convert(v).ok())
598
- .unwrap_or_default(),
599
- span: kwargs
600
- .get(ruby.to_symbol("span"))
601
- .and_then(|v| Span::try_convert(v).ok())
602
- .unwrap_or_default(),
710
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
711
+ Some(v) => DataNodeKind::try_convert(v).map_err(|e| {
712
+ magnus::Error::new(
713
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
714
+ format!("invalid value for `kind`: {}", e),
715
+ )
716
+ })?,
717
+ None => DataNodeKind::KeyValue,
718
+ },
719
+ key: match kwargs.get(ruby.to_symbol("key")) {
720
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
721
+ magnus::Error::new(
722
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
723
+ format!("invalid value for `key`: {}", e),
724
+ )
725
+ })?),
726
+ None => None,
727
+ },
728
+ value: match kwargs.get(ruby.to_symbol("value")) {
729
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
730
+ magnus::Error::new(
731
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
732
+ format!("invalid value for `value`: {}", e),
733
+ )
734
+ })?),
735
+ None => None,
736
+ },
737
+ attributes: match kwargs.get(ruby.to_symbol("attributes")) {
738
+ Some(v) => <Vec<DataAttribute>>::try_convert(v).map_err(|e| {
739
+ magnus::Error::new(
740
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
741
+ format!("invalid value for `attributes`: {}", e),
742
+ )
743
+ })?,
744
+ None => Default::default(),
745
+ },
746
+ children: match kwargs.get(ruby.to_symbol("children")) {
747
+ Some(v) => <Vec<DataNode>>::try_convert(v).map_err(|e| {
748
+ magnus::Error::new(
749
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
750
+ format!("invalid value for `children`: {}", e),
751
+ )
752
+ })?,
753
+ None => Default::default(),
754
+ },
755
+ span: match kwargs.get(ruby.to_symbol("span")) {
756
+ Some(v) => Span::try_convert(v).map_err(|e| {
757
+ magnus::Error::new(
758
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
759
+ format!("invalid value for `span`: {}", e),
760
+ )
761
+ })?,
762
+ None => Default::default(),
763
+ },
603
764
  })
604
765
  }
605
766
 
@@ -678,18 +839,33 @@ impl Diagnostic {
678
839
  let (kwargs_opt,) = args.optional;
679
840
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
680
841
  Ok(Self {
681
- message: kwargs
682
- .get(ruby.to_symbol("message"))
683
- .and_then(|v| String::try_convert(v).ok())
684
- .unwrap_or_default(),
685
- severity: kwargs
686
- .get(ruby.to_symbol("severity"))
687
- .and_then(|v| DiagnosticSeverity::try_convert(v).ok())
688
- .unwrap_or(DiagnosticSeverity::Error),
689
- span: kwargs
690
- .get(ruby.to_symbol("span"))
691
- .and_then(|v| Span::try_convert(v).ok())
692
- .unwrap_or_default(),
842
+ message: match kwargs.get(ruby.to_symbol("message")) {
843
+ Some(v) => String::try_convert(v).map_err(|e| {
844
+ magnus::Error::new(
845
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
846
+ format!("invalid value for `message`: {}", e),
847
+ )
848
+ })?,
849
+ None => Default::default(),
850
+ },
851
+ severity: match kwargs.get(ruby.to_symbol("severity")) {
852
+ Some(v) => DiagnosticSeverity::try_convert(v).map_err(|e| {
853
+ magnus::Error::new(
854
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
855
+ format!("invalid value for `severity`: {}", e),
856
+ )
857
+ })?,
858
+ None => DiagnosticSeverity::Error,
859
+ },
860
+ span: match kwargs.get(ruby.to_symbol("span")) {
861
+ Some(v) => Span::try_convert(v).map_err(|e| {
862
+ magnus::Error::new(
863
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
864
+ format!("invalid value for `span`: {}", e),
865
+ )
866
+ })?,
867
+ None => Default::default(),
868
+ },
693
869
  })
694
870
  }
695
871
 
@@ -756,17 +932,33 @@ impl DocSection {
756
932
  let (kwargs_opt,) = args.optional;
757
933
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
758
934
  Ok(Self {
759
- kind: kwargs
760
- .get(ruby.to_symbol("kind"))
761
- .and_then(|v| String::try_convert(v).ok())
762
- .unwrap_or_default(),
763
- name: kwargs
764
- .get(ruby.to_symbol("name"))
765
- .and_then(|v| String::try_convert(v).ok()),
766
- description: kwargs
767
- .get(ruby.to_symbol("description"))
768
- .and_then(|v| String::try_convert(v).ok())
769
- .unwrap_or_default(),
935
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
936
+ Some(v) => String::try_convert(v).map_err(|e| {
937
+ magnus::Error::new(
938
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
939
+ format!("invalid value for `kind`: {}", e),
940
+ )
941
+ })?,
942
+ None => Default::default(),
943
+ },
944
+ name: match kwargs.get(ruby.to_symbol("name")) {
945
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
946
+ magnus::Error::new(
947
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
948
+ format!("invalid value for `name`: {}", e),
949
+ )
950
+ })?),
951
+ None => None,
952
+ },
953
+ description: match kwargs.get(ruby.to_symbol("description")) {
954
+ Some(v) => String::try_convert(v).map_err(|e| {
955
+ magnus::Error::new(
956
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
957
+ format!("invalid value for `description`: {}", e),
958
+ )
959
+ })?,
960
+ None => Default::default(),
961
+ },
770
962
  })
771
963
  }
772
964
 
@@ -783,7 +975,7 @@ impl DocSection {
783
975
  }
784
976
  }
785
977
 
786
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
978
+ #[derive(Clone, Debug, serde::Serialize)]
787
979
  #[serde(default)]
788
980
  #[magnus::wrap(class = "TreeSitterLanguagePack::DocstringInfo")]
789
981
  pub struct DocstringInfo {
@@ -821,6 +1013,14 @@ impl magnus::TryConvert for DocstringInfo {
821
1013
  }
822
1014
 
823
1015
  unsafe impl TryConvertOwned for DocstringInfo {}
1016
+ impl<'de> serde::Deserialize<'de> for DocstringInfo {
1017
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
1018
+ where
1019
+ D: serde::Deserializer<'de>,
1020
+ {
1021
+ <tree_sitter_language_pack::DocstringInfo as serde::Deserialize>::deserialize(deserializer).map(Into::into)
1022
+ }
1023
+ }
824
1024
 
825
1025
  impl Default for DocstringInfo {
826
1026
  fn default() -> Self {
@@ -835,25 +1035,51 @@ impl DocstringInfo {
835
1035
  let (kwargs_opt,) = args.optional;
836
1036
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
837
1037
  Ok(Self {
838
- text: kwargs
839
- .get(ruby.to_symbol("text"))
840
- .and_then(|v| String::try_convert(v).ok())
841
- .unwrap_or_default(),
842
- format: kwargs
843
- .get(ruby.to_symbol("format"))
844
- .and_then(|v| DocstringFormat::try_convert(v).ok())
845
- .unwrap_or(DocstringFormat::PythonTripleQuote),
846
- span: kwargs
847
- .get(ruby.to_symbol("span"))
848
- .and_then(|v| Span::try_convert(v).ok())
849
- .unwrap_or_default(),
850
- associated_item: kwargs
851
- .get(ruby.to_symbol("associated_item"))
852
- .and_then(|v| String::try_convert(v).ok()),
853
- parsed_sections: kwargs
854
- .get(ruby.to_symbol("parsed_sections"))
855
- .and_then(|v| <Vec<DocSection>>::try_convert(v).ok())
856
- .unwrap_or_default(),
1038
+ text: match kwargs.get(ruby.to_symbol("text")) {
1039
+ Some(v) => String::try_convert(v).map_err(|e| {
1040
+ magnus::Error::new(
1041
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1042
+ format!("invalid value for `text`: {}", e),
1043
+ )
1044
+ })?,
1045
+ None => Default::default(),
1046
+ },
1047
+ format: match kwargs.get(ruby.to_symbol("format")) {
1048
+ Some(v) => DocstringFormat::try_convert(v).map_err(|e| {
1049
+ magnus::Error::new(
1050
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1051
+ format!("invalid value for `format`: {}", e),
1052
+ )
1053
+ })?,
1054
+ None => DocstringFormat::PythonTripleQuote,
1055
+ },
1056
+ span: match kwargs.get(ruby.to_symbol("span")) {
1057
+ Some(v) => Span::try_convert(v).map_err(|e| {
1058
+ magnus::Error::new(
1059
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1060
+ format!("invalid value for `span`: {}", e),
1061
+ )
1062
+ })?,
1063
+ None => Default::default(),
1064
+ },
1065
+ associated_item: match kwargs.get(ruby.to_symbol("associated_item")) {
1066
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
1067
+ magnus::Error::new(
1068
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1069
+ format!("invalid value for `associated_item`: {}", e),
1070
+ )
1071
+ })?),
1072
+ None => None,
1073
+ },
1074
+ parsed_sections: match kwargs.get(ruby.to_symbol("parsed_sections")) {
1075
+ Some(v) => <Vec<DocSection>>::try_convert(v).map_err(|e| {
1076
+ magnus::Error::new(
1077
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1078
+ format!("invalid value for `parsed_sections`: {}", e),
1079
+ )
1080
+ })?,
1081
+ None => Default::default(),
1082
+ },
857
1083
  })
858
1084
  }
859
1085
 
@@ -878,14 +1104,17 @@ impl DocstringInfo {
878
1104
  }
879
1105
  }
880
1106
 
1107
+ #[cfg(feature = "download")]
881
1108
  #[derive(Clone)]
882
1109
  #[magnus::wrap(class = "TreeSitterLanguagePack::DownloadManager")]
883
1110
  pub struct DownloadManager {
884
1111
  inner: Arc<tree_sitter_language_pack::DownloadManager>,
885
1112
  }
886
1113
 
1114
+ #[cfg(feature = "download")]
887
1115
  unsafe impl IntoValueFromNative for DownloadManager {}
888
1116
 
1117
+ #[cfg(feature = "download")]
889
1118
  impl magnus::TryConvert for DownloadManager {
890
1119
  fn try_convert(val: magnus::Value) -> Result<Self, magnus::Error> {
891
1120
  let r: &DownloadManager = magnus::TryConvert::try_convert(val)?;
@@ -893,8 +1122,10 @@ impl magnus::TryConvert for DownloadManager {
893
1122
  }
894
1123
  }
895
1124
 
1125
+ #[cfg(feature = "download")]
896
1126
  unsafe impl TryConvertOwned for DownloadManager {}
897
1127
 
1128
+ #[cfg(feature = "download")]
898
1129
  impl DownloadManager {
899
1130
  fn installed_languages(&self) -> Vec<String> {
900
1131
  self.inner.installed_languages()
@@ -971,18 +1202,33 @@ impl ExportInfo {
971
1202
  let (kwargs_opt,) = args.optional;
972
1203
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
973
1204
  Ok(Self {
974
- name: kwargs
975
- .get(ruby.to_symbol("name"))
976
- .and_then(|v| String::try_convert(v).ok())
977
- .unwrap_or_default(),
978
- kind: kwargs
979
- .get(ruby.to_symbol("kind"))
980
- .and_then(|v| ExportKind::try_convert(v).ok())
981
- .unwrap_or(ExportKind::Named),
982
- span: kwargs
983
- .get(ruby.to_symbol("span"))
984
- .and_then(|v| Span::try_convert(v).ok())
985
- .unwrap_or_default(),
1205
+ name: match kwargs.get(ruby.to_symbol("name")) {
1206
+ Some(v) => String::try_convert(v).map_err(|e| {
1207
+ magnus::Error::new(
1208
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1209
+ format!("invalid value for `name`: {}", e),
1210
+ )
1211
+ })?,
1212
+ None => Default::default(),
1213
+ },
1214
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
1215
+ Some(v) => ExportKind::try_convert(v).map_err(|e| {
1216
+ magnus::Error::new(
1217
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1218
+ format!("invalid value for `kind`: {}", e),
1219
+ )
1220
+ })?,
1221
+ None => ExportKind::Named,
1222
+ },
1223
+ span: match kwargs.get(ruby.to_symbol("span")) {
1224
+ Some(v) => Span::try_convert(v).map_err(|e| {
1225
+ magnus::Error::new(
1226
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1227
+ format!("invalid value for `span`: {}", e),
1228
+ )
1229
+ })?,
1230
+ None => Default::default(),
1231
+ },
986
1232
  })
987
1233
  }
988
1234
 
@@ -1054,38 +1300,78 @@ impl FileMetrics {
1054
1300
  let (kwargs_opt,) = args.optional;
1055
1301
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
1056
1302
  Ok(Self {
1057
- total_lines: kwargs
1058
- .get(ruby.to_symbol("total_lines"))
1059
- .and_then(|v| usize::try_convert(v).ok())
1060
- .unwrap_or_default(),
1061
- code_lines: kwargs
1062
- .get(ruby.to_symbol("code_lines"))
1063
- .and_then(|v| usize::try_convert(v).ok())
1064
- .unwrap_or_default(),
1065
- comment_lines: kwargs
1066
- .get(ruby.to_symbol("comment_lines"))
1067
- .and_then(|v| usize::try_convert(v).ok())
1068
- .unwrap_or_default(),
1069
- blank_lines: kwargs
1070
- .get(ruby.to_symbol("blank_lines"))
1071
- .and_then(|v| usize::try_convert(v).ok())
1072
- .unwrap_or_default(),
1073
- total_bytes: kwargs
1074
- .get(ruby.to_symbol("total_bytes"))
1075
- .and_then(|v| usize::try_convert(v).ok())
1076
- .unwrap_or_default(),
1077
- node_count: kwargs
1078
- .get(ruby.to_symbol("node_count"))
1079
- .and_then(|v| usize::try_convert(v).ok())
1080
- .unwrap_or_default(),
1081
- error_count: kwargs
1082
- .get(ruby.to_symbol("error_count"))
1083
- .and_then(|v| usize::try_convert(v).ok())
1084
- .unwrap_or_default(),
1085
- max_depth: kwargs
1086
- .get(ruby.to_symbol("max_depth"))
1087
- .and_then(|v| usize::try_convert(v).ok())
1088
- .unwrap_or_default(),
1303
+ total_lines: match kwargs.get(ruby.to_symbol("total_lines")) {
1304
+ Some(v) => usize::try_convert(v).map_err(|e| {
1305
+ magnus::Error::new(
1306
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1307
+ format!("invalid value for `total_lines`: {}", e),
1308
+ )
1309
+ })?,
1310
+ None => Default::default(),
1311
+ },
1312
+ code_lines: match kwargs.get(ruby.to_symbol("code_lines")) {
1313
+ Some(v) => usize::try_convert(v).map_err(|e| {
1314
+ magnus::Error::new(
1315
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1316
+ format!("invalid value for `code_lines`: {}", e),
1317
+ )
1318
+ })?,
1319
+ None => Default::default(),
1320
+ },
1321
+ comment_lines: match kwargs.get(ruby.to_symbol("comment_lines")) {
1322
+ Some(v) => usize::try_convert(v).map_err(|e| {
1323
+ magnus::Error::new(
1324
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1325
+ format!("invalid value for `comment_lines`: {}", e),
1326
+ )
1327
+ })?,
1328
+ None => Default::default(),
1329
+ },
1330
+ blank_lines: match kwargs.get(ruby.to_symbol("blank_lines")) {
1331
+ Some(v) => usize::try_convert(v).map_err(|e| {
1332
+ magnus::Error::new(
1333
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1334
+ format!("invalid value for `blank_lines`: {}", e),
1335
+ )
1336
+ })?,
1337
+ None => Default::default(),
1338
+ },
1339
+ total_bytes: match kwargs.get(ruby.to_symbol("total_bytes")) {
1340
+ Some(v) => usize::try_convert(v).map_err(|e| {
1341
+ magnus::Error::new(
1342
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1343
+ format!("invalid value for `total_bytes`: {}", e),
1344
+ )
1345
+ })?,
1346
+ None => Default::default(),
1347
+ },
1348
+ node_count: match kwargs.get(ruby.to_symbol("node_count")) {
1349
+ Some(v) => usize::try_convert(v).map_err(|e| {
1350
+ magnus::Error::new(
1351
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1352
+ format!("invalid value for `node_count`: {}", e),
1353
+ )
1354
+ })?,
1355
+ None => Default::default(),
1356
+ },
1357
+ error_count: match kwargs.get(ruby.to_symbol("error_count")) {
1358
+ Some(v) => usize::try_convert(v).map_err(|e| {
1359
+ magnus::Error::new(
1360
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1361
+ format!("invalid value for `error_count`: {}", e),
1362
+ )
1363
+ })?,
1364
+ None => Default::default(),
1365
+ },
1366
+ max_depth: match kwargs.get(ruby.to_symbol("max_depth")) {
1367
+ Some(v) => usize::try_convert(v).map_err(|e| {
1368
+ magnus::Error::new(
1369
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1370
+ format!("invalid value for `max_depth`: {}", e),
1371
+ )
1372
+ })?,
1373
+ None => Default::default(),
1374
+ },
1089
1375
  })
1090
1376
  }
1091
1377
 
@@ -1122,7 +1408,7 @@ impl FileMetrics {
1122
1408
  }
1123
1409
  }
1124
1410
 
1125
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
1411
+ #[derive(Clone, Debug, serde::Serialize)]
1126
1412
  #[serde(default)]
1127
1413
  #[magnus::wrap(class = "TreeSitterLanguagePack::ImportInfo")]
1128
1414
  pub struct ImportInfo {
@@ -1160,6 +1446,14 @@ impl magnus::TryConvert for ImportInfo {
1160
1446
  }
1161
1447
 
1162
1448
  unsafe impl TryConvertOwned for ImportInfo {}
1449
+ impl<'de> serde::Deserialize<'de> for ImportInfo {
1450
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
1451
+ where
1452
+ D: serde::Deserializer<'de>,
1453
+ {
1454
+ <tree_sitter_language_pack::ImportInfo as serde::Deserialize>::deserialize(deserializer).map(Into::into)
1455
+ }
1456
+ }
1163
1457
 
1164
1458
  impl Default for ImportInfo {
1165
1459
  fn default() -> Self {
@@ -1174,25 +1468,51 @@ impl ImportInfo {
1174
1468
  let (kwargs_opt,) = args.optional;
1175
1469
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
1176
1470
  Ok(Self {
1177
- source: kwargs
1178
- .get(ruby.to_symbol("source"))
1179
- .and_then(|v| String::try_convert(v).ok())
1180
- .unwrap_or_default(),
1181
- items: kwargs
1182
- .get(ruby.to_symbol("items"))
1183
- .and_then(|v| <Vec<String>>::try_convert(v).ok())
1184
- .unwrap_or_default(),
1185
- alias: kwargs
1186
- .get(ruby.to_symbol("alias"))
1187
- .and_then(|v| String::try_convert(v).ok()),
1188
- is_wildcard: kwargs
1189
- .get(ruby.to_symbol("is_wildcard"))
1190
- .and_then(|v| bool::try_convert(v).ok())
1191
- .unwrap_or_default(),
1192
- span: kwargs
1193
- .get(ruby.to_symbol("span"))
1194
- .and_then(|v| Span::try_convert(v).ok())
1195
- .unwrap_or_default(),
1471
+ source: match kwargs.get(ruby.to_symbol("source")) {
1472
+ Some(v) => String::try_convert(v).map_err(|e| {
1473
+ magnus::Error::new(
1474
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1475
+ format!("invalid value for `source`: {}", e),
1476
+ )
1477
+ })?,
1478
+ None => Default::default(),
1479
+ },
1480
+ items: match kwargs.get(ruby.to_symbol("items")) {
1481
+ Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
1482
+ magnus::Error::new(
1483
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1484
+ format!("invalid value for `items`: {}", e),
1485
+ )
1486
+ })?,
1487
+ None => Default::default(),
1488
+ },
1489
+ alias: match kwargs.get(ruby.to_symbol("alias")) {
1490
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
1491
+ magnus::Error::new(
1492
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1493
+ format!("invalid value for `alias`: {}", e),
1494
+ )
1495
+ })?),
1496
+ None => None,
1497
+ },
1498
+ is_wildcard: match kwargs.get(ruby.to_symbol("is_wildcard")) {
1499
+ Some(v) => bool::try_convert(v).map_err(|e| {
1500
+ magnus::Error::new(
1501
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1502
+ format!("invalid value for `is_wildcard`: {}", e),
1503
+ )
1504
+ })?,
1505
+ None => Default::default(),
1506
+ },
1507
+ span: match kwargs.get(ruby.to_symbol("span")) {
1508
+ Some(v) => Span::try_convert(v).map_err(|e| {
1509
+ magnus::Error::new(
1510
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1511
+ format!("invalid value for `span`: {}", e),
1512
+ )
1513
+ })?,
1514
+ None => Default::default(),
1515
+ },
1196
1516
  })
1197
1517
  }
1198
1518
 
@@ -1397,7 +1717,7 @@ impl Node {
1397
1717
  }
1398
1718
  }
1399
1719
 
1400
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
1720
+ #[derive(Clone, Debug, serde::Serialize)]
1401
1721
  #[serde(default)]
1402
1722
  #[magnus::wrap(class = "TreeSitterLanguagePack::PackConfig")]
1403
1723
  pub struct PackConfig {
@@ -1433,6 +1753,14 @@ impl magnus::TryConvert for PackConfig {
1433
1753
  }
1434
1754
 
1435
1755
  unsafe impl TryConvertOwned for PackConfig {}
1756
+ impl<'de> serde::Deserialize<'de> for PackConfig {
1757
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
1758
+ where
1759
+ D: serde::Deserializer<'de>,
1760
+ {
1761
+ <tree_sitter_language_pack::PackConfig as serde::Deserialize>::deserialize(deserializer).map(Into::into)
1762
+ }
1763
+ }
1436
1764
 
1437
1765
  impl Default for PackConfig {
1438
1766
  fn default() -> Self {
@@ -1447,15 +1775,33 @@ impl PackConfig {
1447
1775
  let (kwargs_opt,) = args.optional;
1448
1776
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
1449
1777
  Ok(Self {
1450
- cache_dir: kwargs
1451
- .get(ruby.to_symbol("cache_dir"))
1452
- .and_then(|v| String::try_convert(v).ok()),
1453
- languages: kwargs
1454
- .get(ruby.to_symbol("languages"))
1455
- .and_then(|v| <Vec<String>>::try_convert(v).ok()),
1456
- groups: kwargs
1457
- .get(ruby.to_symbol("groups"))
1458
- .and_then(|v| <Vec<String>>::try_convert(v).ok()),
1778
+ cache_dir: match kwargs.get(ruby.to_symbol("cache_dir")) {
1779
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
1780
+ magnus::Error::new(
1781
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1782
+ format!("invalid value for `cache_dir`: {}", e),
1783
+ )
1784
+ })?),
1785
+ None => None,
1786
+ },
1787
+ languages: match kwargs.get(ruby.to_symbol("languages")) {
1788
+ Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
1789
+ magnus::Error::new(
1790
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1791
+ format!("invalid value for `languages`: {}", e),
1792
+ )
1793
+ })?),
1794
+ None => None,
1795
+ },
1796
+ groups: match kwargs.get(ruby.to_symbol("groups")) {
1797
+ Some(v) => Some(<Vec<String>>::try_convert(v).map_err(|e| {
1798
+ magnus::Error::new(
1799
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1800
+ format!("invalid value for `groups`: {}", e),
1801
+ )
1802
+ })?),
1803
+ None => None,
1804
+ },
1459
1805
  })
1460
1806
  }
1461
1807
 
@@ -1572,14 +1918,24 @@ impl Point {
1572
1918
  let (kwargs_opt,) = args.optional;
1573
1919
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
1574
1920
  Ok(Self {
1575
- row: kwargs
1576
- .get(ruby.to_symbol("row"))
1577
- .and_then(|v| usize::try_convert(v).ok())
1578
- .unwrap_or_default(),
1579
- column: kwargs
1580
- .get(ruby.to_symbol("column"))
1581
- .and_then(|v| usize::try_convert(v).ok())
1582
- .unwrap_or_default(),
1921
+ row: match kwargs.get(ruby.to_symbol("row")) {
1922
+ Some(v) => usize::try_convert(v).map_err(|e| {
1923
+ magnus::Error::new(
1924
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1925
+ format!("invalid value for `row`: {}", e),
1926
+ )
1927
+ })?,
1928
+ None => Default::default(),
1929
+ },
1930
+ column: match kwargs.get(ruby.to_symbol("column")) {
1931
+ Some(v) => usize::try_convert(v).map_err(|e| {
1932
+ magnus::Error::new(
1933
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
1934
+ format!("invalid value for `column`: {}", e),
1935
+ )
1936
+ })?,
1937
+ None => Default::default(),
1938
+ },
1583
1939
  })
1584
1940
  }
1585
1941
 
@@ -1592,7 +1948,7 @@ impl Point {
1592
1948
  }
1593
1949
  }
1594
1950
 
1595
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
1951
+ #[derive(Clone, Debug, serde::Serialize)]
1596
1952
  #[serde(default)]
1597
1953
  #[magnus::wrap(class = "TreeSitterLanguagePack::ProcessConfig")]
1598
1954
  pub struct ProcessConfig {
@@ -1637,6 +1993,14 @@ impl magnus::TryConvert for ProcessConfig {
1637
1993
  }
1638
1994
 
1639
1995
  unsafe impl TryConvertOwned for ProcessConfig {}
1996
+ impl<'de> serde::Deserialize<'de> for ProcessConfig {
1997
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
1998
+ where
1999
+ D: serde::Deserializer<'de>,
2000
+ {
2001
+ <tree_sitter_language_pack::ProcessConfig as serde::Deserialize>::deserialize(deserializer).map(Into::into)
2002
+ }
2003
+ }
1640
2004
 
1641
2005
  impl Default for ProcessConfig {
1642
2006
  fn default() -> Self {
@@ -1651,51 +2015,114 @@ impl ProcessConfig {
1651
2015
  let (kwargs_opt,) = args.optional;
1652
2016
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
1653
2017
  Ok(Self {
1654
- language: kwargs
1655
- .get(ruby.to_symbol("language"))
1656
- .and_then(|v| String::try_convert(v).ok())
1657
- .unwrap_or("".to_string()),
1658
- structure: kwargs
1659
- .get(ruby.to_symbol("structure"))
1660
- .and_then(|v| bool::try_convert(v).ok())
1661
- .unwrap_or(true),
1662
- imports: kwargs
1663
- .get(ruby.to_symbol("imports"))
1664
- .and_then(|v| bool::try_convert(v).ok())
1665
- .unwrap_or(true),
1666
- exports: kwargs
1667
- .get(ruby.to_symbol("exports"))
1668
- .and_then(|v| bool::try_convert(v).ok())
1669
- .unwrap_or(true),
1670
- comments: kwargs
1671
- .get(ruby.to_symbol("comments"))
1672
- .and_then(|v| bool::try_convert(v).ok())
1673
- .unwrap_or(false),
1674
- docstrings: kwargs
1675
- .get(ruby.to_symbol("docstrings"))
1676
- .and_then(|v| bool::try_convert(v).ok())
1677
- .unwrap_or(false),
1678
- symbols: kwargs
1679
- .get(ruby.to_symbol("symbols"))
1680
- .and_then(|v| bool::try_convert(v).ok())
1681
- .unwrap_or(false),
1682
- diagnostics: kwargs
1683
- .get(ruby.to_symbol("diagnostics"))
1684
- .and_then(|v| bool::try_convert(v).ok())
1685
- .unwrap_or(false),
1686
- chunk_max_size: kwargs
1687
- .get(ruby.to_symbol("chunk_max_size"))
1688
- .and_then(|v| usize::try_convert(v).ok()),
1689
- data_extraction: kwargs
1690
- .get(ruby.to_symbol("data_extraction"))
1691
- .and_then(|v| bool::try_convert(v).ok())
1692
- .unwrap_or(false),
1693
- max_source_bytes: kwargs
1694
- .get(ruby.to_symbol("max_source_bytes"))
1695
- .and_then(|v| usize::try_convert(v).ok()),
1696
- parse_timeout_ms: kwargs
1697
- .get(ruby.to_symbol("parse_timeout_ms"))
1698
- .and_then(|v| u64::try_convert(v).ok()),
2018
+ language: match kwargs.get(ruby.to_symbol("language")) {
2019
+ Some(v) => String::try_convert(v).map_err(|e| {
2020
+ magnus::Error::new(
2021
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2022
+ format!("invalid value for `language`: {}", e),
2023
+ )
2024
+ })?,
2025
+ None => "".to_string(),
2026
+ },
2027
+ structure: match kwargs.get(ruby.to_symbol("structure")) {
2028
+ Some(v) => bool::try_convert(v).map_err(|e| {
2029
+ magnus::Error::new(
2030
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2031
+ format!("invalid value for `structure`: {}", e),
2032
+ )
2033
+ })?,
2034
+ None => true,
2035
+ },
2036
+ imports: match kwargs.get(ruby.to_symbol("imports")) {
2037
+ Some(v) => bool::try_convert(v).map_err(|e| {
2038
+ magnus::Error::new(
2039
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2040
+ format!("invalid value for `imports`: {}", e),
2041
+ )
2042
+ })?,
2043
+ None => true,
2044
+ },
2045
+ exports: match kwargs.get(ruby.to_symbol("exports")) {
2046
+ Some(v) => bool::try_convert(v).map_err(|e| {
2047
+ magnus::Error::new(
2048
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2049
+ format!("invalid value for `exports`: {}", e),
2050
+ )
2051
+ })?,
2052
+ None => true,
2053
+ },
2054
+ comments: match kwargs.get(ruby.to_symbol("comments")) {
2055
+ Some(v) => bool::try_convert(v).map_err(|e| {
2056
+ magnus::Error::new(
2057
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2058
+ format!("invalid value for `comments`: {}", e),
2059
+ )
2060
+ })?,
2061
+ None => false,
2062
+ },
2063
+ docstrings: match kwargs.get(ruby.to_symbol("docstrings")) {
2064
+ Some(v) => bool::try_convert(v).map_err(|e| {
2065
+ magnus::Error::new(
2066
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2067
+ format!("invalid value for `docstrings`: {}", e),
2068
+ )
2069
+ })?,
2070
+ None => false,
2071
+ },
2072
+ symbols: match kwargs.get(ruby.to_symbol("symbols")) {
2073
+ Some(v) => bool::try_convert(v).map_err(|e| {
2074
+ magnus::Error::new(
2075
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2076
+ format!("invalid value for `symbols`: {}", e),
2077
+ )
2078
+ })?,
2079
+ None => false,
2080
+ },
2081
+ diagnostics: match kwargs.get(ruby.to_symbol("diagnostics")) {
2082
+ Some(v) => bool::try_convert(v).map_err(|e| {
2083
+ magnus::Error::new(
2084
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2085
+ format!("invalid value for `diagnostics`: {}", e),
2086
+ )
2087
+ })?,
2088
+ None => false,
2089
+ },
2090
+ chunk_max_size: match kwargs.get(ruby.to_symbol("chunk_max_size")) {
2091
+ Some(v) => Some(usize::try_convert(v).map_err(|e| {
2092
+ magnus::Error::new(
2093
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2094
+ format!("invalid value for `chunk_max_size`: {}", e),
2095
+ )
2096
+ })?),
2097
+ None => None,
2098
+ },
2099
+ data_extraction: match kwargs.get(ruby.to_symbol("data_extraction")) {
2100
+ Some(v) => bool::try_convert(v).map_err(|e| {
2101
+ magnus::Error::new(
2102
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2103
+ format!("invalid value for `data_extraction`: {}", e),
2104
+ )
2105
+ })?,
2106
+ None => false,
2107
+ },
2108
+ max_source_bytes: match kwargs.get(ruby.to_symbol("max_source_bytes")) {
2109
+ Some(v) => Some(usize::try_convert(v).map_err(|e| {
2110
+ magnus::Error::new(
2111
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2112
+ format!("invalid value for `max_source_bytes`: {}", e),
2113
+ )
2114
+ })?),
2115
+ None => None,
2116
+ },
2117
+ parse_timeout_ms: match kwargs.get(ruby.to_symbol("parse_timeout_ms")) {
2118
+ Some(v) => Some(u64::try_convert(v).map_err(|e| {
2119
+ magnus::Error::new(
2120
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2121
+ format!("invalid value for `parse_timeout_ms`: {}", e),
2122
+ )
2123
+ })?),
2124
+ None => None,
2125
+ },
1699
2126
  })
1700
2127
  }
1701
2128
 
@@ -1978,7 +2405,7 @@ impl ProcessConfig {
1978
2405
  }
1979
2406
  }
1980
2407
 
1981
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
2408
+ #[derive(Clone, Debug, serde::Serialize)]
1982
2409
  #[serde(default)]
1983
2410
  #[magnus::wrap(class = "TreeSitterLanguagePack::ProcessResult")]
1984
2411
  pub struct ProcessResult {
@@ -2022,6 +2449,14 @@ impl magnus::TryConvert for ProcessResult {
2022
2449
  }
2023
2450
 
2024
2451
  unsafe impl TryConvertOwned for ProcessResult {}
2452
+ impl<'de> serde::Deserialize<'de> for ProcessResult {
2453
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
2454
+ where
2455
+ D: serde::Deserializer<'de>,
2456
+ {
2457
+ <tree_sitter_language_pack::ProcessResult as serde::Deserialize>::deserialize(deserializer).map(Into::into)
2458
+ }
2459
+ }
2025
2460
 
2026
2461
  impl Default for ProcessResult {
2027
2462
  fn default() -> Self {
@@ -2036,49 +2471,105 @@ impl ProcessResult {
2036
2471
  let (kwargs_opt,) = args.optional;
2037
2472
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
2038
2473
  Ok(Self {
2039
- language: kwargs
2040
- .get(ruby.to_symbol("language"))
2041
- .and_then(|v| String::try_convert(v).ok())
2042
- .unwrap_or_default(),
2043
- metrics: kwargs
2044
- .get(ruby.to_symbol("metrics"))
2045
- .and_then(|v| FileMetrics::try_convert(v).ok())
2046
- .unwrap_or_default(),
2047
- structure: kwargs
2048
- .get(ruby.to_symbol("structure"))
2049
- .and_then(|v| <Vec<StructureItem>>::try_convert(v).ok())
2050
- .unwrap_or_default(),
2051
- imports: kwargs
2052
- .get(ruby.to_symbol("imports"))
2053
- .and_then(|v| <Vec<ImportInfo>>::try_convert(v).ok())
2054
- .unwrap_or_default(),
2055
- exports: kwargs
2056
- .get(ruby.to_symbol("exports"))
2057
- .and_then(|v| <Vec<ExportInfo>>::try_convert(v).ok())
2058
- .unwrap_or_default(),
2059
- comments: kwargs
2060
- .get(ruby.to_symbol("comments"))
2061
- .and_then(|v| <Vec<CommentInfo>>::try_convert(v).ok())
2062
- .unwrap_or_default(),
2063
- docstrings: kwargs
2064
- .get(ruby.to_symbol("docstrings"))
2065
- .and_then(|v| <Vec<DocstringInfo>>::try_convert(v).ok())
2066
- .unwrap_or_default(),
2067
- symbols: kwargs
2068
- .get(ruby.to_symbol("symbols"))
2069
- .and_then(|v| <Vec<SymbolInfo>>::try_convert(v).ok())
2070
- .unwrap_or_default(),
2071
- diagnostics: kwargs
2072
- .get(ruby.to_symbol("diagnostics"))
2073
- .and_then(|v| <Vec<Diagnostic>>::try_convert(v).ok())
2074
- .unwrap_or_default(),
2075
- chunks: kwargs
2076
- .get(ruby.to_symbol("chunks"))
2077
- .and_then(|v| <Vec<CodeChunk>>::try_convert(v).ok())
2078
- .unwrap_or_default(),
2079
- data: kwargs
2080
- .get(ruby.to_symbol("data"))
2081
- .and_then(|v| DataNode::try_convert(v).ok()),
2474
+ language: match kwargs.get(ruby.to_symbol("language")) {
2475
+ Some(v) => String::try_convert(v).map_err(|e| {
2476
+ magnus::Error::new(
2477
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2478
+ format!("invalid value for `language`: {}", e),
2479
+ )
2480
+ })?,
2481
+ None => Default::default(),
2482
+ },
2483
+ metrics: match kwargs.get(ruby.to_symbol("metrics")) {
2484
+ Some(v) => FileMetrics::try_convert(v).map_err(|e| {
2485
+ magnus::Error::new(
2486
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2487
+ format!("invalid value for `metrics`: {}", e),
2488
+ )
2489
+ })?,
2490
+ None => Default::default(),
2491
+ },
2492
+ structure: match kwargs.get(ruby.to_symbol("structure")) {
2493
+ Some(v) => <Vec<StructureItem>>::try_convert(v).map_err(|e| {
2494
+ magnus::Error::new(
2495
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2496
+ format!("invalid value for `structure`: {}", e),
2497
+ )
2498
+ })?,
2499
+ None => Default::default(),
2500
+ },
2501
+ imports: match kwargs.get(ruby.to_symbol("imports")) {
2502
+ Some(v) => <Vec<ImportInfo>>::try_convert(v).map_err(|e| {
2503
+ magnus::Error::new(
2504
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2505
+ format!("invalid value for `imports`: {}", e),
2506
+ )
2507
+ })?,
2508
+ None => Default::default(),
2509
+ },
2510
+ exports: match kwargs.get(ruby.to_symbol("exports")) {
2511
+ Some(v) => <Vec<ExportInfo>>::try_convert(v).map_err(|e| {
2512
+ magnus::Error::new(
2513
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2514
+ format!("invalid value for `exports`: {}", e),
2515
+ )
2516
+ })?,
2517
+ None => Default::default(),
2518
+ },
2519
+ comments: match kwargs.get(ruby.to_symbol("comments")) {
2520
+ Some(v) => <Vec<CommentInfo>>::try_convert(v).map_err(|e| {
2521
+ magnus::Error::new(
2522
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2523
+ format!("invalid value for `comments`: {}", e),
2524
+ )
2525
+ })?,
2526
+ None => Default::default(),
2527
+ },
2528
+ docstrings: match kwargs.get(ruby.to_symbol("docstrings")) {
2529
+ Some(v) => <Vec<DocstringInfo>>::try_convert(v).map_err(|e| {
2530
+ magnus::Error::new(
2531
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2532
+ format!("invalid value for `docstrings`: {}", e),
2533
+ )
2534
+ })?,
2535
+ None => Default::default(),
2536
+ },
2537
+ symbols: match kwargs.get(ruby.to_symbol("symbols")) {
2538
+ Some(v) => <Vec<SymbolInfo>>::try_convert(v).map_err(|e| {
2539
+ magnus::Error::new(
2540
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2541
+ format!("invalid value for `symbols`: {}", e),
2542
+ )
2543
+ })?,
2544
+ None => Default::default(),
2545
+ },
2546
+ diagnostics: match kwargs.get(ruby.to_symbol("diagnostics")) {
2547
+ Some(v) => <Vec<Diagnostic>>::try_convert(v).map_err(|e| {
2548
+ magnus::Error::new(
2549
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2550
+ format!("invalid value for `diagnostics`: {}", e),
2551
+ )
2552
+ })?,
2553
+ None => Default::default(),
2554
+ },
2555
+ chunks: match kwargs.get(ruby.to_symbol("chunks")) {
2556
+ Some(v) => <Vec<CodeChunk>>::try_convert(v).map_err(|e| {
2557
+ magnus::Error::new(
2558
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2559
+ format!("invalid value for `chunks`: {}", e),
2560
+ )
2561
+ })?,
2562
+ None => Default::default(),
2563
+ },
2564
+ data: match kwargs.get(ruby.to_symbol("data")) {
2565
+ Some(v) => Some(DataNode::try_convert(v).map_err(|e| {
2566
+ magnus::Error::new(
2567
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2568
+ format!("invalid value for `data`: {}", e),
2569
+ )
2570
+ })?),
2571
+ None => None,
2572
+ },
2082
2573
  })
2083
2574
  }
2084
2575
 
@@ -2180,30 +2671,60 @@ impl Span {
2180
2671
  let (kwargs_opt,) = args.optional;
2181
2672
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
2182
2673
  Ok(Self {
2183
- start_byte: kwargs
2184
- .get(ruby.to_symbol("start_byte"))
2185
- .and_then(|v| usize::try_convert(v).ok())
2186
- .unwrap_or_default(),
2187
- end_byte: kwargs
2188
- .get(ruby.to_symbol("end_byte"))
2189
- .and_then(|v| usize::try_convert(v).ok())
2190
- .unwrap_or_default(),
2191
- start_line: kwargs
2192
- .get(ruby.to_symbol("start_line"))
2193
- .and_then(|v| usize::try_convert(v).ok())
2194
- .unwrap_or_default(),
2195
- start_column: kwargs
2196
- .get(ruby.to_symbol("start_column"))
2197
- .and_then(|v| usize::try_convert(v).ok())
2198
- .unwrap_or_default(),
2199
- end_line: kwargs
2200
- .get(ruby.to_symbol("end_line"))
2201
- .and_then(|v| usize::try_convert(v).ok())
2202
- .unwrap_or_default(),
2203
- end_column: kwargs
2204
- .get(ruby.to_symbol("end_column"))
2205
- .and_then(|v| usize::try_convert(v).ok())
2206
- .unwrap_or_default(),
2674
+ start_byte: match kwargs.get(ruby.to_symbol("start_byte")) {
2675
+ Some(v) => usize::try_convert(v).map_err(|e| {
2676
+ magnus::Error::new(
2677
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2678
+ format!("invalid value for `start_byte`: {}", e),
2679
+ )
2680
+ })?,
2681
+ None => Default::default(),
2682
+ },
2683
+ end_byte: match kwargs.get(ruby.to_symbol("end_byte")) {
2684
+ Some(v) => usize::try_convert(v).map_err(|e| {
2685
+ magnus::Error::new(
2686
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2687
+ format!("invalid value for `end_byte`: {}", e),
2688
+ )
2689
+ })?,
2690
+ None => Default::default(),
2691
+ },
2692
+ start_line: match kwargs.get(ruby.to_symbol("start_line")) {
2693
+ Some(v) => usize::try_convert(v).map_err(|e| {
2694
+ magnus::Error::new(
2695
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2696
+ format!("invalid value for `start_line`: {}", e),
2697
+ )
2698
+ })?,
2699
+ None => Default::default(),
2700
+ },
2701
+ start_column: match kwargs.get(ruby.to_symbol("start_column")) {
2702
+ Some(v) => usize::try_convert(v).map_err(|e| {
2703
+ magnus::Error::new(
2704
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2705
+ format!("invalid value for `start_column`: {}", e),
2706
+ )
2707
+ })?,
2708
+ None => Default::default(),
2709
+ },
2710
+ end_line: match kwargs.get(ruby.to_symbol("end_line")) {
2711
+ Some(v) => usize::try_convert(v).map_err(|e| {
2712
+ magnus::Error::new(
2713
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2714
+ format!("invalid value for `end_line`: {}", e),
2715
+ )
2716
+ })?,
2717
+ None => Default::default(),
2718
+ },
2719
+ end_column: match kwargs.get(ruby.to_symbol("end_column")) {
2720
+ Some(v) => usize::try_convert(v).map_err(|e| {
2721
+ magnus::Error::new(
2722
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2723
+ format!("invalid value for `end_column`: {}", e),
2724
+ )
2725
+ })?,
2726
+ None => Default::default(),
2727
+ },
2207
2728
  })
2208
2729
  }
2209
2730
 
@@ -2232,7 +2753,7 @@ impl Span {
2232
2753
  }
2233
2754
  }
2234
2755
 
2235
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
2756
+ #[derive(Clone, Debug, serde::Serialize)]
2236
2757
  #[serde(default)]
2237
2758
  #[magnus::wrap(class = "TreeSitterLanguagePack::StructureItem")]
2238
2759
  pub struct StructureItem {
@@ -2274,6 +2795,14 @@ impl magnus::TryConvert for StructureItem {
2274
2795
  }
2275
2796
 
2276
2797
  unsafe impl TryConvertOwned for StructureItem {}
2798
+ impl<'de> serde::Deserialize<'de> for StructureItem {
2799
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
2800
+ where
2801
+ D: serde::Deserializer<'de>,
2802
+ {
2803
+ <tree_sitter_language_pack::StructureItem as serde::Deserialize>::deserialize(deserializer).map(Into::into)
2804
+ }
2805
+ }
2277
2806
 
2278
2807
  impl Default for StructureItem {
2279
2808
  fn default() -> Self {
@@ -2288,37 +2817,87 @@ impl StructureItem {
2288
2817
  let (kwargs_opt,) = args.optional;
2289
2818
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
2290
2819
  Ok(Self {
2291
- kind: kwargs
2292
- .get(ruby.to_symbol("kind"))
2293
- .and_then(|v| StructureKind::try_convert(v).ok())
2294
- .unwrap_or(StructureKind::Function),
2295
- name: kwargs
2296
- .get(ruby.to_symbol("name"))
2297
- .and_then(|v| String::try_convert(v).ok()),
2298
- visibility: kwargs
2299
- .get(ruby.to_symbol("visibility"))
2300
- .and_then(|v| String::try_convert(v).ok()),
2301
- span: kwargs
2302
- .get(ruby.to_symbol("span"))
2303
- .and_then(|v| Span::try_convert(v).ok())
2304
- .unwrap_or_default(),
2305
- children: kwargs
2306
- .get(ruby.to_symbol("children"))
2307
- .and_then(|v| <Vec<StructureItem>>::try_convert(v).ok())
2308
- .unwrap_or_default(),
2309
- decorators: kwargs
2310
- .get(ruby.to_symbol("decorators"))
2311
- .and_then(|v| <Vec<String>>::try_convert(v).ok())
2312
- .unwrap_or_default(),
2313
- doc_comment: kwargs
2314
- .get(ruby.to_symbol("doc_comment"))
2315
- .and_then(|v| String::try_convert(v).ok()),
2316
- signature: kwargs
2317
- .get(ruby.to_symbol("signature"))
2318
- .and_then(|v| String::try_convert(v).ok()),
2319
- body_span: kwargs
2320
- .get(ruby.to_symbol("body_span"))
2321
- .and_then(|v| Span::try_convert(v).ok()),
2820
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
2821
+ Some(v) => StructureKind::try_convert(v).map_err(|e| {
2822
+ magnus::Error::new(
2823
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2824
+ format!("invalid value for `kind`: {}", e),
2825
+ )
2826
+ })?,
2827
+ None => StructureKind::Function,
2828
+ },
2829
+ name: match kwargs.get(ruby.to_symbol("name")) {
2830
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
2831
+ magnus::Error::new(
2832
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2833
+ format!("invalid value for `name`: {}", e),
2834
+ )
2835
+ })?),
2836
+ None => None,
2837
+ },
2838
+ visibility: match kwargs.get(ruby.to_symbol("visibility")) {
2839
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
2840
+ magnus::Error::new(
2841
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2842
+ format!("invalid value for `visibility`: {}", e),
2843
+ )
2844
+ })?),
2845
+ None => None,
2846
+ },
2847
+ span: match kwargs.get(ruby.to_symbol("span")) {
2848
+ Some(v) => Span::try_convert(v).map_err(|e| {
2849
+ magnus::Error::new(
2850
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2851
+ format!("invalid value for `span`: {}", e),
2852
+ )
2853
+ })?,
2854
+ None => Default::default(),
2855
+ },
2856
+ children: match kwargs.get(ruby.to_symbol("children")) {
2857
+ Some(v) => <Vec<StructureItem>>::try_convert(v).map_err(|e| {
2858
+ magnus::Error::new(
2859
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2860
+ format!("invalid value for `children`: {}", e),
2861
+ )
2862
+ })?,
2863
+ None => Default::default(),
2864
+ },
2865
+ decorators: match kwargs.get(ruby.to_symbol("decorators")) {
2866
+ Some(v) => <Vec<String>>::try_convert(v).map_err(|e| {
2867
+ magnus::Error::new(
2868
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2869
+ format!("invalid value for `decorators`: {}", e),
2870
+ )
2871
+ })?,
2872
+ None => Default::default(),
2873
+ },
2874
+ doc_comment: match kwargs.get(ruby.to_symbol("doc_comment")) {
2875
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
2876
+ magnus::Error::new(
2877
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2878
+ format!("invalid value for `doc_comment`: {}", e),
2879
+ )
2880
+ })?),
2881
+ None => None,
2882
+ },
2883
+ signature: match kwargs.get(ruby.to_symbol("signature")) {
2884
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
2885
+ magnus::Error::new(
2886
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2887
+ format!("invalid value for `signature`: {}", e),
2888
+ )
2889
+ })?),
2890
+ None => None,
2891
+ },
2892
+ body_span: match kwargs.get(ruby.to_symbol("body_span")) {
2893
+ Some(v) => Some(Span::try_convert(v).map_err(|e| {
2894
+ magnus::Error::new(
2895
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
2896
+ format!("invalid value for `body_span`: {}", e),
2897
+ )
2898
+ })?),
2899
+ None => None,
2900
+ },
2322
2901
  })
2323
2902
  }
2324
2903
 
@@ -2359,7 +2938,7 @@ impl StructureItem {
2359
2938
  }
2360
2939
  }
2361
2940
 
2362
- #[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
2941
+ #[derive(Clone, Debug, serde::Serialize)]
2363
2942
  #[serde(default)]
2364
2943
  #[magnus::wrap(class = "TreeSitterLanguagePack::SymbolInfo")]
2365
2944
  pub struct SymbolInfo {
@@ -2397,6 +2976,14 @@ impl magnus::TryConvert for SymbolInfo {
2397
2976
  }
2398
2977
 
2399
2978
  unsafe impl TryConvertOwned for SymbolInfo {}
2979
+ impl<'de> serde::Deserialize<'de> for SymbolInfo {
2980
+ fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
2981
+ where
2982
+ D: serde::Deserializer<'de>,
2983
+ {
2984
+ <tree_sitter_language_pack::SymbolInfo as serde::Deserialize>::deserialize(deserializer).map(Into::into)
2985
+ }
2986
+ }
2400
2987
 
2401
2988
  impl Default for SymbolInfo {
2402
2989
  fn default() -> Self {
@@ -2411,24 +2998,51 @@ impl SymbolInfo {
2411
2998
  let (kwargs_opt,) = args.optional;
2412
2999
  let kwargs = kwargs_opt.unwrap_or_else(|| ruby.hash_new());
2413
3000
  Ok(Self {
2414
- name: kwargs
2415
- .get(ruby.to_symbol("name"))
2416
- .and_then(|v| String::try_convert(v).ok())
2417
- .unwrap_or_default(),
2418
- kind: kwargs
2419
- .get(ruby.to_symbol("kind"))
2420
- .and_then(|v| SymbolKind::try_convert(v).ok())
2421
- .unwrap_or(SymbolKind::Variable),
2422
- span: kwargs
2423
- .get(ruby.to_symbol("span"))
2424
- .and_then(|v| Span::try_convert(v).ok())
2425
- .unwrap_or_default(),
2426
- type_annotation: kwargs
2427
- .get(ruby.to_symbol("type_annotation"))
2428
- .and_then(|v| String::try_convert(v).ok()),
2429
- doc: kwargs
2430
- .get(ruby.to_symbol("doc"))
2431
- .and_then(|v| String::try_convert(v).ok()),
3001
+ name: match kwargs.get(ruby.to_symbol("name")) {
3002
+ Some(v) => String::try_convert(v).map_err(|e| {
3003
+ magnus::Error::new(
3004
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
3005
+ format!("invalid value for `name`: {}", e),
3006
+ )
3007
+ })?,
3008
+ None => Default::default(),
3009
+ },
3010
+ kind: match kwargs.get(ruby.to_symbol("kind")) {
3011
+ Some(v) => SymbolKind::try_convert(v).map_err(|e| {
3012
+ magnus::Error::new(
3013
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
3014
+ format!("invalid value for `kind`: {}", e),
3015
+ )
3016
+ })?,
3017
+ None => SymbolKind::Variable,
3018
+ },
3019
+ span: match kwargs.get(ruby.to_symbol("span")) {
3020
+ Some(v) => Span::try_convert(v).map_err(|e| {
3021
+ magnus::Error::new(
3022
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
3023
+ format!("invalid value for `span`: {}", e),
3024
+ )
3025
+ })?,
3026
+ None => Default::default(),
3027
+ },
3028
+ type_annotation: match kwargs.get(ruby.to_symbol("type_annotation")) {
3029
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
3030
+ magnus::Error::new(
3031
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
3032
+ format!("invalid value for `type_annotation`: {}", e),
3033
+ )
3034
+ })?),
3035
+ None => None,
3036
+ },
3037
+ doc: match kwargs.get(ruby.to_symbol("doc")) {
3038
+ Some(v) => Some(String::try_convert(v).map_err(|e| {
3039
+ magnus::Error::new(
3040
+ unsafe { magnus::Ruby::get_unchecked() }.exception_type_error(),
3041
+ format!("invalid value for `doc`: {}", e),
3042
+ )
3043
+ })?),
3044
+ None => None,
3045
+ },
2432
3046
  })
2433
3047
  }
2434
3048
 
@@ -3988,13 +4602,16 @@ fn ruby_init(ruby: &Ruby) -> Result<(), Error> {
3988
4602
 
3989
4603
  let class = module.define_class("DownloadManager", ruby.class_object())?;
3990
4604
 
4605
+ #[cfg(feature = "download")]
3991
4606
  class.define_method("installed_languages", method!(DownloadManager::installed_languages, 0))?;
3992
4607
 
4608
+ #[cfg(feature = "download")]
3993
4609
  class.define_method(
3994
4610
  "download_all_best_effort",
3995
4611
  method!(DownloadManager::download_all_best_effort, 0),
3996
4612
  )?;
3997
4613
 
4614
+ #[cfg(feature = "download")]
3998
4615
  class.define_method("clean_cache", method!(DownloadManager::clean_cache, 0))?;
3999
4616
 
4000
4617
  let class = module.define_class("ExportInfo", ruby.class_object())?;