1#[rustfmt::skip]
3#[doc(hidden)]
4static __BOXOLOGY_CONTRACT_DESCRIPTOR: ::std::sync::LazyLock<
5 ::boxology_contract::ContractDescriptor,
6> = ::std::sync::LazyLock::new(|| {
7 let box_id = ::boxology_contract::BoxId::new("check")
8 .expect("generated box identity is valid");
9 let error = ::boxology_contract::TypeDescriptor::enumeration([
10 ::boxology_contract::VariantDescriptor::new(
11 "Internal",
12 ::boxology_contract::VariantPayload::Unit,
13 None,
14 ),
15 ])
16 .expect("generated error descriptor is valid");
17 let capability = ::boxology_contract::CapabilityDescriptor::new(
18 ::boxology_contract::CapabilityId::new(
19 box_id.clone(),
20 ::boxology_contract::CapabilityName::new("check")
21 .expect("generated capability name is valid"),
22 ),
23 ::boxology_contract::TypeDescriptor::structure([
24 ::boxology_contract::FieldDescriptor::new(
25 "workspace",
26 ::boxology_contract::TypeDescriptor::string(),
27 None,
28 ),
29 ::boxology_contract::FieldDescriptor::new(
30 "base",
31 ::boxology_contract::TypeDescriptor::optional(
32 ::boxology_contract::TypeDescriptor::string(),
33 )
34 .expect("generated optional descriptor is valid"),
35 None,
36 ),
37 ])
38 .expect("generated struct descriptor is valid"),
39 ::boxology_contract::TypeDescriptor::structure([
40 ::boxology_contract::FieldDescriptor::new(
41 "report",
42 ::boxology_contract::TypeDescriptor::optional(
43 ::boxology_contract::TypeDescriptor::structure([
44 ::boxology_contract::FieldDescriptor::new(
45 "steps",
46 ::boxology_contract::TypeDescriptor::list(
47 ::boxology_contract::TypeDescriptor::structure([
48 ::boxology_contract::FieldDescriptor::new(
49 "id",
50 ::boxology_contract::TypeDescriptor::string(),
51 None,
52 ),
53 ::boxology_contract::FieldDescriptor::new(
54 "status",
55 ::boxology_contract::TypeDescriptor::enumeration([
56 ::boxology_contract::VariantDescriptor::new(
57 "Passed",
58 ::boxology_contract::VariantPayload::Unit,
59 None,
60 ),
61 ::boxology_contract::VariantDescriptor::new(
62 "Failed",
63 ::boxology_contract::VariantPayload::Unit,
64 None,
65 ),
66 ::boxology_contract::VariantDescriptor::new(
67 "Skipped",
68 ::boxology_contract::VariantPayload::Unit,
69 None,
70 ),
71 ])
72 .expect("generated enum descriptor is valid"),
73 None,
74 ),
75 ::boxology_contract::FieldDescriptor::new(
76 "reason",
77 ::boxology_contract::TypeDescriptor::optional(
78 ::boxology_contract::TypeDescriptor::string(),
79 )
80 .expect("generated optional descriptor is valid"),
81 None,
82 ),
83 ::boxology_contract::FieldDescriptor::new(
84 "findings",
85 ::boxology_contract::TypeDescriptor::list(
86 ::boxology_contract::TypeDescriptor::structure([
87 ::boxology_contract::FieldDescriptor::new(
88 "kind",
89 ::boxology_contract::TypeDescriptor::string(),
90 None,
91 ),
92 ::boxology_contract::FieldDescriptor::new(
93 "code",
94 ::boxology_contract::TypeDescriptor::string(),
95 None,
96 ),
97 ::boxology_contract::FieldDescriptor::new(
98 "path",
99 ::boxology_contract::TypeDescriptor::string(),
100 None,
101 ),
102 ::boxology_contract::FieldDescriptor::new(
103 "package",
104 ::boxology_contract::TypeDescriptor::optional(
105 ::boxology_contract::TypeDescriptor::string(),
106 )
107 .expect("generated optional descriptor is valid"),
108 None,
109 ),
110 ::boxology_contract::FieldDescriptor::new(
111 "payload",
112 ::boxology_contract::TypeDescriptor::optional(
113 ::boxology_contract::TypeDescriptor::string(),
114 )
115 .expect("generated optional descriptor is valid"),
116 None,
117 ),
118 ::boxology_contract::FieldDescriptor::new(
119 "rule",
120 ::boxology_contract::TypeDescriptor::optional(
121 ::boxology_contract::TypeDescriptor::string(),
122 )
123 .expect("generated optional descriptor is valid"),
124 None,
125 ),
126 ::boxology_contract::FieldDescriptor::new(
127 "rule_source",
128 ::boxology_contract::TypeDescriptor::optional(
129 ::boxology_contract::TypeDescriptor::string(),
130 )
131 .expect("generated optional descriptor is valid"),
132 None,
133 ),
134 ::boxology_contract::FieldDescriptor::new(
135 "span_start_line",
136 ::boxology_contract::TypeDescriptor::optional(
137 ::boxology_contract::TypeDescriptor::u64(),
138 )
139 .expect("generated optional descriptor is valid"),
140 None,
141 ),
142 ::boxology_contract::FieldDescriptor::new(
143 "span_start_column",
144 ::boxology_contract::TypeDescriptor::optional(
145 ::boxology_contract::TypeDescriptor::u64(),
146 )
147 .expect("generated optional descriptor is valid"),
148 None,
149 ),
150 ::boxology_contract::FieldDescriptor::new(
151 "span_end_line",
152 ::boxology_contract::TypeDescriptor::optional(
153 ::boxology_contract::TypeDescriptor::u64(),
154 )
155 .expect("generated optional descriptor is valid"),
156 None,
157 ),
158 ::boxology_contract::FieldDescriptor::new(
159 "span_end_column",
160 ::boxology_contract::TypeDescriptor::optional(
161 ::boxology_contract::TypeDescriptor::u64(),
162 )
163 .expect("generated optional descriptor is valid"),
164 None,
165 ),
166 ::boxology_contract::FieldDescriptor::new(
167 "offending",
168 ::boxology_contract::TypeDescriptor::optional(
169 ::boxology_contract::TypeDescriptor::string(),
170 )
171 .expect("generated optional descriptor is valid"),
172 None,
173 ),
174 ::boxology_contract::FieldDescriptor::new(
175 "class",
176 ::boxology_contract::TypeDescriptor::optional(
177 ::boxology_contract::TypeDescriptor::string(),
178 )
179 .expect("generated optional descriptor is valid"),
180 None,
181 ),
182 ::boxology_contract::FieldDescriptor::new(
183 "condition",
184 ::boxology_contract::TypeDescriptor::optional(
185 ::boxology_contract::TypeDescriptor::string(),
186 )
187 .expect("generated optional descriptor is valid"),
188 None,
189 ),
190 ])
191 .expect("generated struct descriptor is valid"),
192 )
193 .expect("generated list descriptor is valid"),
194 None,
195 ),
196 ::boxology_contract::FieldDescriptor::new(
197 "output",
198 ::boxology_contract::TypeDescriptor::optional(
199 ::boxology_contract::TypeDescriptor::list(
200 ::boxology_contract::TypeDescriptor::u8(),
201 )
202 .expect("generated list descriptor is valid"),
203 )
204 .expect("generated optional descriptor is valid"),
205 None,
206 ),
207 ])
208 .expect("generated struct descriptor is valid"),
209 )
210 .expect("generated list descriptor is valid"),
211 None,
212 ),
213 ::boxology_contract::FieldDescriptor::new(
214 "status",
215 ::boxology_contract::TypeDescriptor::enumeration([
216 ::boxology_contract::VariantDescriptor::new(
217 "Passed",
218 ::boxology_contract::VariantPayload::Unit,
219 None,
220 ),
221 ::boxology_contract::VariantDescriptor::new(
222 "Failed",
223 ::boxology_contract::VariantPayload::Unit,
224 None,
225 ),
226 ])
227 .expect("generated enum descriptor is valid"),
228 None,
229 ),
230 ::boxology_contract::FieldDescriptor::new(
231 "human",
232 ::boxology_contract::TypeDescriptor::list(
233 ::boxology_contract::TypeDescriptor::u8(),
234 )
235 .expect("generated list descriptor is valid"),
236 None,
237 ),
238 ::boxology_contract::FieldDescriptor::new(
239 "json",
240 ::boxology_contract::TypeDescriptor::list(
241 ::boxology_contract::TypeDescriptor::u8(),
242 )
243 .expect("generated list descriptor is valid"),
244 None,
245 ),
246 ])
247 .expect("generated struct descriptor is valid"),
248 )
249 .expect("generated optional descriptor is valid"),
250 None,
251 ),
252 ::boxology_contract::FieldDescriptor::new(
253 "failure",
254 ::boxology_contract::TypeDescriptor::optional(
255 ::boxology_contract::TypeDescriptor::structure([
256 ::boxology_contract::FieldDescriptor::new(
257 "kind",
258 ::boxology_contract::TypeDescriptor::enumeration([
259 ::boxology_contract::VariantDescriptor::new(
260 "Validation",
261 ::boxology_contract::VariantPayload::Unit,
262 None,
263 ),
264 ::boxology_contract::VariantDescriptor::new(
265 "Invocation",
266 ::boxology_contract::VariantPayload::Unit,
267 None,
268 ),
269 ])
270 .expect("generated enum descriptor is valid"),
271 None,
272 ),
273 ::boxology_contract::FieldDescriptor::new(
274 "human",
275 ::boxology_contract::TypeDescriptor::list(
276 ::boxology_contract::TypeDescriptor::u8(),
277 )
278 .expect("generated list descriptor is valid"),
279 None,
280 ),
281 ::boxology_contract::FieldDescriptor::new(
282 "json",
283 ::boxology_contract::TypeDescriptor::list(
284 ::boxology_contract::TypeDescriptor::u8(),
285 )
286 .expect("generated list descriptor is valid"),
287 None,
288 ),
289 ])
290 .expect("generated struct descriptor is valid"),
291 )
292 .expect("generated optional descriptor is valid"),
293 None,
294 ),
295 ])
296 .expect("generated struct descriptor is valid"),
297 error,
298 ::boxology_contract::CapabilityShape::Unary,
299 ::boxology_contract::ExposureLevel::CodeOnly,
300 ::boxology_contract::Idempotency::None,
301 None,
302 );
303 ::boxology_contract::ContractDescriptor::new(
304 box_id,
305 [capability],
306 ::boxology_contract::ContractRevision::new(
307 "sha256:3990c9cd7afa80360c2051526516fafd71ab94890bf27f6aa4e057669f99754d",
308 )
309 .expect("generated contract revision is non-empty"),
310 )
311 .expect("generated contract descriptor is valid")
312});
313#[rustfmt::skip]
314pub fn contract_descriptor() -> &'static ::boxology_contract::ContractDescriptor {
316 &__BOXOLOGY_CONTRACT_DESCRIPTOR
317}
318#[rustfmt::skip]
319use std::future::Future;
320#[rustfmt::skip]
321use std::pin::Pin;
322#[rustfmt::skip]
323use std::sync::{Arc, LazyLock};
324#[rustfmt::skip]
325use ::boxology_contract::{
326 BoxId, CallContext, CallError, CapabilityId, CapabilityName, ContractType,
327 DecodeRole, Detail, ErasedCallTarget, TypeDescriptor,
328};
329#[rustfmt::skip]
330pub trait CheckDispatch: Send + Sync + 'static {
331 fn check<'a>(
332 &'a self,
333 context: CallContext,
334 request: CheckRequest,
335 ) -> Pin<Box<dyn Future<Output = Result<CheckOutcome, CheckError>> + Send + 'a>>;
336}
337#[rustfmt::skip]
338#[derive(Clone)]
339pub struct CheckHandle {
340 target: Arc<dyn ErasedCallTarget>,
341}
342#[rustfmt::skip]
343impl CheckHandle {
344 #[doc(hidden)]
345 pub fn from_erased(target: Arc<dyn ErasedCallTarget>) -> Self {
346 Self { target }
347 }
348 pub async fn check(
349 &self,
350 context: CallContext,
351 request: CheckRequest,
352 ) -> Result<CheckOutcome, CallError<CheckError>> {
353 let input = request
354 .encode()
355 .map_err(|error| conversion_detail("input_encode", error))
356 .map_err(CallError::ContractViolation)?;
357 let output = self
358 .target
359 .call(&CHECK_CHECK, context, input)
360 .await
361 .map_err(|error| error.into_typed::<CheckError>(&CHECK_ERROR_DESCRIPTOR))?;
362 let output = TypeDescriptor::structure([
363 ::boxology_contract::FieldDescriptor::new(
364 "report",
365 TypeDescriptor::optional(
366 TypeDescriptor::structure([
367 ::boxology_contract::FieldDescriptor::new(
368 "steps",
369 TypeDescriptor::list(
370 TypeDescriptor::structure([
371 ::boxology_contract::FieldDescriptor::new(
372 "id",
373 TypeDescriptor::string(),
374 None,
375 ),
376 ::boxology_contract::FieldDescriptor::new(
377 "status",
378 TypeDescriptor::enumeration([
379 ::boxology_contract::VariantDescriptor::new(
380 "Passed",
381 ::boxology_contract::VariantPayload::Unit,
382 None,
383 ),
384 ::boxology_contract::VariantDescriptor::new(
385 "Failed",
386 ::boxology_contract::VariantPayload::Unit,
387 None,
388 ),
389 ::boxology_contract::VariantDescriptor::new(
390 "Skipped",
391 ::boxology_contract::VariantPayload::Unit,
392 None,
393 ),
394 ])
395 .expect("generated enum descriptor is valid"),
396 None,
397 ),
398 ::boxology_contract::FieldDescriptor::new(
399 "reason",
400 TypeDescriptor::optional(TypeDescriptor::string())
401 .expect("generated optional descriptor is valid"),
402 None,
403 ),
404 ::boxology_contract::FieldDescriptor::new(
405 "findings",
406 TypeDescriptor::list(
407 TypeDescriptor::structure([
408 ::boxology_contract::FieldDescriptor::new(
409 "kind",
410 TypeDescriptor::string(),
411 None,
412 ),
413 ::boxology_contract::FieldDescriptor::new(
414 "code",
415 TypeDescriptor::string(),
416 None,
417 ),
418 ::boxology_contract::FieldDescriptor::new(
419 "path",
420 TypeDescriptor::string(),
421 None,
422 ),
423 ::boxology_contract::FieldDescriptor::new(
424 "package",
425 TypeDescriptor::optional(TypeDescriptor::string())
426 .expect("generated optional descriptor is valid"),
427 None,
428 ),
429 ::boxology_contract::FieldDescriptor::new(
430 "payload",
431 TypeDescriptor::optional(TypeDescriptor::string())
432 .expect("generated optional descriptor is valid"),
433 None,
434 ),
435 ::boxology_contract::FieldDescriptor::new(
436 "rule",
437 TypeDescriptor::optional(TypeDescriptor::string())
438 .expect("generated optional descriptor is valid"),
439 None,
440 ),
441 ::boxology_contract::FieldDescriptor::new(
442 "rule_source",
443 TypeDescriptor::optional(TypeDescriptor::string())
444 .expect("generated optional descriptor is valid"),
445 None,
446 ),
447 ::boxology_contract::FieldDescriptor::new(
448 "span_start_line",
449 TypeDescriptor::optional(TypeDescriptor::u64())
450 .expect("generated optional descriptor is valid"),
451 None,
452 ),
453 ::boxology_contract::FieldDescriptor::new(
454 "span_start_column",
455 TypeDescriptor::optional(TypeDescriptor::u64())
456 .expect("generated optional descriptor is valid"),
457 None,
458 ),
459 ::boxology_contract::FieldDescriptor::new(
460 "span_end_line",
461 TypeDescriptor::optional(TypeDescriptor::u64())
462 .expect("generated optional descriptor is valid"),
463 None,
464 ),
465 ::boxology_contract::FieldDescriptor::new(
466 "span_end_column",
467 TypeDescriptor::optional(TypeDescriptor::u64())
468 .expect("generated optional descriptor is valid"),
469 None,
470 ),
471 ::boxology_contract::FieldDescriptor::new(
472 "offending",
473 TypeDescriptor::optional(TypeDescriptor::string())
474 .expect("generated optional descriptor is valid"),
475 None,
476 ),
477 ::boxology_contract::FieldDescriptor::new(
478 "class",
479 TypeDescriptor::optional(TypeDescriptor::string())
480 .expect("generated optional descriptor is valid"),
481 None,
482 ),
483 ::boxology_contract::FieldDescriptor::new(
484 "condition",
485 TypeDescriptor::optional(TypeDescriptor::string())
486 .expect("generated optional descriptor is valid"),
487 None,
488 ),
489 ])
490 .expect("generated struct descriptor is valid"),
491 )
492 .expect("generated list descriptor is valid"),
493 None,
494 ),
495 ::boxology_contract::FieldDescriptor::new(
496 "output",
497 TypeDescriptor::optional(
498 TypeDescriptor::list(TypeDescriptor::u8())
499 .expect("generated list descriptor is valid"),
500 )
501 .expect("generated optional descriptor is valid"),
502 None,
503 ),
504 ])
505 .expect("generated struct descriptor is valid"),
506 )
507 .expect("generated list descriptor is valid"),
508 None,
509 ),
510 ::boxology_contract::FieldDescriptor::new(
511 "status",
512 TypeDescriptor::enumeration([
513 ::boxology_contract::VariantDescriptor::new(
514 "Passed",
515 ::boxology_contract::VariantPayload::Unit,
516 None,
517 ),
518 ::boxology_contract::VariantDescriptor::new(
519 "Failed",
520 ::boxology_contract::VariantPayload::Unit,
521 None,
522 ),
523 ])
524 .expect("generated enum descriptor is valid"),
525 None,
526 ),
527 ::boxology_contract::FieldDescriptor::new(
528 "human",
529 TypeDescriptor::list(TypeDescriptor::u8())
530 .expect("generated list descriptor is valid"),
531 None,
532 ),
533 ::boxology_contract::FieldDescriptor::new(
534 "json",
535 TypeDescriptor::list(TypeDescriptor::u8())
536 .expect("generated list descriptor is valid"),
537 None,
538 ),
539 ])
540 .expect("generated struct descriptor is valid"),
541 )
542 .expect("generated optional descriptor is valid"),
543 None,
544 ),
545 ::boxology_contract::FieldDescriptor::new(
546 "failure",
547 TypeDescriptor::optional(
548 TypeDescriptor::structure([
549 ::boxology_contract::FieldDescriptor::new(
550 "kind",
551 TypeDescriptor::enumeration([
552 ::boxology_contract::VariantDescriptor::new(
553 "Validation",
554 ::boxology_contract::VariantPayload::Unit,
555 None,
556 ),
557 ::boxology_contract::VariantDescriptor::new(
558 "Invocation",
559 ::boxology_contract::VariantPayload::Unit,
560 None,
561 ),
562 ])
563 .expect("generated enum descriptor is valid"),
564 None,
565 ),
566 ::boxology_contract::FieldDescriptor::new(
567 "human",
568 TypeDescriptor::list(TypeDescriptor::u8())
569 .expect("generated list descriptor is valid"),
570 None,
571 ),
572 ::boxology_contract::FieldDescriptor::new(
573 "json",
574 TypeDescriptor::list(TypeDescriptor::u8())
575 .expect("generated list descriptor is valid"),
576 None,
577 ),
578 ])
579 .expect("generated struct descriptor is valid"),
580 )
581 .expect("generated optional descriptor is valid"),
582 None,
583 ),
584 ])
585 .expect("generated struct descriptor is valid")
586 .conform(DecodeRole::ConsumerOutput, output)
587 .map_err(|error| conversion_detail("output_decode", error))
588 .map_err(CallError::InvalidResponse)?;
589 <CheckOutcome as ContractType>::decode(&output)
590 .map_err(|error| conversion_detail("output_decode", error))
591 .map_err(CallError::InvalidResponse)
592 }
593}
594#[rustfmt::skip]
595impl ::boxology_contract::BoxHandle for CheckHandle {
596 fn from_erased(target: Arc<dyn ErasedCallTarget>) -> Self {
597 Self::from_erased(target)
598 }
599}
600#[rustfmt::skip]
601static CHECK_CHECK: LazyLock<CapabilityId> = LazyLock::new(|| {
602 CapabilityId::new(
603 BoxId::new("check").expect("generated box identity is valid"),
604 CapabilityName::new("check").expect("generated capability name is valid"),
605 )
606});
607#[rustfmt::skip]
608static CHECK_ERROR_DESCRIPTOR: LazyLock<TypeDescriptor> = LazyLock::new(|| {
609 TypeDescriptor::enumeration([
610 ::boxology_contract::VariantDescriptor::new(
611 "Internal",
612 ::boxology_contract::VariantPayload::Unit,
613 None,
614 ),
615 ])
616 .expect("generated check error descriptor is valid")
617});
618#[rustfmt::skip]
619fn conversion_detail(code: &'static str, error: impl std::fmt::Display) -> Detail {
620 Detail::new(code).with_message(error.to_string())
621}
622#[rustfmt::skip]
623#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
624pub struct CheckRequest {
625 pub workspace: ::std::string::String,
626 pub base: ::core::option::Option<::std::string::String>,
627}
628#[rustfmt::skip]
629impl ::boxology_contract::ContractType for CheckRequest {
630 fn encode_value(
631 &self,
632 ) -> ::core::result::Result<
633 ::boxology_contract::ContractValue,
634 ::boxology_contract::EncodeError,
635 > {
636 let mut fields = ::std::vec::Vec::new();
637 if let Some(value) = ::boxology_contract::ContractType::encode_field(
638 &self.workspace,
639 )
640 .map_err(|error| {
641 error.under(::boxology_contract::PathSegment::Field("workspace".into()))
642 })?
643 {
644 fields.push(("workspace".into(), value));
645 }
646 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.base)
647 .map_err(|error| {
648 error.under(::boxology_contract::PathSegment::Field("base".into()))
649 })?
650 {
651 fields.push(("base".into(), value));
652 }
653 ::boxology_contract::ContractValue::object(fields)
654 .map_err(|_| unreachable!("validated generated field identities are unique"))
655 }
656 fn decode_value(
657 value: &::boxology_contract::ContractValue,
658 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
659 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
660 return Err(
661 ::boxology_contract::DecodeError::new(
662 ::boxology_contract::DecodeErrorKind::KindMismatch,
663 ),
664 );
665 };
666 for (field, _) in fields.entries() {
667 match field {
668 "workspace" | "base" => {}
669 _ => {
670 return Err(
671 ::boxology_contract::DecodeError::new(
672 ::boxology_contract::DecodeErrorKind::UnknownField(
673 field.into(),
674 ),
675 )
676 .under(::boxology_contract::PathSegment::Field(field.into())),
677 );
678 }
679 }
680 }
681 Ok(Self {
682 workspace: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
683 fields.get("workspace"),
684 )
685 .map_err(|error| {
686 error
687 .under(
688 ::boxology_contract::PathSegment::Field("workspace".into()),
689 )
690 })?,
691 base: <::core::option::Option<
692 ::std::string::String,
693 > as ::boxology_contract::ContractType>::decode_field(fields.get("base"))
694 .map_err(|error| {
695 error.under(::boxology_contract::PathSegment::Field("base".into()))
696 })?,
697 })
698 }
699}
700#[rustfmt::skip]
701#[derive(Debug, Clone, PartialEq, Default)]
702pub enum CheckStatus {
703 #[default]
704 Passed,
705 Failed,
706 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
707}
708#[rustfmt::skip]
709impl ::boxology_contract::ContractType for CheckStatus {
710 fn encode_value(
711 &self,
712 ) -> ::core::result::Result<
713 ::boxology_contract::ContractValue,
714 ::boxology_contract::EncodeError,
715 > {
716 let (tag, payload) = match self {
717 Self::Passed => ("Passed".into(), ::boxology_contract::SlotValue::Null),
718 Self::Failed => ("Failed".into(), ::boxology_contract::SlotValue::Null),
719 Self::Unknown { tag, payload } => {
720 (
721 tag.clone(),
722 ::boxology_contract::SlotValue::Value(
723 ::boxology_contract::ContractValue::opaque(payload.forward()),
724 ),
725 )
726 }
727 };
728 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
729 }
730 fn decode_value(
731 value: &::boxology_contract::ContractValue,
732 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
733 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
734 return Err(
735 ::boxology_contract::DecodeError::new(
736 ::boxology_contract::DecodeErrorKind::KindMismatch,
737 ),
738 );
739 };
740 match tag {
741 "Passed" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
742 Ok(Self::Passed)
743 }
744 "Passed" => {
745 Err(
746 ::boxology_contract::DecodeError::new(
747 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
748 )
749 .under(::boxology_contract::PathSegment::Variant(tag.into())),
750 )
751 }
752 "Failed" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
753 Ok(Self::Failed)
754 }
755 "Failed" => {
756 Err(
757 ::boxology_contract::DecodeError::new(
758 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
759 )
760 .under(::boxology_contract::PathSegment::Variant(tag.into())),
761 )
762 }
763 _ => {
764 match payload {
765 ::boxology_contract::SlotValue::Value(value) => {
766 match value.view() {
767 ::boxology_contract::ValueRef::Opaque(payload) => {
768 Ok(Self::Unknown {
769 tag: tag.into(),
770 payload: payload.forward(),
771 })
772 }
773 _ => {
774 Err(
775 ::boxology_contract::DecodeError::new(
776 ::boxology_contract::DecodeErrorKind::UnknownVariant(
777 tag.into(),
778 ),
779 )
780 .under(
781 ::boxology_contract::PathSegment::Variant(tag.into()),
782 ),
783 )
784 }
785 }
786 }
787 _ => {
788 Err(
789 ::boxology_contract::DecodeError::new(
790 ::boxology_contract::DecodeErrorKind::UnknownVariant(
791 tag.into(),
792 ),
793 )
794 .under(
795 ::boxology_contract::PathSegment::Variant(tag.into()),
796 ),
797 )
798 }
799 }
800 }
801 }
802 }
803}
804#[rustfmt::skip]
805#[derive(Debug, Clone, PartialEq, Default)]
806pub enum CheckStepStatus {
807 #[default]
808 Passed,
809 Failed,
810 Skipped,
811 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
812}
813#[rustfmt::skip]
814impl ::boxology_contract::ContractType for CheckStepStatus {
815 fn encode_value(
816 &self,
817 ) -> ::core::result::Result<
818 ::boxology_contract::ContractValue,
819 ::boxology_contract::EncodeError,
820 > {
821 let (tag, payload) = match self {
822 Self::Passed => ("Passed".into(), ::boxology_contract::SlotValue::Null),
823 Self::Failed => ("Failed".into(), ::boxology_contract::SlotValue::Null),
824 Self::Skipped => ("Skipped".into(), ::boxology_contract::SlotValue::Null),
825 Self::Unknown { tag, payload } => {
826 (
827 tag.clone(),
828 ::boxology_contract::SlotValue::Value(
829 ::boxology_contract::ContractValue::opaque(payload.forward()),
830 ),
831 )
832 }
833 };
834 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
835 }
836 fn decode_value(
837 value: &::boxology_contract::ContractValue,
838 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
839 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
840 return Err(
841 ::boxology_contract::DecodeError::new(
842 ::boxology_contract::DecodeErrorKind::KindMismatch,
843 ),
844 );
845 };
846 match tag {
847 "Passed" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
848 Ok(Self::Passed)
849 }
850 "Passed" => {
851 Err(
852 ::boxology_contract::DecodeError::new(
853 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
854 )
855 .under(::boxology_contract::PathSegment::Variant(tag.into())),
856 )
857 }
858 "Failed" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
859 Ok(Self::Failed)
860 }
861 "Failed" => {
862 Err(
863 ::boxology_contract::DecodeError::new(
864 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
865 )
866 .under(::boxology_contract::PathSegment::Variant(tag.into())),
867 )
868 }
869 "Skipped" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
870 Ok(Self::Skipped)
871 }
872 "Skipped" => {
873 Err(
874 ::boxology_contract::DecodeError::new(
875 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
876 )
877 .under(::boxology_contract::PathSegment::Variant(tag.into())),
878 )
879 }
880 _ => {
881 match payload {
882 ::boxology_contract::SlotValue::Value(value) => {
883 match value.view() {
884 ::boxology_contract::ValueRef::Opaque(payload) => {
885 Ok(Self::Unknown {
886 tag: tag.into(),
887 payload: payload.forward(),
888 })
889 }
890 _ => {
891 Err(
892 ::boxology_contract::DecodeError::new(
893 ::boxology_contract::DecodeErrorKind::UnknownVariant(
894 tag.into(),
895 ),
896 )
897 .under(
898 ::boxology_contract::PathSegment::Variant(tag.into()),
899 ),
900 )
901 }
902 }
903 }
904 _ => {
905 Err(
906 ::boxology_contract::DecodeError::new(
907 ::boxology_contract::DecodeErrorKind::UnknownVariant(
908 tag.into(),
909 ),
910 )
911 .under(
912 ::boxology_contract::PathSegment::Variant(tag.into()),
913 ),
914 )
915 }
916 }
917 }
918 }
919 }
920}
921#[rustfmt::skip]
922#[derive(Debug, Clone, PartialEq, Default)]
923pub enum CheckFailureKind {
924 #[default]
925 Validation,
926 Invocation,
927 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
928}
929#[rustfmt::skip]
930impl ::boxology_contract::ContractType for CheckFailureKind {
931 fn encode_value(
932 &self,
933 ) -> ::core::result::Result<
934 ::boxology_contract::ContractValue,
935 ::boxology_contract::EncodeError,
936 > {
937 let (tag, payload) = match self {
938 Self::Validation => {
939 ("Validation".into(), ::boxology_contract::SlotValue::Null)
940 }
941 Self::Invocation => {
942 ("Invocation".into(), ::boxology_contract::SlotValue::Null)
943 }
944 Self::Unknown { tag, payload } => {
945 (
946 tag.clone(),
947 ::boxology_contract::SlotValue::Value(
948 ::boxology_contract::ContractValue::opaque(payload.forward()),
949 ),
950 )
951 }
952 };
953 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
954 }
955 fn decode_value(
956 value: &::boxology_contract::ContractValue,
957 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
958 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
959 return Err(
960 ::boxology_contract::DecodeError::new(
961 ::boxology_contract::DecodeErrorKind::KindMismatch,
962 ),
963 );
964 };
965 match tag {
966 "Validation" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
967 Ok(Self::Validation)
968 }
969 "Validation" => {
970 Err(
971 ::boxology_contract::DecodeError::new(
972 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
973 )
974 .under(::boxology_contract::PathSegment::Variant(tag.into())),
975 )
976 }
977 "Invocation" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
978 Ok(Self::Invocation)
979 }
980 "Invocation" => {
981 Err(
982 ::boxology_contract::DecodeError::new(
983 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
984 )
985 .under(::boxology_contract::PathSegment::Variant(tag.into())),
986 )
987 }
988 _ => {
989 match payload {
990 ::boxology_contract::SlotValue::Value(value) => {
991 match value.view() {
992 ::boxology_contract::ValueRef::Opaque(payload) => {
993 Ok(Self::Unknown {
994 tag: tag.into(),
995 payload: payload.forward(),
996 })
997 }
998 _ => {
999 Err(
1000 ::boxology_contract::DecodeError::new(
1001 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1002 tag.into(),
1003 ),
1004 )
1005 .under(
1006 ::boxology_contract::PathSegment::Variant(tag.into()),
1007 ),
1008 )
1009 }
1010 }
1011 }
1012 _ => {
1013 Err(
1014 ::boxology_contract::DecodeError::new(
1015 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1016 tag.into(),
1017 ),
1018 )
1019 .under(
1020 ::boxology_contract::PathSegment::Variant(tag.into()),
1021 ),
1022 )
1023 }
1024 }
1025 }
1026 }
1027 }
1028}
1029#[rustfmt::skip]
1030#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Default)]
1031pub struct CheckFinding {
1032 pub kind: ::std::string::String,
1033 pub code: ::std::string::String,
1034 pub path: ::std::string::String,
1035 pub package: ::core::option::Option<::std::string::String>,
1036 pub payload: ::core::option::Option<::std::string::String>,
1037 pub rule: ::core::option::Option<::std::string::String>,
1038 pub rule_source: ::core::option::Option<::std::string::String>,
1039 pub span_start_line: ::core::option::Option<u64>,
1040 pub span_start_column: ::core::option::Option<u64>,
1041 pub span_end_line: ::core::option::Option<u64>,
1042 pub span_end_column: ::core::option::Option<u64>,
1043 pub offending: ::core::option::Option<::std::string::String>,
1044 pub class: ::core::option::Option<::std::string::String>,
1045 pub condition: ::core::option::Option<::std::string::String>,
1046}
1047#[rustfmt::skip]
1048impl ::boxology_contract::ContractType for CheckFinding {
1049 fn encode_value(
1050 &self,
1051 ) -> ::core::result::Result<
1052 ::boxology_contract::ContractValue,
1053 ::boxology_contract::EncodeError,
1054 > {
1055 let mut fields = ::std::vec::Vec::new();
1056 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.kind)
1057 .map_err(|error| {
1058 error.under(::boxology_contract::PathSegment::Field("kind".into()))
1059 })?
1060 {
1061 fields.push(("kind".into(), value));
1062 }
1063 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.code)
1064 .map_err(|error| {
1065 error.under(::boxology_contract::PathSegment::Field("code".into()))
1066 })?
1067 {
1068 fields.push(("code".into(), value));
1069 }
1070 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.path)
1071 .map_err(|error| {
1072 error.under(::boxology_contract::PathSegment::Field("path".into()))
1073 })?
1074 {
1075 fields.push(("path".into(), value));
1076 }
1077 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1078 &self.package,
1079 )
1080 .map_err(|error| {
1081 error.under(::boxology_contract::PathSegment::Field("package".into()))
1082 })?
1083 {
1084 fields.push(("package".into(), value));
1085 }
1086 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1087 &self.payload,
1088 )
1089 .map_err(|error| {
1090 error.under(::boxology_contract::PathSegment::Field("payload".into()))
1091 })?
1092 {
1093 fields.push(("payload".into(), value));
1094 }
1095 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.rule)
1096 .map_err(|error| {
1097 error.under(::boxology_contract::PathSegment::Field("rule".into()))
1098 })?
1099 {
1100 fields.push(("rule".into(), value));
1101 }
1102 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1103 &self.rule_source,
1104 )
1105 .map_err(|error| {
1106 error
1107 .under(::boxology_contract::PathSegment::Field("rule_source".into()))
1108 })?
1109 {
1110 fields.push(("rule_source".into(), value));
1111 }
1112 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1113 &self.span_start_line,
1114 )
1115 .map_err(|error| {
1116 error
1117 .under(
1118 ::boxology_contract::PathSegment::Field("span_start_line".into()),
1119 )
1120 })?
1121 {
1122 fields.push(("span_start_line".into(), value));
1123 }
1124 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1125 &self.span_start_column,
1126 )
1127 .map_err(|error| {
1128 error
1129 .under(
1130 ::boxology_contract::PathSegment::Field(
1131 "span_start_column".into(),
1132 ),
1133 )
1134 })?
1135 {
1136 fields.push(("span_start_column".into(), value));
1137 }
1138 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1139 &self.span_end_line,
1140 )
1141 .map_err(|error| {
1142 error
1143 .under(
1144 ::boxology_contract::PathSegment::Field("span_end_line".into()),
1145 )
1146 })?
1147 {
1148 fields.push(("span_end_line".into(), value));
1149 }
1150 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1151 &self.span_end_column,
1152 )
1153 .map_err(|error| {
1154 error
1155 .under(
1156 ::boxology_contract::PathSegment::Field("span_end_column".into()),
1157 )
1158 })?
1159 {
1160 fields.push(("span_end_column".into(), value));
1161 }
1162 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1163 &self.offending,
1164 )
1165 .map_err(|error| {
1166 error.under(::boxology_contract::PathSegment::Field("offending".into()))
1167 })?
1168 {
1169 fields.push(("offending".into(), value));
1170 }
1171 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.class)
1172 .map_err(|error| {
1173 error.under(::boxology_contract::PathSegment::Field("class".into()))
1174 })?
1175 {
1176 fields.push(("class".into(), value));
1177 }
1178 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1179 &self.condition,
1180 )
1181 .map_err(|error| {
1182 error.under(::boxology_contract::PathSegment::Field("condition".into()))
1183 })?
1184 {
1185 fields.push(("condition".into(), value));
1186 }
1187 ::boxology_contract::ContractValue::object(fields)
1188 .map_err(|_| unreachable!("validated generated field identities are unique"))
1189 }
1190 fn decode_value(
1191 value: &::boxology_contract::ContractValue,
1192 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1193 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1194 return Err(
1195 ::boxology_contract::DecodeError::new(
1196 ::boxology_contract::DecodeErrorKind::KindMismatch,
1197 ),
1198 );
1199 };
1200 for (field, _) in fields.entries() {
1201 match field {
1202 "kind" | "code" | "path" | "package" | "payload" | "rule" | "rule_source"
1203 | "span_start_line" | "span_start_column" | "span_end_line"
1204 | "span_end_column" | "offending" | "class" | "condition" => {}
1205 _ => {
1206 return Err(
1207 ::boxology_contract::DecodeError::new(
1208 ::boxology_contract::DecodeErrorKind::UnknownField(
1209 field.into(),
1210 ),
1211 )
1212 .under(::boxology_contract::PathSegment::Field(field.into())),
1213 );
1214 }
1215 }
1216 }
1217 Ok(Self {
1218 kind: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1219 fields.get("kind"),
1220 )
1221 .map_err(|error| {
1222 error.under(::boxology_contract::PathSegment::Field("kind".into()))
1223 })?,
1224 code: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1225 fields.get("code"),
1226 )
1227 .map_err(|error| {
1228 error.under(::boxology_contract::PathSegment::Field("code".into()))
1229 })?,
1230 path: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1231 fields.get("path"),
1232 )
1233 .map_err(|error| {
1234 error.under(::boxology_contract::PathSegment::Field("path".into()))
1235 })?,
1236 package: <::core::option::Option<
1237 ::std::string::String,
1238 > as ::boxology_contract::ContractType>::decode_field(fields.get("package"))
1239 .map_err(|error| {
1240 error
1241 .under(::boxology_contract::PathSegment::Field("package".into()))
1242 })?,
1243 payload: <::core::option::Option<
1244 ::std::string::String,
1245 > as ::boxology_contract::ContractType>::decode_field(fields.get("payload"))
1246 .map_err(|error| {
1247 error
1248 .under(::boxology_contract::PathSegment::Field("payload".into()))
1249 })?,
1250 rule: <::core::option::Option<
1251 ::std::string::String,
1252 > as ::boxology_contract::ContractType>::decode_field(fields.get("rule"))
1253 .map_err(|error| {
1254 error.under(::boxology_contract::PathSegment::Field("rule".into()))
1255 })?,
1256 rule_source: <::core::option::Option<
1257 ::std::string::String,
1258 > as ::boxology_contract::ContractType>::decode_field(
1259 fields.get("rule_source"),
1260 )
1261 .map_err(|error| {
1262 error
1263 .under(
1264 ::boxology_contract::PathSegment::Field("rule_source".into()),
1265 )
1266 })?,
1267 span_start_line: <::core::option::Option<
1268 u64,
1269 > as ::boxology_contract::ContractType>::decode_field(
1270 fields.get("span_start_line"),
1271 )
1272 .map_err(|error| {
1273 error
1274 .under(
1275 ::boxology_contract::PathSegment::Field(
1276 "span_start_line".into(),
1277 ),
1278 )
1279 })?,
1280 span_start_column: <::core::option::Option<
1281 u64,
1282 > as ::boxology_contract::ContractType>::decode_field(
1283 fields.get("span_start_column"),
1284 )
1285 .map_err(|error| {
1286 error
1287 .under(
1288 ::boxology_contract::PathSegment::Field(
1289 "span_start_column".into(),
1290 ),
1291 )
1292 })?,
1293 span_end_line: <::core::option::Option<
1294 u64,
1295 > as ::boxology_contract::ContractType>::decode_field(
1296 fields.get("span_end_line"),
1297 )
1298 .map_err(|error| {
1299 error
1300 .under(
1301 ::boxology_contract::PathSegment::Field(
1302 "span_end_line".into(),
1303 ),
1304 )
1305 })?,
1306 span_end_column: <::core::option::Option<
1307 u64,
1308 > as ::boxology_contract::ContractType>::decode_field(
1309 fields.get("span_end_column"),
1310 )
1311 .map_err(|error| {
1312 error
1313 .under(
1314 ::boxology_contract::PathSegment::Field(
1315 "span_end_column".into(),
1316 ),
1317 )
1318 })?,
1319 offending: <::core::option::Option<
1320 ::std::string::String,
1321 > as ::boxology_contract::ContractType>::decode_field(
1322 fields.get("offending"),
1323 )
1324 .map_err(|error| {
1325 error
1326 .under(
1327 ::boxology_contract::PathSegment::Field("offending".into()),
1328 )
1329 })?,
1330 class: <::core::option::Option<
1331 ::std::string::String,
1332 > as ::boxology_contract::ContractType>::decode_field(fields.get("class"))
1333 .map_err(|error| {
1334 error.under(::boxology_contract::PathSegment::Field("class".into()))
1335 })?,
1336 condition: <::core::option::Option<
1337 ::std::string::String,
1338 > as ::boxology_contract::ContractType>::decode_field(
1339 fields.get("condition"),
1340 )
1341 .map_err(|error| {
1342 error
1343 .under(
1344 ::boxology_contract::PathSegment::Field("condition".into()),
1345 )
1346 })?,
1347 })
1348 }
1349}
1350#[rustfmt::skip]
1351#[derive(Debug, Clone, PartialEq, Default)]
1352pub struct CheckStepReport {
1353 pub id: ::std::string::String,
1354 pub status: CheckStepStatus,
1355 pub reason: ::core::option::Option<::std::string::String>,
1356 pub findings: ::std::vec::Vec<CheckFinding>,
1357 pub output: ::core::option::Option<::std::vec::Vec<u8>>,
1358}
1359#[rustfmt::skip]
1360impl ::boxology_contract::ContractType for CheckStepReport {
1361 fn encode_value(
1362 &self,
1363 ) -> ::core::result::Result<
1364 ::boxology_contract::ContractValue,
1365 ::boxology_contract::EncodeError,
1366 > {
1367 let mut fields = ::std::vec::Vec::new();
1368 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.id)
1369 .map_err(|error| {
1370 error.under(::boxology_contract::PathSegment::Field("id".into()))
1371 })?
1372 {
1373 fields.push(("id".into(), value));
1374 }
1375 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1376 &self.status,
1377 )
1378 .map_err(|error| {
1379 error.under(::boxology_contract::PathSegment::Field("status".into()))
1380 })?
1381 {
1382 fields.push(("status".into(), value));
1383 }
1384 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1385 &self.reason,
1386 )
1387 .map_err(|error| {
1388 error.under(::boxology_contract::PathSegment::Field("reason".into()))
1389 })?
1390 {
1391 fields.push(("reason".into(), value));
1392 }
1393 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1394 &self.findings,
1395 )
1396 .map_err(|error| {
1397 error.under(::boxology_contract::PathSegment::Field("findings".into()))
1398 })?
1399 {
1400 fields.push(("findings".into(), value));
1401 }
1402 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1403 &self.output,
1404 )
1405 .map_err(|error| {
1406 error.under(::boxology_contract::PathSegment::Field("output".into()))
1407 })?
1408 {
1409 fields.push(("output".into(), value));
1410 }
1411 ::boxology_contract::ContractValue::object(fields)
1412 .map_err(|_| unreachable!("validated generated field identities are unique"))
1413 }
1414 fn decode_value(
1415 value: &::boxology_contract::ContractValue,
1416 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1417 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1418 return Err(
1419 ::boxology_contract::DecodeError::new(
1420 ::boxology_contract::DecodeErrorKind::KindMismatch,
1421 ),
1422 );
1423 };
1424 for (field, _) in fields.entries() {
1425 match field {
1426 "id" | "status" | "reason" | "findings" | "output" => {}
1427 _ => {
1428 return Err(
1429 ::boxology_contract::DecodeError::new(
1430 ::boxology_contract::DecodeErrorKind::UnknownField(
1431 field.into(),
1432 ),
1433 )
1434 .under(::boxology_contract::PathSegment::Field(field.into())),
1435 );
1436 }
1437 }
1438 }
1439 Ok(Self {
1440 id: <::std::string::String as ::boxology_contract::ContractType>::decode_field(
1441 fields.get("id"),
1442 )
1443 .map_err(|error| {
1444 error.under(::boxology_contract::PathSegment::Field("id".into()))
1445 })?,
1446 status: <CheckStepStatus as ::boxology_contract::ContractType>::decode_field(
1447 fields.get("status"),
1448 )
1449 .map_err(|error| {
1450 error.under(::boxology_contract::PathSegment::Field("status".into()))
1451 })?,
1452 reason: <::core::option::Option<
1453 ::std::string::String,
1454 > as ::boxology_contract::ContractType>::decode_field(fields.get("reason"))
1455 .map_err(|error| {
1456 error.under(::boxology_contract::PathSegment::Field("reason".into()))
1457 })?,
1458 findings: <::std::vec::Vec<
1459 CheckFinding,
1460 > as ::boxology_contract::ContractType>::decode_field(fields.get("findings"))
1461 .map_err(|error| {
1462 error
1463 .under(
1464 ::boxology_contract::PathSegment::Field("findings".into()),
1465 )
1466 })?,
1467 output: <::core::option::Option<
1468 ::std::vec::Vec<u8>,
1469 > as ::boxology_contract::ContractType>::decode_field(fields.get("output"))
1470 .map_err(|error| {
1471 error.under(::boxology_contract::PathSegment::Field("output".into()))
1472 })?,
1473 })
1474 }
1475}
1476#[rustfmt::skip]
1477#[derive(Debug, Clone, PartialEq, Default)]
1478pub struct CheckReport {
1479 pub steps: ::std::vec::Vec<CheckStepReport>,
1480 pub status: CheckStatus,
1481 pub human: ::std::vec::Vec<u8>,
1482 pub json: ::std::vec::Vec<u8>,
1483}
1484#[rustfmt::skip]
1485impl ::boxology_contract::ContractType for CheckReport {
1486 fn encode_value(
1487 &self,
1488 ) -> ::core::result::Result<
1489 ::boxology_contract::ContractValue,
1490 ::boxology_contract::EncodeError,
1491 > {
1492 let mut fields = ::std::vec::Vec::new();
1493 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.steps)
1494 .map_err(|error| {
1495 error.under(::boxology_contract::PathSegment::Field("steps".into()))
1496 })?
1497 {
1498 fields.push(("steps".into(), value));
1499 }
1500 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1501 &self.status,
1502 )
1503 .map_err(|error| {
1504 error.under(::boxology_contract::PathSegment::Field("status".into()))
1505 })?
1506 {
1507 fields.push(("status".into(), value));
1508 }
1509 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.human)
1510 .map_err(|error| {
1511 error.under(::boxology_contract::PathSegment::Field("human".into()))
1512 })?
1513 {
1514 fields.push(("human".into(), value));
1515 }
1516 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.json)
1517 .map_err(|error| {
1518 error.under(::boxology_contract::PathSegment::Field("json".into()))
1519 })?
1520 {
1521 fields.push(("json".into(), value));
1522 }
1523 ::boxology_contract::ContractValue::object(fields)
1524 .map_err(|_| unreachable!("validated generated field identities are unique"))
1525 }
1526 fn decode_value(
1527 value: &::boxology_contract::ContractValue,
1528 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1529 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1530 return Err(
1531 ::boxology_contract::DecodeError::new(
1532 ::boxology_contract::DecodeErrorKind::KindMismatch,
1533 ),
1534 );
1535 };
1536 for (field, _) in fields.entries() {
1537 match field {
1538 "steps" | "status" | "human" | "json" => {}
1539 _ => {
1540 return Err(
1541 ::boxology_contract::DecodeError::new(
1542 ::boxology_contract::DecodeErrorKind::UnknownField(
1543 field.into(),
1544 ),
1545 )
1546 .under(::boxology_contract::PathSegment::Field(field.into())),
1547 );
1548 }
1549 }
1550 }
1551 Ok(Self {
1552 steps: <::std::vec::Vec<
1553 CheckStepReport,
1554 > as ::boxology_contract::ContractType>::decode_field(fields.get("steps"))
1555 .map_err(|error| {
1556 error.under(::boxology_contract::PathSegment::Field("steps".into()))
1557 })?,
1558 status: <CheckStatus as ::boxology_contract::ContractType>::decode_field(
1559 fields.get("status"),
1560 )
1561 .map_err(|error| {
1562 error.under(::boxology_contract::PathSegment::Field("status".into()))
1563 })?,
1564 human: <::std::vec::Vec<
1565 u8,
1566 > as ::boxology_contract::ContractType>::decode_field(fields.get("human"))
1567 .map_err(|error| {
1568 error.under(::boxology_contract::PathSegment::Field("human".into()))
1569 })?,
1570 json: <::std::vec::Vec<
1571 u8,
1572 > as ::boxology_contract::ContractType>::decode_field(fields.get("json"))
1573 .map_err(|error| {
1574 error.under(::boxology_contract::PathSegment::Field("json".into()))
1575 })?,
1576 })
1577 }
1578}
1579#[rustfmt::skip]
1580#[derive(Debug, Clone, PartialEq, Default)]
1581pub struct CheckFailure {
1582 pub kind: CheckFailureKind,
1583 pub human: ::std::vec::Vec<u8>,
1584 pub json: ::std::vec::Vec<u8>,
1585}
1586#[rustfmt::skip]
1587impl ::boxology_contract::ContractType for CheckFailure {
1588 fn encode_value(
1589 &self,
1590 ) -> ::core::result::Result<
1591 ::boxology_contract::ContractValue,
1592 ::boxology_contract::EncodeError,
1593 > {
1594 let mut fields = ::std::vec::Vec::new();
1595 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.kind)
1596 .map_err(|error| {
1597 error.under(::boxology_contract::PathSegment::Field("kind".into()))
1598 })?
1599 {
1600 fields.push(("kind".into(), value));
1601 }
1602 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.human)
1603 .map_err(|error| {
1604 error.under(::boxology_contract::PathSegment::Field("human".into()))
1605 })?
1606 {
1607 fields.push(("human".into(), value));
1608 }
1609 if let Some(value) = ::boxology_contract::ContractType::encode_field(&self.json)
1610 .map_err(|error| {
1611 error.under(::boxology_contract::PathSegment::Field("json".into()))
1612 })?
1613 {
1614 fields.push(("json".into(), value));
1615 }
1616 ::boxology_contract::ContractValue::object(fields)
1617 .map_err(|_| unreachable!("validated generated field identities are unique"))
1618 }
1619 fn decode_value(
1620 value: &::boxology_contract::ContractValue,
1621 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1622 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1623 return Err(
1624 ::boxology_contract::DecodeError::new(
1625 ::boxology_contract::DecodeErrorKind::KindMismatch,
1626 ),
1627 );
1628 };
1629 for (field, _) in fields.entries() {
1630 match field {
1631 "kind" | "human" | "json" => {}
1632 _ => {
1633 return Err(
1634 ::boxology_contract::DecodeError::new(
1635 ::boxology_contract::DecodeErrorKind::UnknownField(
1636 field.into(),
1637 ),
1638 )
1639 .under(::boxology_contract::PathSegment::Field(field.into())),
1640 );
1641 }
1642 }
1643 }
1644 Ok(Self {
1645 kind: <CheckFailureKind as ::boxology_contract::ContractType>::decode_field(
1646 fields.get("kind"),
1647 )
1648 .map_err(|error| {
1649 error.under(::boxology_contract::PathSegment::Field("kind".into()))
1650 })?,
1651 human: <::std::vec::Vec<
1652 u8,
1653 > as ::boxology_contract::ContractType>::decode_field(fields.get("human"))
1654 .map_err(|error| {
1655 error.under(::boxology_contract::PathSegment::Field("human".into()))
1656 })?,
1657 json: <::std::vec::Vec<
1658 u8,
1659 > as ::boxology_contract::ContractType>::decode_field(fields.get("json"))
1660 .map_err(|error| {
1661 error.under(::boxology_contract::PathSegment::Field("json".into()))
1662 })?,
1663 })
1664 }
1665}
1666#[rustfmt::skip]
1667#[derive(Debug, Clone, PartialEq, Default)]
1668pub struct CheckOutcome {
1669 pub report: ::core::option::Option<CheckReport>,
1670 pub failure: ::core::option::Option<CheckFailure>,
1671}
1672#[rustfmt::skip]
1673impl ::boxology_contract::ContractType for CheckOutcome {
1674 fn encode_value(
1675 &self,
1676 ) -> ::core::result::Result<
1677 ::boxology_contract::ContractValue,
1678 ::boxology_contract::EncodeError,
1679 > {
1680 let mut fields = ::std::vec::Vec::new();
1681 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1682 &self.report,
1683 )
1684 .map_err(|error| {
1685 error.under(::boxology_contract::PathSegment::Field("report".into()))
1686 })?
1687 {
1688 fields.push(("report".into(), value));
1689 }
1690 if let Some(value) = ::boxology_contract::ContractType::encode_field(
1691 &self.failure,
1692 )
1693 .map_err(|error| {
1694 error.under(::boxology_contract::PathSegment::Field("failure".into()))
1695 })?
1696 {
1697 fields.push(("failure".into(), value));
1698 }
1699 ::boxology_contract::ContractValue::object(fields)
1700 .map_err(|_| unreachable!("validated generated field identities are unique"))
1701 }
1702 fn decode_value(
1703 value: &::boxology_contract::ContractValue,
1704 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1705 let ::boxology_contract::ValueRef::Object(fields) = value.view() else {
1706 return Err(
1707 ::boxology_contract::DecodeError::new(
1708 ::boxology_contract::DecodeErrorKind::KindMismatch,
1709 ),
1710 );
1711 };
1712 for (field, _) in fields.entries() {
1713 match field {
1714 "report" | "failure" => {}
1715 _ => {
1716 return Err(
1717 ::boxology_contract::DecodeError::new(
1718 ::boxology_contract::DecodeErrorKind::UnknownField(
1719 field.into(),
1720 ),
1721 )
1722 .under(::boxology_contract::PathSegment::Field(field.into())),
1723 );
1724 }
1725 }
1726 }
1727 Ok(Self {
1728 report: <::core::option::Option<
1729 CheckReport,
1730 > as ::boxology_contract::ContractType>::decode_field(fields.get("report"))
1731 .map_err(|error| {
1732 error.under(::boxology_contract::PathSegment::Field("report".into()))
1733 })?,
1734 failure: <::core::option::Option<
1735 CheckFailure,
1736 > as ::boxology_contract::ContractType>::decode_field(fields.get("failure"))
1737 .map_err(|error| {
1738 error
1739 .under(::boxology_contract::PathSegment::Field("failure".into()))
1740 })?,
1741 })
1742 }
1743}
1744#[rustfmt::skip]
1745#[derive(Debug, Clone, PartialEq, Default)]
1746pub enum CheckError {
1747 #[default]
1748 Internal,
1749 Unknown { tag: ::std::string::String, payload: ::boxology_contract::OpaquePayload },
1750}
1751#[rustfmt::skip]
1752impl ::boxology_contract::ContractType for CheckError {
1753 fn encode_value(
1754 &self,
1755 ) -> ::core::result::Result<
1756 ::boxology_contract::ContractValue,
1757 ::boxology_contract::EncodeError,
1758 > {
1759 let (tag, payload) = match self {
1760 Self::Internal => ("Internal".into(), ::boxology_contract::SlotValue::Null),
1761 Self::Unknown { tag, payload } => {
1762 (
1763 tag.clone(),
1764 ::boxology_contract::SlotValue::Value(
1765 ::boxology_contract::ContractValue::opaque(payload.forward()),
1766 ),
1767 )
1768 }
1769 };
1770 Ok(::boxology_contract::ContractValue::enum_value(tag, payload))
1771 }
1772 fn decode_value(
1773 value: &::boxology_contract::ContractValue,
1774 ) -> ::core::result::Result<Self, ::boxology_contract::DecodeError> {
1775 let ::boxology_contract::ValueRef::Enum { tag, payload } = value.view() else {
1776 return Err(
1777 ::boxology_contract::DecodeError::new(
1778 ::boxology_contract::DecodeErrorKind::KindMismatch,
1779 ),
1780 );
1781 };
1782 match tag {
1783 "Internal" if matches!(payload, ::boxology_contract::SlotValue::Null) => {
1784 Ok(Self::Internal)
1785 }
1786 "Internal" => {
1787 Err(
1788 ::boxology_contract::DecodeError::new(
1789 ::boxology_contract::DecodeErrorKind::UnexpectedPayload,
1790 )
1791 .under(::boxology_contract::PathSegment::Variant(tag.into())),
1792 )
1793 }
1794 _ => {
1795 match payload {
1796 ::boxology_contract::SlotValue::Value(value) => {
1797 match value.view() {
1798 ::boxology_contract::ValueRef::Opaque(payload) => {
1799 Ok(Self::Unknown {
1800 tag: tag.into(),
1801 payload: payload.forward(),
1802 })
1803 }
1804 _ => {
1805 Err(
1806 ::boxology_contract::DecodeError::new(
1807 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1808 tag.into(),
1809 ),
1810 )
1811 .under(
1812 ::boxology_contract::PathSegment::Variant(tag.into()),
1813 ),
1814 )
1815 }
1816 }
1817 }
1818 _ => {
1819 Err(
1820 ::boxology_contract::DecodeError::new(
1821 ::boxology_contract::DecodeErrorKind::UnknownVariant(
1822 tag.into(),
1823 ),
1824 )
1825 .under(
1826 ::boxology_contract::PathSegment::Variant(tag.into()),
1827 ),
1828 )
1829 }
1830 }
1831 }
1832 }
1833 }
1834}
1835#[rustfmt::skip]
1836impl ::boxology_contract::ContractError for CheckError {
1837 fn error_tag(&self) -> &str {
1838 match self {
1839 Self::Internal => "Internal",
1840 Self::Unknown { tag, .. } => tag,
1841 }
1842 }
1843}
1844#[rustfmt::skip]
1845#[cfg(feature = "test-support")]
1846pub mod test_support {
1847 use std::future::{Future, ready};
1848 use std::pin::Pin;
1849 use std::sync::Arc;
1850 use ::boxology_contract::{
1851 CallContext, CapabilityId, ContractType, DecodeRole, Detail, ErasedCallError,
1852 ErasedCallTarget, SlotValue, TypeDescriptor,
1853 };
1854 use super::{CheckError, CHECK_CHECK, CheckHandle, conversion_detail};
1855 type CheckFuture = Pin<
1856 Box<
1857 dyn Future<Output = Result<super::CheckOutcome, CheckError>> + Send + 'static,
1858 >,
1859 >;
1860 type CheckResponder = dyn Fn(
1861 CallContext,
1862 super::CheckRequest,
1863 ) -> CheckFuture + Send + Sync + 'static;
1864 #[derive(Clone, Default)]
1865 pub struct CheckFake {
1866 check: Option<Arc<CheckResponder>>,
1867 }
1868 impl CheckFake {
1869 pub fn new() -> Self {
1870 Self::default()
1871 }
1872 pub fn with_check<F, Fut>(mut self, responder: F) -> Self
1873 where
1874 F: Fn(CallContext, super::CheckRequest) -> Fut + Send + Sync + 'static,
1875 Fut: Future<Output = Result<super::CheckOutcome, CheckError>> + Send
1876 + 'static,
1877 {
1878 self.check = Some(
1879 Arc::new(move |context, request| {
1880 Box::pin(responder(context, request))
1881 }),
1882 );
1883 self
1884 }
1885 pub fn handle(&self) -> CheckHandle {
1886 CheckHandle::from_erased(Arc::new(self.clone()))
1887 }
1888 }
1889 impl ErasedCallTarget for CheckFake {
1890 fn call<'a>(
1891 &'a self,
1892 capability: &'a CapabilityId,
1893 context: CallContext,
1894 input: SlotValue,
1895 ) -> Pin<
1896 Box<dyn Future<Output = Result<SlotValue, ErasedCallError>> + Send + 'a>,
1897 > {
1898 if capability != &*CHECK_CHECK {
1899 return Box::pin(ready(Err(unprogrammed())));
1900 }
1901 let Some(responder) = self.check.clone() else {
1902 return Box::pin(ready(Err(unprogrammed())));
1903 };
1904 Box::pin(async move {
1905 let input = TypeDescriptor::structure([
1906 ::boxology_contract::FieldDescriptor::new(
1907 "workspace",
1908 TypeDescriptor::string(),
1909 None,
1910 ),
1911 ::boxology_contract::FieldDescriptor::new(
1912 "base",
1913 TypeDescriptor::optional(TypeDescriptor::string())
1914 .expect("generated optional descriptor is valid"),
1915 None,
1916 ),
1917 ])
1918 .expect("generated struct descriptor is valid")
1919 .conform(DecodeRole::ProviderInput, input)
1920 .map_err(|error| {
1921 ErasedCallError::ContractViolation(
1922 conversion_detail("input_decode", error),
1923 )
1924 })?;
1925 let request = <super::CheckRequest as ContractType>::decode(&input)
1926 .map_err(|error| {
1927 ErasedCallError::ContractViolation(
1928 conversion_detail("input_decode", error),
1929 )
1930 })?;
1931 match responder(context, request).await {
1932 Ok(output) => {
1933 output
1934 .encode()
1935 .map_err(|error| {
1936 ErasedCallError::InvalidResponse(
1937 conversion_detail("output_encode", error),
1938 )
1939 })
1940 }
1941 Err(error) => Err(ErasedCallError::from_domain(&error)),
1942 }
1943 })
1944 }
1945 }
1946 fn unprogrammed() -> ErasedCallError {
1947 ErasedCallError::Internal(Detail::new("unprogrammed_capability"))
1948 }
1949}
1950#[rustfmt::skip]
1951#[doc(hidden)]
1952pub const __BOXOLOGY_SEMANTIC_DIGEST: [u8; 32] = [
1953 2, 77, 0, 140, 120, 151, 105, 218, 107, 123, 130, 202, 34, 9, 233, 42, 222, 179, 217,
1954 54, 168, 241, 90, 245, 73, 49, 119, 39, 144, 105, 131, 72,
1955];
1956#[rustfmt::skip]
1957#[doc(hidden)]
1958#[macro_export]
1959macro_rules! __boxology_check_implementation {
1960 ($receiver:ty; $($method:ident $validity:ident;)*) => {
1961 $crate::__boxology_check_implementation!(@ find $receiver; $($method
1962 $validity;)*);
1963 };
1964 (@ find $receiver:ty; check valid; $($rest:tt)*) => {
1965 const _ : () = { fn require_service < T : ::core::marker::Send +
1966 ::core::marker::Sync + 'static > () {} fn require_future < F :
1967 ::core::future::Future < Output = ::core::result::Result <$crate::CheckOutcome,
1968 $crate::CheckError >> + ::core::marker::Send > (_ : F) {} fn check(receiver :
1969 &$receiver, context : ::boxology::CallContext, input : $crate::CheckRequest) {
1970 require_service::<$receiver > (); require_future(receiver.check(context, input));
1971 } }; impl $crate::CheckDispatch for $receiver { fn check <'a > (&'a self, context
1972 : ::boxology::CallContext, input : $crate::CheckRequest,) -> ::std::pin::Pin <
1973 ::std::boxed::Box < dyn ::core::future::Future < Output = ::core::result::Result
1974 < $crate::CheckOutcome, $crate::CheckError, >, > + ::core::marker::Send + 'a, >,
1975 > { ::std::boxed::Box::pin(self.check(context, input)) } }
1976 };
1977 (@ find $receiver:ty; check invalid; $($rest:tt)*) => {
1978 compile_error!("Boxology capability has an invalid structural signature");
1979 };
1980 (@ find $receiver:ty; $other:ident $validity:ident; $($rest:tt)*) => {
1981 $crate::__boxology_check_implementation!(@ find $receiver; $($rest)*);
1982 };
1983 (@ find $receiver:ty;) => {
1984 compile_error!("Boxology capability implementation is missing");
1985 };
1986}