initial code based on zig 0.9.0
This commit is contained in:
parent
1a29a532c9
commit
9a2ce42bbf
GPG Key ID:
A7B62D657EF764F8
21
LICENSE
Normal file
21
LICENSE
Normal file
|
|
@ -0,0 +1,21 @@
|
|||
MIT License
|
||||
|
||||
Copyright (c) 2023 Emil Lerch
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
8
README.md
Normal file
8
README.md
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
AWS Smithy Model for Zig
|
||||
========================
|
||||
|
||||
This holds a smithy project for zig, extracted from the AWS SDK for Zig for
|
||||
use as a package. Built for zig 0.11
|
||||
|
||||
TODO: complete the readme
|
||||
TODO: CI
|
||||
17
build.zig
Normal file
17
build.zig
Normal file
|
|
@ -0,0 +1,17 @@
|
|||
const std = @import("std");
|
||||
|
||||
pub fn build(b: *std.build.Builder) void {
|
||||
// Standard release options allow the person running `zig build` to select
|
||||
// between Debug, ReleaseSafe, ReleaseFast, and ReleaseSmall.
|
||||
const mode = b.standardReleaseOptions();
|
||||
|
||||
const lib = b.addStaticLibrary("smithy", "src/smithy.zig");
|
||||
lib.setBuildMode(mode);
|
||||
lib.install();
|
||||
|
||||
var main_tests = b.addTest("src/smithy.zig");
|
||||
main_tests.setBuildMode(mode);
|
||||
|
||||
const test_step = b.step("test", "Run library tests");
|
||||
test_step.dependOn(&main_tests.step);
|
||||
}
|
||||
802
src/smithy.zig
Normal file
802
src/smithy.zig
Normal file
|
|
@ -0,0 +1,802 @@
|
|||
const std = @import("std");
|
||||
const expect = std.testing.expect;
|
||||
|
||||
// TODO: validate this matches the schema
|
||||
pub const Smithy = struct {
|
||||
version: []const u8,
|
||||
metadata: ModelMetadata,
|
||||
shapes: []ShapeInfo,
|
||||
allocator: std.mem.Allocator,
|
||||
|
||||
const Self = @This();
|
||||
pub fn init(allocator: std.mem.Allocator, version: []const u8, metadata: ModelMetadata, shapeinfo: []ShapeInfo) Smithy {
|
||||
return .{
|
||||
.version = version,
|
||||
.metadata = metadata,
|
||||
.shapes = shapeinfo,
|
||||
.allocator = allocator,
|
||||
};
|
||||
}
|
||||
pub fn deinit(self: Self) void {
|
||||
for (self.shapes) |s| {
|
||||
switch (s.shape) {
|
||||
.string,
|
||||
.byte,
|
||||
.short,
|
||||
.integer,
|
||||
.long,
|
||||
.float,
|
||||
.double,
|
||||
.bigInteger,
|
||||
.bigDecimal,
|
||||
.blob,
|
||||
.boolean,
|
||||
.timestamp,
|
||||
.document,
|
||||
.member,
|
||||
.resource,
|
||||
=> |v| self.allocator.free(v.traits),
|
||||
.structure => |v| {
|
||||
for (v.members) |m| self.allocator.free(m.traits);
|
||||
self.allocator.free(v.members);
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
.uniontype => |v| {
|
||||
for (v.members) |m| self.allocator.free(m.traits);
|
||||
self.allocator.free(v.members);
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
.service => |v| {
|
||||
self.allocator.free(v.traits);
|
||||
self.allocator.free(v.operations);
|
||||
},
|
||||
.operation => |v| {
|
||||
if (v.errors) |e| self.allocator.free(e);
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
.list => |v| {
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
.set => |v| {
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
.map => |v| {
|
||||
self.allocator.free(v.key);
|
||||
self.allocator.free(v.value);
|
||||
self.allocator.free(v.traits);
|
||||
},
|
||||
}
|
||||
}
|
||||
self.allocator.free(self.shapes);
|
||||
}
|
||||
};
|
||||
pub const ShapeInfo = struct {
|
||||
id: []const u8,
|
||||
namespace: []const u8,
|
||||
name: []const u8,
|
||||
member: ?[]const u8,
|
||||
|
||||
shape: Shape,
|
||||
};
|
||||
|
||||
const ModelMetadata = struct {
|
||||
suppressions: []struct {
|
||||
id: []const u8,
|
||||
namespace: []const u8,
|
||||
},
|
||||
};
|
||||
|
||||
pub const TraitType = enum {
|
||||
aws_api_service,
|
||||
aws_auth_sigv4,
|
||||
aws_protocol,
|
||||
ec2_query_name,
|
||||
http,
|
||||
http_header,
|
||||
http_label,
|
||||
http_query,
|
||||
http_payload,
|
||||
json_name,
|
||||
xml_name,
|
||||
required,
|
||||
documentation,
|
||||
pattern,
|
||||
range,
|
||||
length,
|
||||
box,
|
||||
sparse,
|
||||
};
|
||||
pub const Trait = union(TraitType) {
|
||||
aws_api_service: struct {
|
||||
sdk_id: []const u8,
|
||||
arn_namespace: []const u8,
|
||||
cloudformation_name: []const u8,
|
||||
cloudtrail_event_source: []const u8,
|
||||
endpoint_prefix: []const u8,
|
||||
},
|
||||
aws_auth_sigv4: struct {
|
||||
name: []const u8,
|
||||
},
|
||||
aws_protocol: AwsProtocol,
|
||||
ec2_query_name: []const u8,
|
||||
json_name: []const u8,
|
||||
xml_name: []const u8,
|
||||
http: struct {
|
||||
method: []const u8,
|
||||
uri: []const u8,
|
||||
code: i64 = 200,
|
||||
},
|
||||
http_header: []const u8,
|
||||
http_label: []const u8,
|
||||
http_query: []const u8,
|
||||
http_payload: struct {},
|
||||
required: struct {},
|
||||
documentation: []const u8,
|
||||
pattern: []const u8,
|
||||
range: struct { // most data is actually integers, but as some are floats, we'll use that here
|
||||
min: ?f64,
|
||||
max: ?f64,
|
||||
},
|
||||
length: struct {
|
||||
min: ?f64,
|
||||
max: ?f64,
|
||||
},
|
||||
box: struct {},
|
||||
sparse: struct {},
|
||||
};
|
||||
const ShapeType = enum {
|
||||
blob,
|
||||
boolean,
|
||||
string,
|
||||
byte,
|
||||
short,
|
||||
integer,
|
||||
long,
|
||||
float,
|
||||
double,
|
||||
bigInteger,
|
||||
bigDecimal,
|
||||
timestamp,
|
||||
document,
|
||||
member,
|
||||
list,
|
||||
set,
|
||||
map,
|
||||
structure,
|
||||
uniontype,
|
||||
service,
|
||||
operation,
|
||||
resource,
|
||||
};
|
||||
const TraitsOnly = struct {
|
||||
traits: []Trait,
|
||||
};
|
||||
pub const TypeMember = struct {
|
||||
name: []const u8,
|
||||
target: []const u8,
|
||||
traits: []Trait,
|
||||
};
|
||||
const Shape = union(ShapeType) {
|
||||
blob: TraitsOnly,
|
||||
boolean: TraitsOnly,
|
||||
string: TraitsOnly,
|
||||
byte: TraitsOnly,
|
||||
short: TraitsOnly,
|
||||
integer: TraitsOnly,
|
||||
long: TraitsOnly,
|
||||
float: TraitsOnly,
|
||||
double: TraitsOnly,
|
||||
bigInteger: TraitsOnly,
|
||||
bigDecimal: TraitsOnly,
|
||||
timestamp: TraitsOnly,
|
||||
document: TraitsOnly,
|
||||
member: TraitsOnly,
|
||||
list: struct {
|
||||
member_target: []const u8,
|
||||
traits: []Trait,
|
||||
},
|
||||
set: struct {
|
||||
member_target: []const u8,
|
||||
traits: []Trait,
|
||||
},
|
||||
map: struct {
|
||||
key: []const u8,
|
||||
value: []const u8,
|
||||
traits: []Trait,
|
||||
},
|
||||
structure: struct {
|
||||
members: []TypeMember,
|
||||
traits: []Trait,
|
||||
},
|
||||
uniontype: struct {
|
||||
members: []TypeMember,
|
||||
traits: []Trait,
|
||||
},
|
||||
service: struct {
|
||||
version: []const u8,
|
||||
operations: [][]const u8,
|
||||
resources: [][]const u8,
|
||||
traits: []Trait,
|
||||
},
|
||||
operation: struct {
|
||||
input: ?[]const u8,
|
||||
output: ?[]const u8,
|
||||
errors: ?[][]const u8,
|
||||
traits: []Trait,
|
||||
},
|
||||
resource: TraitsOnly,
|
||||
};
|
||||
|
||||
// https://awslabs.github.io/smithy/1.0/spec/aws/index.html
|
||||
pub const AwsProtocol = enum {
|
||||
query,
|
||||
rest_xml,
|
||||
json_1_1,
|
||||
json_1_0,
|
||||
rest_json_1,
|
||||
ec2_query,
|
||||
};
|
||||
|
||||
pub fn parse(allocator: std.mem.Allocator, json_model: []const u8) !Smithy {
|
||||
// construct a parser. We're not copying strings here, but that may
|
||||
// be a poor decision
|
||||
var parser = std.json.Parser.init(allocator, false);
|
||||
defer parser.deinit();
|
||||
var vt = try parser.parse(json_model);
|
||||
defer vt.deinit();
|
||||
return Smithy.init(
|
||||
allocator,
|
||||
vt.root.Object.get("smithy").?.String,
|
||||
ModelMetadata{
|
||||
// TODO: implement
|
||||
.suppressions = &.{},
|
||||
},
|
||||
try shapes(allocator, vt.root.Object.get("shapes").?.Object),
|
||||
);
|
||||
}
|
||||
|
||||
// anytype: HashMap([]const u8, std.json.Value...)
|
||||
// list must be deinitialized by caller
|
||||
fn shapes(allocator: std.mem.Allocator, map: anytype) ![]ShapeInfo {
|
||||
var list = try std.ArrayList(ShapeInfo).initCapacity(allocator, map.count());
|
||||
defer list.deinit();
|
||||
var iterator = map.iterator();
|
||||
while (iterator.next()) |kv| {
|
||||
const id_info = try parseId(kv.key_ptr.*);
|
||||
try list.append(.{
|
||||
.id = id_info.id,
|
||||
.namespace = id_info.namespace,
|
||||
.name = id_info.name,
|
||||
.member = id_info.member,
|
||||
.shape = try getShape(allocator, kv.value_ptr.*),
|
||||
});
|
||||
}
|
||||
// This seems to be a synonym for the simple type "string"
|
||||
// https://awslabs.github.io/smithy/1.0/spec/core/model.html#simple-types
|
||||
// But I don't see it in the spec. We might need to preload other similar
|
||||
// simple types?
|
||||
try list.append(.{
|
||||
.id = "smithy.api#String",
|
||||
.namespace = "smithy.api",
|
||||
.name = "String",
|
||||
.member = null,
|
||||
.shape = Shape{
|
||||
.string = .{
|
||||
.traits = &.{},
|
||||
},
|
||||
},
|
||||
});
|
||||
try list.append(.{
|
||||
.id = "smithy.api#Boolean",
|
||||
.namespace = "smithy.api",
|
||||
.name = "Boolean",
|
||||
.member = null,
|
||||
.shape = Shape{
|
||||
.boolean = .{
|
||||
.traits = &.{},
|
||||
},
|
||||
},
|
||||
});
|
||||
try list.append(.{
|
||||
.id = "smithy.api#Integer",
|
||||
.namespace = "smithy.api",
|
||||
.name = "Integer",
|
||||
.member = null,
|
||||
.shape = Shape{
|
||||
.integer = .{
|
||||
.traits = &.{},
|
||||
},
|
||||
},
|
||||
});
|
||||
try list.append(.{
|
||||
.id = "smithy.api#Double",
|
||||
.namespace = "smithy.api",
|
||||
.name = "Double",
|
||||
.member = null,
|
||||
.shape = Shape{
|
||||
.double = .{
|
||||
.traits = &.{},
|
||||
},
|
||||
},
|
||||
});
|
||||
try list.append(.{
|
||||
.id = "smithy.api#Timestamp",
|
||||
.namespace = "smithy.api",
|
||||
.name = "Timestamp",
|
||||
.member = null,
|
||||
.shape = Shape{
|
||||
.timestamp = .{
|
||||
.traits = &.{},
|
||||
},
|
||||
},
|
||||
});
|
||||
return list.toOwnedSlice();
|
||||
}
|
||||
|
||||
fn getShape(allocator: std.mem.Allocator, shape: std.json.Value) SmithyParseError!Shape {
|
||||
const shape_type = shape.Object.get("type").?.String;
|
||||
if (std.mem.eql(u8, shape_type, "service"))
|
||||
return Shape{
|
||||
.service = .{
|
||||
.version = shape.Object.get("version").?.String,
|
||||
.operations = if (shape.Object.get("operations")) |ops|
|
||||
try parseTargetList(allocator, ops.Array)
|
||||
else
|
||||
&.{}, // this doesn't make much sense, but it's happening
|
||||
// TODO: implement. We need some sample data tho
|
||||
.resources = &.{},
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "structure"))
|
||||
return Shape{
|
||||
.structure = .{
|
||||
.members = try parseMembers(allocator, shape.Object.get("members")),
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "union"))
|
||||
return Shape{
|
||||
.uniontype = .{
|
||||
.members = try parseMembers(allocator, shape.Object.get("members")),
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "operation"))
|
||||
return Shape{
|
||||
.operation = .{
|
||||
.input = if (shape.Object.get("input")) |member| member.Object.get("target").?.String else null,
|
||||
.output = if (shape.Object.get("output")) |member| member.Object.get("target").?.String else null,
|
||||
.errors = blk: {
|
||||
if (shape.Object.get("errors")) |e| {
|
||||
break :blk try parseTargetList(allocator, e.Array);
|
||||
}
|
||||
break :blk null;
|
||||
},
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "list"))
|
||||
return Shape{
|
||||
.list = .{
|
||||
.member_target = shape.Object.get("member").?.Object.get("target").?.String,
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "set"))
|
||||
return Shape{
|
||||
.set = .{
|
||||
.member_target = shape.Object.get("member").?.Object.get("target").?.String,
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "map"))
|
||||
return Shape{
|
||||
.map = .{
|
||||
.key = shape.Object.get("key").?.Object.get("target").?.String,
|
||||
.value = shape.Object.get("value").?.Object.get("target").?.String,
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, shape_type, "string"))
|
||||
return Shape{ .string = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "byte"))
|
||||
return Shape{ .byte = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "short"))
|
||||
return Shape{ .short = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "integer"))
|
||||
return Shape{ .integer = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "long"))
|
||||
return Shape{ .long = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "float"))
|
||||
return Shape{ .float = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "double"))
|
||||
return Shape{ .double = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "bigInteger"))
|
||||
return Shape{ .bigInteger = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "bigDecimal"))
|
||||
return Shape{ .bigDecimal = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "boolean"))
|
||||
return Shape{ .boolean = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "blob"))
|
||||
return Shape{ .blob = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "timestamp"))
|
||||
return Shape{ .timestamp = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "document"))
|
||||
return Shape{ .document = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "member"))
|
||||
return Shape{ .member = try parseTraitsOnly(allocator, shape) };
|
||||
if (std.mem.eql(u8, shape_type, "resource"))
|
||||
return Shape{ .resource = try parseTraitsOnly(allocator, shape) };
|
||||
|
||||
std.debug.print("Invalid Type: {s}", .{shape_type});
|
||||
return SmithyParseError.InvalidType;
|
||||
}
|
||||
|
||||
fn parseMembers(allocator: std.mem.Allocator, shape: ?std.json.Value) SmithyParseError![]TypeMember {
|
||||
var rc: []TypeMember = &.{};
|
||||
if (shape == null)
|
||||
return rc;
|
||||
|
||||
const map = shape.?.Object;
|
||||
var list = std.ArrayList(TypeMember).initCapacity(allocator, map.count()) catch return SmithyParseError.OutOfMemory;
|
||||
defer list.deinit();
|
||||
var iterator = map.iterator();
|
||||
while (iterator.next()) |kv| {
|
||||
try list.append(TypeMember{
|
||||
.name = kv.key_ptr.*,
|
||||
.target = kv.value_ptr.*.Object.get("target").?.String,
|
||||
.traits = try parseTraits(allocator, kv.value_ptr.*.Object.get("traits")),
|
||||
});
|
||||
}
|
||||
return list.toOwnedSlice();
|
||||
}
|
||||
|
||||
// ArrayList of std.Json.Value
|
||||
fn parseTargetList(allocator: std.mem.Allocator, list: anytype) SmithyParseError![][]const u8 {
|
||||
var array_list = std.ArrayList([]const u8).initCapacity(allocator, list.items.len) catch return SmithyParseError.OutOfMemory;
|
||||
defer array_list.deinit();
|
||||
for (list.items) |i| {
|
||||
try array_list.append(i.Object.get("target").?.String);
|
||||
}
|
||||
return array_list.toOwnedSlice();
|
||||
}
|
||||
fn parseTraitsOnly(allocator: std.mem.Allocator, shape: std.json.Value) SmithyParseError!TraitsOnly {
|
||||
return TraitsOnly{
|
||||
.traits = try parseTraits(allocator, shape.Object.get("traits")),
|
||||
};
|
||||
}
|
||||
|
||||
fn parseTraits(allocator: std.mem.Allocator, shape: ?std.json.Value) SmithyParseError![]Trait {
|
||||
var rc: []Trait = &.{};
|
||||
if (shape == null)
|
||||
return rc;
|
||||
|
||||
const map = shape.?.Object;
|
||||
var list = std.ArrayList(Trait).initCapacity(allocator, map.count()) catch return SmithyParseError.OutOfMemory;
|
||||
defer list.deinit();
|
||||
var iterator = map.iterator();
|
||||
while (iterator.next()) |kv| {
|
||||
if (try getTrait(kv.key_ptr.*, kv.value_ptr.*)) |t|
|
||||
try list.append(t);
|
||||
}
|
||||
return list.toOwnedSlice();
|
||||
}
|
||||
|
||||
fn getTrait(trait_type: []const u8, value: std.json.Value) SmithyParseError!?Trait {
|
||||
if (std.mem.eql(u8, trait_type, "aws.api#service"))
|
||||
return Trait{
|
||||
.aws_api_service = .{
|
||||
.sdk_id = value.Object.get("sdkId").?.String,
|
||||
.arn_namespace = value.Object.get("arnNamespace").?.String,
|
||||
.cloudformation_name = value.Object.get("cloudFormationName").?.String,
|
||||
.cloudtrail_event_source = value.Object.get("cloudTrailEventSource").?.String,
|
||||
// what good is a service without an endpoint? I don't know - ask amp
|
||||
.endpoint_prefix = if (value.Object.get("endpointPrefix")) |endpoint| endpoint.String else "",
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.auth#sigv4"))
|
||||
return Trait{
|
||||
.aws_auth_sigv4 = .{
|
||||
.name = value.Object.get("name").?.String,
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#required"))
|
||||
return Trait{ .required = .{} };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#sparse"))
|
||||
return Trait{ .sparse = .{} };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#box"))
|
||||
return Trait{ .box = .{} };
|
||||
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#range"))
|
||||
return Trait{
|
||||
.range = .{
|
||||
.min = getOptionalNumber(value, "min"),
|
||||
.max = getOptionalNumber(value, "max"),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#length"))
|
||||
return Trait{
|
||||
.length = .{
|
||||
.min = getOptionalNumber(value, "min"),
|
||||
.max = getOptionalNumber(value, "max"),
|
||||
},
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#restJson1"))
|
||||
return Trait{
|
||||
.aws_protocol = .rest_json_1,
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#awsJson1_0"))
|
||||
return Trait{
|
||||
.aws_protocol = .json_1_0,
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#awsJson1_1"))
|
||||
return Trait{
|
||||
.aws_protocol = .json_1_1,
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#restXml"))
|
||||
return Trait{
|
||||
.aws_protocol = .rest_xml,
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#awsQuery"))
|
||||
return Trait{
|
||||
.aws_protocol = .query,
|
||||
};
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#ec2Query"))
|
||||
return Trait{
|
||||
.aws_protocol = .ec2_query,
|
||||
};
|
||||
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#documentation"))
|
||||
return Trait{ .documentation = value.String };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#pattern"))
|
||||
return Trait{ .pattern = value.String };
|
||||
|
||||
if (std.mem.eql(u8, trait_type, "aws.protocols#ec2QueryName"))
|
||||
return Trait{ .ec2_query_name = value.String };
|
||||
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#http")) {
|
||||
var code: i64 = 200;
|
||||
if (value.Object.get("code")) |v| {
|
||||
if (v == .Integer)
|
||||
code = v.Integer;
|
||||
}
|
||||
return Trait{ .http = .{
|
||||
.method = value.Object.get("method").?.String,
|
||||
.uri = value.Object.get("uri").?.String,
|
||||
.code = code,
|
||||
} };
|
||||
}
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#jsonName"))
|
||||
return Trait{ .json_name = value.String };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#xmlName"))
|
||||
return Trait{ .xml_name = value.String };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#httpQuery"))
|
||||
return Trait{ .http_query = value.String };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#httpHeader"))
|
||||
return Trait{ .http_header = value.String };
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#httpPayload"))
|
||||
return Trait{ .http_payload = .{} };
|
||||
|
||||
// TODO: Maybe care about these traits?
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#title"))
|
||||
return null;
|
||||
|
||||
if (std.mem.eql(u8, trait_type, "smithy.api#xmlNamespace"))
|
||||
return null;
|
||||
// TODO: win argument with compiler to get this comptime
|
||||
const list =
|
||||
\\aws.api#arnReference
|
||||
\\aws.api#clientDiscoveredEndpoint
|
||||
\\aws.api#clientEndpointDiscovery
|
||||
\\aws.api#arn
|
||||
\\aws.auth#unsignedPayload
|
||||
\\aws.iam#disableConditionKeyInference
|
||||
\\smithy.api#auth
|
||||
\\smithy.api#cors
|
||||
\\smithy.api#deprecated
|
||||
\\smithy.api#endpoint
|
||||
\\smithy.api#enum
|
||||
\\smithy.api#error
|
||||
\\smithy.api#eventPayload
|
||||
\\smithy.api#externalDocumentation
|
||||
\\smithy.api#hostLabel
|
||||
\\smithy.api#httpError
|
||||
\\smithy.api#httpChecksumRequired
|
||||
\\smithy.api#httpLabel
|
||||
\\smithy.api#httpPrefixHeaders
|
||||
\\smithy.api#httpQueryParams
|
||||
\\smithy.api#httpResponseCode
|
||||
\\smithy.api#idempotencyToken
|
||||
\\smithy.api#idempotent
|
||||
\\smithy.api#mediaType
|
||||
\\smithy.api#noReplace
|
||||
\\smithy.api#optionalAuth
|
||||
\\smithy.api#paginated
|
||||
\\smithy.api#readonly
|
||||
\\smithy.api#references
|
||||
\\smithy.api#requiresLength
|
||||
\\smithy.api#retryable
|
||||
\\smithy.api#sensitive
|
||||
\\smithy.api#streaming
|
||||
\\smithy.api#suppress
|
||||
\\smithy.api#tags
|
||||
\\smithy.api#timestampFormat
|
||||
\\smithy.api#xmlAttribute
|
||||
\\smithy.api#xmlFlattened
|
||||
\\smithy.waiters#waitable
|
||||
;
|
||||
var iterator = std.mem.split(u8, list, "\n");
|
||||
while (iterator.next()) |known_but_unimplemented| {
|
||||
if (std.mem.eql(u8, trait_type, known_but_unimplemented))
|
||||
return null;
|
||||
}
|
||||
|
||||
// Totally unknown type
|
||||
std.log.err("Invalid Trait Type: {s}", .{trait_type});
|
||||
return null;
|
||||
}
|
||||
fn getOptionalNumber(value: std.json.Value, key: []const u8) ?f64 {
|
||||
if (value.Object.get(key)) |v|
|
||||
return switch (v) {
|
||||
.Integer => @intToFloat(f64, v.Integer),
|
||||
.Float => v.Float,
|
||||
.Null, .Bool, .NumberString, .String, .Array, .Object => null,
|
||||
};
|
||||
return null;
|
||||
}
|
||||
const IdInfo = struct { id: []const u8, namespace: []const u8, name: []const u8, member: ?[]const u8 };
|
||||
const SmithyParseError = error{
|
||||
NoHashtagFound,
|
||||
InvalidType,
|
||||
OutOfMemory,
|
||||
};
|
||||
fn parseId(id: []const u8) SmithyParseError!IdInfo {
|
||||
var hashtag: ?usize = null;
|
||||
var dollar: ?usize = null;
|
||||
var inx: usize = 0;
|
||||
for (id) |ch| {
|
||||
switch (ch) {
|
||||
'#' => hashtag = inx,
|
||||
'$' => dollar = inx,
|
||||
else => {},
|
||||
}
|
||||
inx = inx + 1;
|
||||
}
|
||||
if (hashtag == null) {
|
||||
std.debug.print("no hashtag found on id: {s}\n", .{id});
|
||||
return SmithyParseError.NoHashtagFound;
|
||||
}
|
||||
const namespace = id[0..hashtag.?];
|
||||
var end = id.len;
|
||||
var member: ?[]const u8 = null;
|
||||
if (dollar) |d| {
|
||||
member = id[dollar.? + 1 .. end];
|
||||
end = d;
|
||||
}
|
||||
const name = id[hashtag.? + 1 .. end];
|
||||
return IdInfo{
|
||||
.id = id,
|
||||
.namespace = namespace,
|
||||
.name = name,
|
||||
.member = member,
|
||||
};
|
||||
}
|
||||
fn read_file_to_string(allocator: std.mem.Allocator, file_name: []const u8, max_bytes: usize) ![]const u8 {
|
||||
const file = try std.fs.cwd().openFile(file_name, std.fs.File.OpenFlags{});
|
||||
defer file.close();
|
||||
return file.readToEndAlloc(allocator, max_bytes);
|
||||
}
|
||||
var test_data: ?[]const u8 = null;
|
||||
const intrinsic_type_count: usize = 5; // 5 intrinsic types are added to every model
|
||||
|
||||
fn getTestData(_: *std.mem.Allocator) []const u8 {
|
||||
if (test_data) |d| return d;
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
test_data = read_file_to_string(gpa.allocator, "test.json", 150000) catch @panic("could not read test.json");
|
||||
return test_data.?;
|
||||
}
|
||||
test "read file" {
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer if (gpa.deinit()) @panic("leak");
|
||||
const allocator = gpa.allocator;
|
||||
_ = getTestData(allocator);
|
||||
// test stuff
|
||||
}
|
||||
test "parse string" {
|
||||
const test_string =
|
||||
\\ {
|
||||
\\ "smithy": "1.0",
|
||||
\\ "shapes": {
|
||||
\\ "com.amazonaws.sts#AWSSecurityTokenServiceV20110615": {
|
||||
\\ "type": "service",
|
||||
\\ "version": "2011-06-15",
|
||||
\\ "operations": [
|
||||
\\ {
|
||||
\\ "target": "op"
|
||||
\\ }
|
||||
\\ ]
|
||||
\\ }
|
||||
\\ }
|
||||
\\ }
|
||||
\\
|
||||
\\
|
||||
;
|
||||
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer if (gpa.deinit()) @panic("leak");
|
||||
const allocator = gpa.allocator;
|
||||
const model = try parse(allocator, test_string);
|
||||
defer model.deinit();
|
||||
try expect(std.mem.eql(u8, model.version, "1.0"));
|
||||
|
||||
try std.testing.expectEqual(intrinsic_type_count + 1, model.shapes.len);
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts#AWSSecurityTokenServiceV20110615", model.shapes[0].id);
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts", model.shapes[0].namespace);
|
||||
try std.testing.expectEqualStrings("AWSSecurityTokenServiceV20110615", model.shapes[0].name);
|
||||
try std.testing.expect(model.shapes[0].member == null);
|
||||
try std.testing.expectEqualStrings("2011-06-15", model.shapes[0].shape.service.version);
|
||||
}
|
||||
test "parse shape with member" {
|
||||
const test_string =
|
||||
\\ {
|
||||
\\ "smithy": "1.0",
|
||||
\\ "shapes": {
|
||||
\\ "com.amazonaws.sts#AWSSecurityTokenServiceV20110615$member": {
|
||||
\\ "type": "service",
|
||||
\\ "version": "2011-06-15",
|
||||
\\ "operations": [
|
||||
\\ {
|
||||
\\ "target": "op"
|
||||
\\ }
|
||||
\\ ]
|
||||
\\ }
|
||||
\\ }
|
||||
\\ }
|
||||
\\
|
||||
\\
|
||||
;
|
||||
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer if (gpa.deinit()) @panic("leak");
|
||||
const allocator = gpa.allocator;
|
||||
const model = try parse(allocator, test_string);
|
||||
defer model.deinit();
|
||||
try expect(std.mem.eql(u8, model.version, "1.0"));
|
||||
try std.testing.expectEqual(intrinsic_type_count + 1, model.shapes.len);
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts#AWSSecurityTokenServiceV20110615$member", model.shapes[0].id);
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts", model.shapes[0].namespace);
|
||||
try std.testing.expectEqualStrings("AWSSecurityTokenServiceV20110615", model.shapes[0].name);
|
||||
try std.testing.expectEqualStrings("2011-06-15", model.shapes[0].shape.service.version);
|
||||
try std.testing.expectEqualStrings("member", model.shapes[0].member.?);
|
||||
}
|
||||
test "parse file" {
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer if (gpa.deinit()) @panic("leak");
|
||||
const allocator = gpa.allocator;
|
||||
const test_string = getTestData(allocator);
|
||||
const model = try parse(allocator, test_string);
|
||||
defer model.deinit();
|
||||
try std.testing.expectEqualStrings(model.version, "1.0");
|
||||
// metadata expectations
|
||||
// try expect(std.mem.eql(u8, model.version, "version 1.0"));
|
||||
|
||||
// shape expectations
|
||||
try std.testing.expectEqual(intrinsic_type_count + 81, model.shapes.len);
|
||||
var optsvc: ?ShapeInfo = null;
|
||||
for (model.shapes) |shape| {
|
||||
if (std.mem.eql(u8, shape.id, "com.amazonaws.sts#AWSSecurityTokenServiceV20110615")) {
|
||||
optsvc = shape;
|
||||
break;
|
||||
}
|
||||
}
|
||||
try std.testing.expect(optsvc != null);
|
||||
const svc = optsvc.?;
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts#AWSSecurityTokenServiceV20110615", svc.id);
|
||||
try std.testing.expectEqualStrings("com.amazonaws.sts", svc.namespace);
|
||||
try std.testing.expectEqualStrings("AWSSecurityTokenServiceV20110615", svc.name);
|
||||
try std.testing.expectEqualStrings("2011-06-15", svc.shape.service.version);
|
||||
// Should be 6, but we don't handle title or xml namespace
|
||||
try std.testing.expectEqual(@as(usize, 4), svc.shape.service.traits.len);
|
||||
try std.testing.expectEqual(@as(usize, 8), svc.shape.service.operations.len);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user