Skip to content

Commit 7908c13

Browse files
hyperpolymathhyperpolymath
committed
chore: M5 CI/Workflow Sweep - final synchronisation
1 parent 7c266cc commit 7908c13

5 files changed

Lines changed: 95 additions & 95 deletions

File tree

‎ffi/zig/src/main.zig‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
// {{PROJECT}} FFI Implementation
1+
// CONATIVE_GATING FFI Implementation
22
//
33
// This module implements the C-compatible FFI declared in src/abi/Foreign.idr
44
// All types and layouts must match the Idris2 ABI definitions.
@@ -9,7 +9,7 @@ const std = @import("std");
99

1010
// Version information (keep in sync with project)
1111
const VERSION = "0.1.0";
12-
const BUILD_INFO = "{{PROJECT}} built with Zig " ++ @import("builtin").zig_version_string;
12+
const BUILD_INFO = "CONATIVE_GATING built with Zig " ++ @import("builtin").zig_version_string;
1313

1414
/// Thread-local error storage
1515
threadlocal var last_error: ?[]const u8 = null;
@@ -51,7 +51,7 @@ pub const Handle = opaque {
5151

5252
/// Initialize the library
5353
/// Returns a handle, or null on failure
54-
export fn {{project}}_init() ?*Handle {
54+
export fn conative_gating_init() ?*Handle {
5555
const allocator = std.heap.c_allocator;
5656

5757
const handle = allocator.create(Handle) catch {
@@ -70,7 +70,7 @@ export fn {{project}}_init() ?*Handle {
7070
}
7171

7272
/// Free the library handle
73-
export fn {{project}}_free(handle: ?*Handle) void {
73+
export fn conative_gating_free(handle: ?*Handle) void {
7474
const h = handle orelse return;
7575
const allocator = h.allocator;
7676

@@ -86,7 +86,7 @@ export fn {{project}}_free(handle: ?*Handle) void {
8686
//==============================================================================
8787

8888
/// Process data (example operation)
89-
export fn {{project}}_process(handle: ?*Handle, input: u32) Result {
89+
export fn conative_gating_process(handle: ?*Handle, input: u32) Result {
9090
const h = handle orelse {
9191
setError("Null handle");
9292
return .null_pointer;
@@ -110,7 +110,7 @@ export fn {{project}}_process(handle: ?*Handle, input: u32) Result {
110110

111111
/// Get a string result (example)
112112
/// Caller must free the returned string
113-
export fn {{project}}_get_string(handle: ?*Handle) ?[*:0]const u8 {
113+
export fn conative_gating_get_string(handle: ?*Handle) ?[*:0]const u8 {
114114
const h = handle orelse {
115115
setError("Null handle");
116116
return null;
@@ -132,7 +132,7 @@ export fn {{project}}_get_string(handle: ?*Handle) ?[*:0]const u8 {
132132
}
133133

134134
/// Free a string allocated by the library
135-
export fn {{project}}_free_string(str: ?[*:0]const u8) void {
135+
export fn conative_gating_free_string(str: ?[*:0]const u8) void {
136136
const s = str orelse return;
137137
const allocator = std.heap.c_allocator;
138138

@@ -145,7 +145,7 @@ export fn {{project}}_free_string(str: ?[*:0]const u8) void {
145145
//==============================================================================
146146

147147
/// Process an array of data
148-
export fn {{project}}_process_array(
148+
export fn conative_gating_process_array(
149149
handle: ?*Handle,
150150
buffer: ?[*]const u8,
151151
len: u32,
@@ -181,7 +181,7 @@ export fn {{project}}_process_array(
181181

182182
/// Get the last error message
183183
/// Returns null if no error
184-
export fn {{project}}_last_error() ?[*:0]const u8 {
184+
export fn conative_gating_last_error() ?[*:0]const u8 {
185185
const err = last_error orelse return null;
186186

187187
// Return C string (static storage, no need to free)
@@ -195,12 +195,12 @@ export fn {{project}}_last_error() ?[*:0]const u8 {
195195
//==============================================================================
196196

197197
/// Get the library version
198-
export fn {{project}}_version() [*:0]const u8 {
198+
export fn conative_gating_version() [*:0]const u8 {
199199
return VERSION.ptr;
200200
}
201201

202202
/// Get build information
203-
export fn {{project}}_build_info() [*:0]const u8 {
203+
export fn conative_gating_build_info() [*:0]const u8 {
204204
return BUILD_INFO.ptr;
205205
}
206206

@@ -212,7 +212,7 @@ export fn {{project}}_build_info() [*:0]const u8 {
212212
pub const Callback = *const fn (u64, u32) callconv(.C) u32;
213213

214214
/// Register a callback
215-
export fn {{project}}_register_callback(
215+
export fn conative_gating_register_callback(
216216
handle: ?*Handle,
217217
callback: ?Callback,
218218
) Result {
@@ -243,7 +243,7 @@ export fn {{project}}_register_callback(
243243
//==============================================================================
244244

245245
/// Check if handle is initialized
246-
export fn {{project}}_is_initialized(handle: ?*Handle) u32 {
246+
export fn conative_gating_is_initialized(handle: ?*Handle) u32 {
247247
const h = handle orelse return 0;
248248
return if (h.initialized) 1 else 0;
249249
}
@@ -253,22 +253,22 @@ export fn {{project}}_is_initialized(handle: ?*Handle) u32 {
253253
//==============================================================================
254254

255255
test "lifecycle" {
256-
const handle = {{project}}_init() orelse return error.InitFailed;
257-
defer {{project}}_free(handle);
256+
const handle = conative_gating_init() orelse return error.InitFailed;
257+
defer conative_gating_free(handle);
258258

259-
try std.testing.expect({{project}}_is_initialized(handle) == 1);
259+
try std.testing.expect(conative_gating_is_initialized(handle) == 1);
260260
}
261261

262262
test "error handling" {
263-
const result = {{project}}_process(null, 0);
263+
const result = conative_gating_process(null, 0);
264264
try std.testing.expectEqual(Result.null_pointer, result);
265265

266-
const err = {{project}}_last_error();
266+
const err = conative_gating_last_error();
267267
try std.testing.expect(err != null);
268268
}
269269

270270
test "version" {
271-
const ver = {{project}}_version();
271+
const ver = conative_gating_version();
272272
const ver_str = std.mem.span(ver);
273273
try std.testing.expectEqualStrings(VERSION, ver_str);
274274
}

‎src/contract/src/lib.rs‎

Lines changed: 33 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -1539,7 +1539,7 @@ mod tests {
15391539
"fn main() { println!(\"Hello\"); }",
15401540
));
15411541

1542-
let decision = runner.evaluate(&request).unwrap();
1542+
let decision = runner.evaluate(&request).expect("TODO: handle error");
15431543
assert_eq!(decision.verdict, Verdict::Allow);
15441544
assert!(decision.refusal.is_none());
15451545
}
@@ -1552,11 +1552,11 @@ mod tests {
15521552
"export const foo: string = 'bar';",
15531553
));
15541554

1555-
let decision = runner.evaluate(&request).unwrap();
1555+
let decision = runner.evaluate(&request).expect("TODO: handle error");
15561556
assert_eq!(decision.verdict, Verdict::Block);
15571557
assert!(decision.refusal.is_some());
15581558

1559-
let refusal = decision.refusal.unwrap();
1559+
let refusal = decision.refusal.expect("TODO: handle error");
15601560
assert_eq!(refusal.category, RefusalCategory::ForbiddenLanguage);
15611561
assert_eq!(refusal.code, RefusalCode::Lang100TypeScript);
15621562
}
@@ -1569,10 +1569,10 @@ mod tests {
15691569
r#"let password = "supersecret123456""#,
15701570
));
15711571

1572-
let decision = runner.evaluate(&request).unwrap();
1572+
let decision = runner.evaluate(&request).expect("TODO: handle error");
15731573
assert_eq!(decision.verdict, Verdict::Block);
15741574

1575-
let refusal = decision.refusal.unwrap();
1575+
let refusal = decision.refusal.expect("TODO: handle error");
15761576
assert_eq!(refusal.category, RefusalCategory::ForbiddenPattern);
15771577
}
15781578

@@ -1581,7 +1581,7 @@ mod tests {
15811581
let runner = ContractRunner::new();
15821582
let request = GatingRequest::new(create_proposal("src/lib.rs", "pub fn hello() {}"));
15831583

1584-
let decision = runner.evaluate(&request).unwrap();
1584+
let decision = runner.evaluate(&request).expect("TODO: handle error");
15851585
let audit = runner.audit(&request, &decision);
15861586

15871587
assert_eq!(audit.request_id, request.request_id);
@@ -1638,7 +1638,7 @@ mod tests {
16381638
"import os\ndef configure(): pass",
16391639
));
16401640

1641-
let decision = runner.evaluate(&request).unwrap();
1641+
let decision = runner.evaluate(&request).expect("TODO: handle error");
16421642
assert_eq!(decision.verdict, Verdict::Allow);
16431643
}
16441644

@@ -1650,8 +1650,8 @@ mod tests {
16501650
let request1 = GatingRequest::new(create_proposal("a.rs", "fn main() {}"));
16511651
let request2 = GatingRequest::new(create_proposal("b.rs", "fn main() {}"));
16521652

1653-
let decision1 = runner.evaluate(&request1).unwrap();
1654-
let decision2 = runner.evaluate(&request2).unwrap();
1653+
let decision1 = runner.evaluate(&request1).expect("TODO: handle error");
1654+
let decision2 = runner.evaluate(&request2).expect("TODO: handle error");
16551655

16561656
assert_ne!(decision1.decision_id, decision2.decision_id);
16571657
assert_ne!(decision1.request_id, decision2.request_id);
@@ -1693,7 +1693,7 @@ mod tests {
16931693
fn test_contract_runner_default() {
16941694
let runner = ContractRunner::default();
16951695
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
1696-
let decision = runner.evaluate(&request).unwrap();
1696+
let decision = runner.evaluate(&request).expect("TODO: handle error");
16971697
assert_eq!(decision.verdict, Verdict::Allow);
16981698
}
16991699

@@ -1721,10 +1721,10 @@ mod tests {
17211721
"const x: string = 'hello';",
17221722
));
17231723

1724-
let decision = runner.evaluate(&request).unwrap();
1724+
let decision = runner.evaluate(&request).expect("TODO: handle error");
17251725
assert!(decision.refusal.is_some());
17261726

1727-
let refusal = decision.refusal.unwrap();
1727+
let refusal = decision.refusal.expect("TODO: handle error");
17281728
assert!(!refusal.evidence.is_empty());
17291729
assert_eq!(refusal.evidence[0].evidence_type, EvidenceType::ContentMarker);
17301730
}
@@ -1737,10 +1737,10 @@ mod tests {
17371737
"import os",
17381738
));
17391739

1740-
let decision = runner.evaluate(&request).unwrap();
1741-
let refusal = decision.refusal.unwrap();
1740+
let decision = runner.evaluate(&request).expect("TODO: handle error");
1741+
let refusal = decision.refusal.expect("TODO: handle error");
17421742
assert!(refusal.remediation.is_some());
1743-
assert!(refusal.remediation.unwrap().contains("only allowed in salt"));
1743+
assert!(refusal.remediation.expect("TODO: handle error").contains("only allowed in salt"));
17441744
}
17451745

17461746
#[test]
@@ -1751,19 +1751,19 @@ mod tests {
17511751
"package main\nfunc main() {}",
17521752
));
17531753

1754-
let decision = runner.evaluate(&request).unwrap();
1755-
let refusal = decision.refusal.unwrap();
1754+
let decision = runner.evaluate(&request).expect("TODO: handle error");
1755+
let refusal = decision.refusal.expect("TODO: handle error");
17561756
assert_eq!(refusal.code, RefusalCode::Lang102Go);
17571757
assert!(refusal.remediation.is_some());
1758-
assert!(refusal.remediation.unwrap().contains("Rust"));
1758+
assert!(refusal.remediation.expect("TODO: handle error").contains("Rust"));
17591759
}
17601760

17611761
#[test]
17621762
fn test_contract_evaluator_records_oracle_stage() {
17631763
let runner = ContractRunner::new();
17641764
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
17651765

1766-
let decision = runner.evaluate(&request).unwrap();
1766+
let decision = runner.evaluate(&request).expect("TODO: handle error");
17671767
assert!(decision.processing.stages_executed.contains(&"oracle".to_string()));
17681768
assert!(decision.evaluations.oracle.is_some());
17691769
}
@@ -1773,7 +1773,7 @@ mod tests {
17731773
let runner = ContractRunner::new();
17741774
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
17751775

1776-
let decision = runner.evaluate(&request).unwrap();
1776+
let decision = runner.evaluate(&request).expect("TODO: handle error");
17771777
assert!(decision.processing.duration_us > 0);
17781778
}
17791779

@@ -1795,20 +1795,20 @@ mod tests {
17951795
fn test_audit_entry_json_serialization() {
17961796
let runner = ContractRunner::new();
17971797
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
1798-
let decision = runner.evaluate(&request).unwrap();
1798+
let decision = runner.evaluate(&request).expect("TODO: handle error");
17991799
let audit = runner.audit(&request, &decision);
18001800

18011801
let json = audit.to_json();
18021802
assert!(json.is_ok());
1803-
let json_str = json.unwrap();
1803+
let json_str = json.expect("TODO: handle error");
18041804
assert!(json_str.contains("\"verdict\""));
18051805
}
18061806

18071807
#[test]
18081808
fn test_audit_entry_compact_json() {
18091809
let runner = ContractRunner::new();
18101810
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
1811-
let decision = runner.evaluate(&request).unwrap();
1811+
let decision = runner.evaluate(&request).expect("TODO: handle error");
18121812
let audit = runner.audit(&request, &decision);
18131813

18141814
let json = audit.to_json_compact();
@@ -1819,7 +1819,7 @@ mod tests {
18191819
fn test_audit_entry_pretty_json() {
18201820
let runner = ContractRunner::new();
18211821
let request = GatingRequest::new(create_proposal("lib.rs", "pub fn foo() {}"));
1822-
let decision = runner.evaluate(&request).unwrap();
1822+
let decision = runner.evaluate(&request).expect("TODO: handle error");
18231823
let audit = runner.audit(&request, &decision);
18241824

18251825
let json = audit.to_json_pretty();
@@ -1948,7 +1948,7 @@ mod tests {
19481948
let json = baseline.to_json();
19491949
assert!(json.is_ok());
19501950

1951-
let json_str = json.unwrap();
1951+
let json_str = json.expect("TODO: handle error");
19521952
let parsed = RegressionBaseline::from_json(&json_str);
19531953
assert!(parsed.is_ok());
19541954
}
@@ -1980,7 +1980,7 @@ mod tests {
19801980
"defmodule MyModule, do: :ok",
19811981
));
19821982

1983-
let decision = runner.evaluate(&request).unwrap();
1983+
let decision = runner.evaluate(&request).expect("TODO: handle error");
19841984
// Should be allowed as tier1 language
19851985
assert!(matches!(decision.verdict, Verdict::Allow),
19861986
"Elixir should be allowed, got {:?}", decision.verdict);
@@ -1994,7 +1994,7 @@ mod tests {
19941994
"const std = @import(\"std\");\npub fn main() void {}",
19951995
));
19961996

1997-
let decision = runner.evaluate(&request).unwrap();
1997+
let decision = runner.evaluate(&request).expect("TODO: handle error");
19981998
assert_eq!(decision.verdict, Verdict::Allow);
19991999
}
20002000

@@ -2006,7 +2006,7 @@ mod tests {
20062006
"@react.component\nlet make = () => React.string(\"Hello\")",
20072007
));
20082008

2009-
let decision = runner.evaluate(&request).unwrap();
2009+
let decision = runner.evaluate(&request).expect("TODO: handle error");
20102010
assert_eq!(decision.verdict, Verdict::Allow);
20112011
}
20122012

@@ -2018,7 +2018,7 @@ mod tests {
20182018
"procedure Main is\nbegin\n null;\nend Main;",
20192019
));
20202020

2021-
let decision = runner.evaluate(&request).unwrap();
2021+
let decision = runner.evaluate(&request).expect("TODO: handle error");
20222022
assert_eq!(decision.verdict, Verdict::Allow);
20232023
}
20242024

@@ -2030,7 +2030,7 @@ mod tests {
20302030
"module Main where\nmain = putStrLn \"Hello\"",
20312031
));
20322032

2033-
let decision = runner.evaluate(&request).unwrap();
2033+
let decision = runner.evaluate(&request).expect("TODO: handle error");
20342034
assert_eq!(decision.verdict, Verdict::Allow);
20352035
}
20362036

@@ -2042,9 +2042,9 @@ mod tests {
20422042
r#"{"name": "test", "version": "1.0.0"}"#,
20432043
));
20442044

2045-
let decision = runner.evaluate(&request).unwrap();
2045+
let decision = runner.evaluate(&request).expect("TODO: handle error");
20462046
assert_eq!(decision.verdict, Verdict::Block);
2047-
let refusal = decision.refusal.unwrap();
2047+
let refusal = decision.refusal.expect("TODO: handle error");
20482048
assert_eq!(refusal.code, RefusalCode::Tool200NpmWithoutDeno);
20492049
}
20502050

@@ -2057,7 +2057,7 @@ mod tests {
20572057
));
20582058
request.proposal.files_affected.push("deno.json".to_string());
20592059

2060-
let decision = runner.evaluate(&request).unwrap();
2060+
let decision = runner.evaluate(&request).expect("TODO: handle error");
20612061
assert_eq!(decision.verdict, Verdict::Allow);
20622062
}
20632063

0 commit comments

Comments
 (0)