lumenkeyes
/
proxy-print
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

new way of doing things! it's slower :((

This commit is contained in:
Lumen Keyes 2024-07-06 00:18:29 -06:00
parent be11ed54dd
commit b9945e8097
2 changed files with 206 additions and 117 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
src/print.zig
View File

@ -21,18 +21,9 @@ const Card = struct {
card_faces: ?[]Card = null, //array of cards card_faces: ?[]Card = null, //array of cards
}; };
const TextCard = struct { const TextCard = struct { lines: [][]const u8 = undefined };
lines: [][]const u8 = undefined
};
const PandocOptions = &[_][]const u8{ const PandocOptions = &[_][]const u8{ "pandoc", "out.md", "-o", "out.pdf", "--pdf-engine", "xelatex", "-V", "mainfont:Liberation Mono", "-V", "geometry:margin=0cm" };
"pandoc",
"out.md",
"-o", "out.pdf",
"--pdf-engine", "xelatex",
"-V", "mainfont:Liberation Mono",
"-V", "geometry:margin=0cm"
};
//dimension constants and defaults //dimension constants and defaults
const cardWidth = 30; const cardWidth = 30;
@ -41,7 +32,6 @@ const minCardHeight = 5;
const pageHeight = 66; const pageHeight = 66;
var heightMayVary = false; var heightMayVary = false;
const formatString = "{s: <" ++ std.fmt.digits2(cardWidth) ++ "}"; const formatString = "{s: <" ++ std.fmt.digits2(cardWidth) ++ "}";
const lineFormatter = "|" ++ formatString; const lineFormatter = "|" ++ formatString;
const spacer: []const u8 = "|" ++ (" " ** cardWidth); const spacer: []const u8 = "|" ++ (" " ** cardWidth);
@ -62,7 +52,9 @@ pub fn main() !void {
//TODO: properly handle program arguments //TODO: properly handle program arguments
_ = args.next(); //handle program name (args[0]) _ = args.next(); //handle program name (args[0])
const listFileName: []const u8 = args.next() orelse {return error.ExpectedArgument;}; const listFileName: []const u8 = args.next() orelse {
return error.ExpectedArgument;
};
heightMayVary = stringToBool(args.next()); heightMayVary = stringToBool(args.next());
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
@ -70,66 +62,114 @@ pub fn main() !void {
const allocator = arena.allocator(); const allocator = arena.allocator();
const oracleFile = try cwd.openFile(oracleFileName, .{}); const oracleFile = try cwd.openFile(oracleFileName, .{});
var jsonReader = json.reader(allocator, oracleFile.reader()); // var jsonReader = json.reader(allocator, oracleFile.reader());
const parsedJson = try json.parseFromTokenSource([]Card, allocator, &jsonReader, .{.ignore_unknown_fields = true}); // const parsedJson = try json.parseFromTokenSource([]Card, allocator, &jsonReader, .{.ignore_unknown_fields = true});
var allCards = std.StringHashMap(Card).init(allocator);
for(parsedJson.value) |cardObj| {
try allCards.put(cardObj.name, cardObj);
}
parsedJson.deinit();
var line = std.ArrayList(u8).init(allocator);
var cardNames = std.ArrayList([]const u8).init(allocator);
const listReader = (try cwd.openFile(listFileName, .{})).reader(); const listReader = (try cwd.openFile(listFileName, .{})).reader();
var allPrinted = std.ArrayList(u8).init(allocator); var line = std.ArrayList(u8).init(allocator);
var cards = std.ArrayList(TextCard).init(allocator);
// var pages = std.ArrayList(page).init(allocator);
while (listReader.streamUntilDelimiter(line.writer(), '\n', null)) { while (listReader.streamUntilDelimiter(line.writer(), '\n', null)) {
defer line.clearRetainingCapacity(); defer line.clearRetainingCapacity();
const cardName = line.items[indexOf(u8, line.items, " ").? + 1 .. indexOf(u8, line.items, "(").? - 1]; const cardName = line.items[indexOf(u8, line.items, " ").? + 1 .. indexOf(u8, line.items, "(").? - 1];
assert(cardName.len > 0); try cardNames.append(try allocator.dupe(u8, cardName));
const cardText = try card(allCards.get(cardName).?);
try cards.append(cardText);
} else |err| switch (err) { } else |err| switch (err) {
error.EndOfStream => {}, error.EndOfStream => {},
else => return err, else => return err,
} }
for(cards.items) |cardText| { var depth: u32 = 0;
std.debug.print("{any}\n", .{cardText}); var cardString = std.ArrayList(u8).init(allocator);
var cards = std.StringHashMap(Card).init(allocator);
while (oracleFile.reader().readByte()) |char| {
if (char == '{') depth += 1;
if (depth != 0) try cardString.append(char);
if (char == '}') {
depth -= 1;
if (depth == 0) {
// print("{s}\n", .{cardString.items});
const parsedCard = try std.json.parseFromSlice(Card, allocator, cardString.items, .{ .ignore_unknown_fields = true });
var lookupTimer = try std.time.Timer.start();
for (cardNames.items, 0..) |cardName, i| {
if (std.mem.eql(u8, parsedCard.value.name, cardName)) {
// print("{s}\n", .{parsedCard.value.name});
try cards.putNoClobber(try allocator.dupe(u8, parsedCard.value.name), (try allocator.dupe(Card, &[_]Card{parsedCard.value}))[0]);
_ = cardNames.orderedRemove(i);
} }
}
cardString.clearAndFree();
print("took {d:.10}\n", .{lookupTimer.read() / (1000 * 1000 * 1000)});
}
}
} else |e| {
switch (e) {
error.EndOfStream => {},
else => {
return e;
},
}
}
var cardIterator = cards.valueIterator();
while (cardIterator.next()) |cardObj| {
print("{any}\n", .{cardObj});
}
// var allCards = std.StringHashMap(Card).init(allocator);
// for(parsedJson.value) |cardObj| {
// try allCards.put(cardObj.name, cardObj);
// }
// parsedJson.deinit();
//
// var allPrinted = std.ArrayList(u8).init(allocator);
// var cards = std.ArrayList(TextCard).init(allocator);
// // var pages = std.ArrayList(page).init(allocator);
// while (listReader.streamUntilDelimiter(line.writer(), '\n', null)) {
// defer line.clearRetainingCapacity();
// const cardName = line.items[indexOf(u8, line.items, " ").? + 1..indexOf(u8, line.items, "(").? - 1];
// assert(cardName.len > 0);
// const cardText = try card(allCards.get(cardName).?);
// try cards.append(cardText);
// } else |err| switch(err) {
// error.EndOfStream => {},
// else => return err,
// }
//
// for(cards.items) |cardText| {
// std.debug.print("{any}\n", .{cardText});
// }
//sort the cards //sort the cards
std.mem.sort(TextCard, cards.items, {}, compareTwo); // std.mem.sort(TextCard, cards.items, {}, compareTwo);
//TODO (fixme): absolutely GARBAGE hack to get pandoc to preserve whitespace //TODO (fixme): absolutely GARBAGE hack to get pandoc to preserve whitespace
try allPrinted.appendSlice(markdownFormatString); // try allPrinted.appendSlice(markdownFormatString);
var rowToPrint = std.ArrayList(TextCard).init(allocator); // var rowToPrint = std.ArrayList(TextCard).init(allocator);
for(cards.items) |cardObj| { // for(cards.items) |cardObj| {
try rowToPrint.append(cardObj); // try rowToPrint.append(cardObj);
std.debug.print("{any}\n", .{cardObj}); // std.debug.print("{any}\n", .{cardObj});
if(rowToPrint.items.len >= 3) { // if(rowToPrint.items.len >= 3) {
try cardRow.print(allocator, rowToPrint.items, &allPrinted); // try cardRow.print(allocator, rowToPrint.items, &allPrinted);
rowToPrint.clearAndFree(); // rowToPrint.clearAndFree();
} // }
} else { // // } else {
try cardRow.print(allocator, rowToPrint.items, &allPrinted); // try cardRow.print(allocator, rowToPrint.items, &allPrinted);
try allPrinted.appendSlice(markdownFormatString); // try allPrinted.appendSlice(markdownFormatString);
std.debug.print("{s}", .{allPrinted.items}); // std.debug.print("{s}", .{allPrinted.items});
try cwd.writeFile(.{.sub_path = "out.md", .data = allPrinted.items}); // try cwd.writeFile(.{.sub_path = "out.md", .data = allPrinted.items});
rowToPrint.clearAndFree(); // rowToPrint.clearAndFree();
var pandocProcess = std.process.Child.init(PandocOptions, allocator); // var pandocProcess = std.process.Child.init(PandocOptions, allocator);
_ = try pandocProcess.spawnAndWait(); // _ = try pandocProcess.spawnAndWait();
} // }
} }
fn compareTwo(_: void, a: TextCard, b: TextCard) bool { fn compareTwo(_: void, a: TextCard, b: TextCard) bool {
return a.lines.len < b.lines.len; return a.lines.len < b.lines.len;
} }
fn card(cardObj: Card,) !TextCard { fn card(
cardObj: Card,
) !TextCard {
var buffer: [cardHeight * 1024]u8 = undefined; var buffer: [cardHeight * 1024]u8 = undefined;
var cardTextAllocator = std.heap.FixedBufferAllocator.init(&buffer); var cardTextAllocator = std.heap.FixedBufferAllocator.init(&buffer);
defer cardTextAllocator.reset(); defer cardTextAllocator.reset();
@ -168,7 +208,9 @@ fn card(cardObj: Card,) !TextCard {
for (fullUnformattedText.items) |char| { for (fullUnformattedText.items) |char| {
try switch (char) { try switch (char) {
'\n', ' ' => addWord(&word, &line, &cardText), '\n', ' ' => addWord(&word, &line, &cardText),
else => if(std.ascii.isASCII(char)) {try word.append(char);} else => if (std.ascii.isASCII(char)) {
try word.append(char);
},
}; };
} else { } else {
try addWord(&word, &line, &cardText); try addWord(&word, &line, &cardText);
@ -228,7 +270,7 @@ const cardRow = struct{
0 => .{ .first = paddedLine }, 0 => .{ .first = paddedLine },
1 => .{ .first = placeholder.first, .second = paddedLine }, 1 => .{ .first = placeholder.first, .second = paddedLine },
2 => .{ .first = placeholder.first, .second = placeholder.second, .third = paddedLine }, 2 => .{ .first = placeholder.first, .second = placeholder.second, .third = paddedLine },
else => unreachable else => unreachable,
}; };
if (idx < lines.items(.first).len) { if (idx < lines.items(.first).len) {
lines.set(idx, new); lines.set(idx, new);
@ -245,12 +287,7 @@ const cardRow = struct{
const line = lines.get(idx); const line = lines.get(idx);
const printedWidth = line.first.len + line.second.len + line.third.len + line.last.len; const printedWidth = line.first.len + line.second.len + line.third.len + line.last.len;
assert(printedWidth == pageWidth); assert(printedWidth == pageWidth);
const fullLine = try std.mem.concat(gpa.allocator(), u8, &[_][]const u8{ const fullLine = try std.mem.concat(gpa.allocator(), u8, &[_][]const u8{ line.first, line.second, line.third, line.last });
line.first,
line.second,
line.third,
line.last
});
try allPrinted.appendSlice(fullLine); try allPrinted.appendSlice(fullLine);
} }
} }

52
src/selectiveParse.zig Normal file
View File

@ -0,0 +1,52 @@
const std = @import("std");
const cwd = std.fs.cwd;
const json = std.json;
const print = std.debug.print;
const oracleFileName = "oracle-cards-20240701090158.json";
const Card = struct {
name: []const u8 = "", //string
mana_cost: []const u8 = "", //string
cmc: f32 = 0, //technically a float? but I think we can always cast safely cast. EDIT: NOPE
type_line: []const u8 = "", //string
oracle_text: []const u8 = "", //string
power: []const u8 = "", //coerced to string
toughness: []const u8 = "", //coerced to string
card_faces: ?[]Card = null, //array of cards
};
const testCardName = "Raffine, Scheming Seer";
const cardList = std.MultiArrayList(Card);
pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit();
const allocator = arena.allocator();
const oracleFile = try cwd().openFile(oracleFileName, .{});
const fileReader = oracleFile.reader();
// var jsonReader = json.reader(allocator, oracleFile.reader());
// var fields = std.ArrayList(Field).init(allocator);
// var isVal = false;
// var cards = std.StringHashMap(*StringHashMap);
// var currentCard = std.ArrayList(std.json.Token).init(allocator);
var depth: u32 = 0;
var cardString = std.ArrayList(u8).init(allocator);
var idx: u32 = 0;
while (fileReader.readByte()) |char| {
if (char == '{') depth += 1;
if (depth != 0) try cardString.append(char);
if (char == '}') {
depth -= 1;
if (depth == 0) {
// print("{s}\n", .{cardString.items});
const parsedCard = try std.json.parseFromSlice(Card, allocator, cardString.items, .{ .ignore_unknown_fields = true });
print("{s}\n", .{parsedCard.value.name});
cardString.clearAndFree();
}
}
idx += 1;
} else |e| {
return e;
}
}