0.2.0 #1

+4 -1

.gitignore

··· 1 1 /target 2 2 3 3 - realm.nbt 3 3 + # my local input data 4 4 + /worlds 5 5 + realm.nbt 6 6 + container.json.gz

+273 -30

Cargo.lock

··· 291 291 ] 292 292 293 293 [[package]] 294 294 + name = "borsh" 295 295 + version = "1.6.0" 296 296 + source = "registry+https://github.com/rust-lang/crates.io-index" 297 297 + checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f" 298 298 + dependencies = [ 299 299 + "cfg_aliases", 300 300 + ] 301 301 + 302 302 + [[package]] 294 303 name = "brotli" 295 304 version = "8.0.2" 296 305 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 346 355 version = "1.0.4" 347 356 source = "registry+https://github.com/rust-lang/crates.io-index" 348 357 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801" 358 358 + 359 359 + [[package]] 360 360 + name = "cfg_aliases" 361 361 + version = "0.2.1" 362 362 + source = "registry+https://github.com/rust-lang/crates.io-index" 363 363 + checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724" 349 364 350 365 [[package]] 351 366 name = "chrono" ··· 426 441 checksum = "75984efb6ed102a0d42db99afb6c1948f0380d1d91808d5529916e6c08b49d8d" 427 442 428 443 [[package]] 444 444 + name = "console" 445 445 + version = "0.15.11" 446 446 + source = "registry+https://github.com/rust-lang/crates.io-index" 447 447 + checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8" 448 448 + dependencies = [ 449 449 + "encode_unicode", 450 450 + "libc", 451 451 + "once_cell", 452 452 + "windows-sys 0.59.0", 453 453 + ] 454 454 + 455 455 + [[package]] 429 456 name = "const-oid" 430 457 version = "0.10.2" 431 458 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 561 588 checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555" 562 589 563 590 [[package]] 591 591 + name = "encode_unicode" 592 592 + version = "1.0.0" 593 593 + source = "registry+https://github.com/rust-lang/crates.io-index" 594 594 + checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0" 595 595 + 596 596 + [[package]] 564 597 name = "equivalent" 565 598 version = "1.0.2" 566 599 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 577 610 ] 578 611 579 612 [[package]] 613 613 + name = "fastrand" 614 614 + version = "2.3.0" 615 615 + source = "registry+https://github.com/rust-lang/crates.io-index" 616 616 + checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" 617 617 + 618 618 + [[package]] 580 619 name = "find-msvc-tools" 581 620 version = "0.1.9" 582 621 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 600 639 601 640 [[package]] 602 641 name = "foldhash" 603 603 - version = "0.1.5" 642 642 + version = "0.2.0" 604 643 source = "registry+https://github.com/rust-lang/crates.io-index" 605 605 - checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2" 644 644 + checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb" 606 645 607 646 [[package]] 608 647 name = "form_urlencoded" ··· 672 711 673 712 [[package]] 674 713 name = "hashbrown" 675 675 - version = "0.15.5" 714 714 + version = "0.16.1" 676 715 source = "registry+https://github.com/rust-lang/crates.io-index" 677 677 - checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1" 716 716 + checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" 678 717 dependencies = [ 679 718 "allocator-api2", 680 719 "equivalent", 681 720 "foldhash", 682 721 ] 683 683 - 684 684 - [[package]] 685 685 - name = "hashbrown" 686 686 - version = "0.16.1" 687 687 - source = "registry+https://github.com/rust-lang/crates.io-index" 688 688 - checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" 689 722 690 723 [[package]] 691 724 name = "heck" ··· 852 885 ] 853 886 854 887 [[package]] 888 888 + name = "insta" 889 889 + version = "1.46.3" 890 890 + source = "registry+https://github.com/rust-lang/crates.io-index" 891 891 + checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4" 892 892 + dependencies = [ 893 893 + "console", 894 894 + "once_cell", 895 895 + "similar", 896 896 + "tempfile", 897 897 + ] 898 898 + 899 899 + [[package]] 855 900 name = "is_terminal_polyfill" 856 901 version = "1.70.2" 857 902 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 896 941 checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112" 897 942 898 943 [[package]] 944 944 + name = "linux-raw-sys" 945 945 + version = "0.12.1" 946 946 + source = "registry+https://github.com/rust-lang/crates.io-index" 947 947 + checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53" 948 948 + 949 949 + [[package]] 899 950 name = "lock_api" 900 951 version = "0.4.14" 901 952 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 912 963 913 964 [[package]] 914 965 name = "lru" 915 915 - version = "0.12.5" 966 966 + version = "0.16.3" 916 967 source = "registry+https://github.com/rust-lang/crates.io-index" 917 917 - checksum = "234cf4f4a04dc1f57e24b96cc0cd600cf2af460d4161ac5ecdd0af8e1f3b2a38" 968 968 + checksum = "a1dc47f592c06f33f8e3aea9591776ec7c9f9e4124778ff8a3c3b87159f7e593" 918 969 dependencies = [ 919 919 - "hashbrown 0.15.5", 970 970 + "hashbrown 0.16.1", 920 971 ] 921 972 922 973 [[package]] ··· 960 1011 961 1012 [[package]] 962 1013 name = "nara" 963 963 - version = "0.1.0" 1014 1014 + version = "0.2.0" 964 1015 dependencies = [ 965 1016 "ahash", 966 1017 "anyhow", ··· 972 1023 "hex", 973 1024 "html-escape", 974 1025 "lru", 1026 1026 + "nara_core", 1027 1027 + "nara_slurper_1_12_infinity", 1028 1028 + "nara_slurper_1_12_world", 975 1029 "serde", 976 1030 "serde_json", 977 1031 "serde_with", ··· 986 1040 ] 987 1041 988 1042 [[package]] 1043 1043 + name = "nara_core" 1044 1044 + version = "0.2.0" 1045 1045 + dependencies = [ 1046 1046 + "hex", 1047 1047 + "insta", 1048 1048 + "nara_io", 1049 1049 + "serde", 1050 1050 + "serde_json", 1051 1051 + "serde_with", 1052 1052 + "sha1", 1053 1053 + "uuid", 1054 1054 + ] 1055 1055 + 1056 1056 + [[package]] 1057 1057 + name = "nara_io" 1058 1058 + version = "0.2.0" 1059 1059 + dependencies = [ 1060 1060 + "crab_nbt", 1061 1061 + "flate2", 1062 1062 + "serde", 1063 1063 + "serde_json", 1064 1064 + "thiserror", 1065 1065 + ] 1066 1066 + 1067 1067 + [[package]] 1068 1068 + name = "nara_mcr" 1069 1069 + version = "0.2.0" 1070 1070 + dependencies = [ 1071 1071 + "crab_nbt", 1072 1072 + "flate2", 1073 1073 + "serde", 1074 1074 + "thiserror", 1075 1075 + ] 1076 1076 + 1077 1077 + [[package]] 1078 1078 + name = "nara_slurper_1_12_core" 1079 1079 + version = "0.2.0" 1080 1080 + dependencies = [ 1081 1081 + "nara_core", 1082 1082 + "nara_mcr", 1083 1083 + "serde", 1084 1084 + ] 1085 1085 + 1086 1086 + [[package]] 1087 1087 + name = "nara_slurper_1_12_infinity" 1088 1088 + version = "0.2.0" 1089 1089 + dependencies = [ 1090 1090 + "nara_core", 1091 1091 + "nara_io", 1092 1092 + "nara_slurper_1_12_core", 1093 1093 + "serde", 1094 1094 + ] 1095 1095 + 1096 1096 + [[package]] 1097 1097 + name = "nara_slurper_1_12_world" 1098 1098 + version = "0.2.0" 1099 1099 + dependencies = [ 1100 1100 + "crab_nbt", 1101 1101 + "insta", 1102 1102 + "nara_core", 1103 1103 + "nara_io", 1104 1104 + "nara_mcr", 1105 1105 + "nara_slurper_1_12_core", 1106 1106 + "serde", 1107 1107 + "serde_with", 1108 1108 + "thiserror", 1109 1109 + "tokio", 1110 1110 + "tracing", 1111 1111 + "uuid", 1112 1112 + ] 1113 1113 + 1114 1114 + [[package]] 989 1115 name = "nu-ansi-term" 990 1116 version = "0.50.3" 991 1117 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1143 1269 ] 1144 1270 1145 1271 [[package]] 1272 1272 + name = "rustix" 1273 1273 + version = "1.1.4" 1274 1274 + source = "registry+https://github.com/rust-lang/crates.io-index" 1275 1275 + checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190" 1276 1276 + dependencies = [ 1277 1277 + "bitflags", 1278 1278 + "errno", 1279 1279 + "libc", 1280 1280 + "linux-raw-sys", 1281 1281 + "windows-sys 0.61.2", 1282 1282 + ] 1283 1283 + 1284 1284 + [[package]] 1146 1285 name = "rustversion" 1147 1286 version = "1.0.22" 1148 1287 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1258 1397 1259 1398 [[package]] 1260 1399 name = "serde_with" 1261 1261 - version = "3.16.1" 1400 1400 + version = "3.17.0" 1262 1401 source = "registry+https://github.com/rust-lang/crates.io-index" 1263 1263 - checksum = "4fa237f2807440d238e0364a218270b98f767a00d3dada77b1c53ae88940e2e7" 1402 1402 + checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9" 1264 1403 dependencies = [ 1265 1404 "base64", 1266 1405 "chrono", ··· 1277 1416 1278 1417 [[package]] 1279 1418 name = "serde_with_macros" 1280 1280 - version = "3.16.1" 1419 1419 + version = "3.17.0" 1281 1420 source = "registry+https://github.com/rust-lang/crates.io-index" 1282 1282 - checksum = "52a8e3ca0ca629121f70ab50f95249e5a6f925cc0f6ffe8256c45b728875706c" 1421 1421 + checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0" 1283 1422 dependencies = [ 1284 1423 "darling", 1285 1424 "proc-macro2", ··· 1328 1467 version = "0.3.8" 1329 1468 source = "registry+https://github.com/rust-lang/crates.io-index" 1330 1469 checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2" 1470 1470 + 1471 1471 + [[package]] 1472 1472 + name = "similar" 1473 1473 + version = "2.7.0" 1474 1474 + source = "registry+https://github.com/rust-lang/crates.io-index" 1475 1475 + checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa" 1331 1476 1332 1477 [[package]] 1333 1478 name = "slab" ··· 1343 1488 1344 1489 [[package]] 1345 1490 name = "smol_str" 1346 1346 - version = "0.2.2" 1491 1491 + version = "0.3.5" 1347 1492 source = "registry+https://github.com/rust-lang/crates.io-index" 1348 1348 - checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead" 1493 1493 + checksum = "0f7a918bd2a9951d18ee6e48f076843e8e73a9a5d22cf05bcd4b7a81bdd04e17" 1349 1494 dependencies = [ 1350 1350 - "serde", 1495 1495 + "borsh", 1496 1496 + "serde_core", 1351 1497 ] 1352 1498 1353 1499 [[package]] ··· 1384 1530 checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263" 1385 1531 1386 1532 [[package]] 1533 1533 + name = "tempfile" 1534 1534 + version = "3.26.0" 1535 1535 + source = "registry+https://github.com/rust-lang/crates.io-index" 1536 1536 + checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0" 1537 1537 + dependencies = [ 1538 1538 + "fastrand", 1539 1539 + "getrandom", 1540 1540 + "once_cell", 1541 1541 + "rustix", 1542 1542 + "windows-sys 0.61.2", 1543 1543 + ] 1544 1544 + 1545 1545 + [[package]] 1387 1546 name = "thiserror" 1388 1547 version = "2.0.18" 1389 1548 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1614 1773 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" 1615 1774 1616 1775 [[package]] 1776 1776 + name = "uuid" 1777 1777 + version = "1.21.0" 1778 1778 + source = "registry+https://github.com/rust-lang/crates.io-index" 1779 1779 + checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb" 1780 1780 + dependencies = [ 1781 1781 + "js-sys", 1782 1782 + "serde_core", 1783 1783 + "wasm-bindgen", 1784 1784 + ] 1785 1785 + 1786 1786 + [[package]] 1617 1787 name = "valuable" 1618 1788 version = "0.1.1" 1619 1789 source = "registry+https://github.com/rust-lang/crates.io-index" ··· 1746 1916 1747 1917 [[package]] 1748 1918 name = "windows-sys" 1919 1919 + version = "0.59.0" 1920 1920 + source = "registry+https://github.com/rust-lang/crates.io-index" 1921 1921 + checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" 1922 1922 + dependencies = [ 1923 1923 + "windows-targets 0.52.6", 1924 1924 + ] 1925 1925 + 1926 1926 + [[package]] 1927 1927 + name = "windows-sys" 1749 1928 version = "0.60.2" 1750 1929 source = "registry+https://github.com/rust-lang/crates.io-index" 1751 1930 checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb" 1752 1931 dependencies = [ 1753 1753 - "windows-targets", 1932 1932 + "windows-targets 0.53.5", 1754 1933 ] 1755 1934 1756 1935 [[package]] ··· 1764 1943 1765 1944 [[package]] 1766 1945 name = "windows-targets" 1946 1946 + version = "0.52.6" 1947 1947 + source = "registry+https://github.com/rust-lang/crates.io-index" 1948 1948 + checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" 1949 1949 + dependencies = [ 1950 1950 + "windows_aarch64_gnullvm 0.52.6", 1951 1951 + "windows_aarch64_msvc 0.52.6", 1952 1952 + "windows_i686_gnu 0.52.6", 1953 1953 + "windows_i686_gnullvm 0.52.6", 1954 1954 + "windows_i686_msvc 0.52.6", 1955 1955 + "windows_x86_64_gnu 0.52.6", 1956 1956 + "windows_x86_64_gnullvm 0.52.6", 1957 1957 + "windows_x86_64_msvc 0.52.6", 1958 1958 + ] 1959 1959 + 1960 1960 + [[package]] 1961 1961 + name = "windows-targets" 1767 1962 version = "0.53.5" 1768 1963 source = "registry+https://github.com/rust-lang/crates.io-index" 1769 1964 checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3" 1770 1965 dependencies = [ 1771 1966 "windows-link", 1772 1772 - "windows_aarch64_gnullvm", 1773 1773 - "windows_aarch64_msvc", 1774 1774 - "windows_i686_gnu", 1775 1775 - "windows_i686_gnullvm", 1776 1776 - "windows_i686_msvc", 1777 1777 - "windows_x86_64_gnu", 1778 1778 - "windows_x86_64_gnullvm", 1779 1779 - "windows_x86_64_msvc", 1967 1967 + "windows_aarch64_gnullvm 0.53.1", 1968 1968 + "windows_aarch64_msvc 0.53.1", 1969 1969 + "windows_i686_gnu 0.53.1", 1970 1970 + "windows_i686_gnullvm 0.53.1", 1971 1971 + "windows_i686_msvc 0.53.1", 1972 1972 + "windows_x86_64_gnu 0.53.1", 1973 1973 + "windows_x86_64_gnullvm 0.53.1", 1974 1974 + "windows_x86_64_msvc 0.53.1", 1780 1975 ] 1781 1976 1782 1977 [[package]] 1783 1978 name = "windows_aarch64_gnullvm" 1979 1979 + version = "0.52.6" 1980 1980 + source = "registry+https://github.com/rust-lang/crates.io-index" 1981 1981 + checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" 1982 1982 + 1983 1983 + [[package]] 1984 1984 + name = "windows_aarch64_gnullvm" 1784 1985 version = "0.53.1" 1785 1986 source = "registry+https://github.com/rust-lang/crates.io-index" 1786 1987 checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53" 1787 1988 1788 1989 [[package]] 1789 1990 name = "windows_aarch64_msvc" 1991 1991 + version = "0.52.6" 1992 1992 + source = "registry+https://github.com/rust-lang/crates.io-index" 1993 1993 + checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" 1994 1994 + 1995 1995 + [[package]] 1996 1996 + name = "windows_aarch64_msvc" 1790 1997 version = "0.53.1" 1791 1998 source = "registry+https://github.com/rust-lang/crates.io-index" 1792 1999 checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006" 1793 2000 1794 2001 [[package]] 1795 2002 name = "windows_i686_gnu" 2003 2003 + version = "0.52.6" 2004 2004 + source = "registry+https://github.com/rust-lang/crates.io-index" 2005 2005 + checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b" 2006 2006 + 2007 2007 + [[package]] 2008 2008 + name = "windows_i686_gnu" 1796 2009 version = "0.53.1" 1797 2010 source = "registry+https://github.com/rust-lang/crates.io-index" 1798 2011 checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3" 1799 2012 1800 2013 [[package]] 1801 2014 name = "windows_i686_gnullvm" 2015 2015 + version = "0.52.6" 2016 2016 + source = "registry+https://github.com/rust-lang/crates.io-index" 2017 2017 + checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" 2018 2018 + 2019 2019 + [[package]] 2020 2020 + name = "windows_i686_gnullvm" 1802 2021 version = "0.53.1" 1803 2022 source = "registry+https://github.com/rust-lang/crates.io-index" 1804 2023 checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c" 2024 2024 + 2025 2025 + [[package]] 2026 2026 + name = "windows_i686_msvc" 2027 2027 + version = "0.52.6" 2028 2028 + source = "registry+https://github.com/rust-lang/crates.io-index" 2029 2029 + checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" 1805 2030 1806 2031 [[package]] 1807 2032 name = "windows_i686_msvc" ··· 1811 2036 1812 2037 [[package]] 1813 2038 name = "windows_x86_64_gnu" 2039 2039 + version = "0.52.6" 2040 2040 + source = "registry+https://github.com/rust-lang/crates.io-index" 2041 2041 + checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" 2042 2042 + 2043 2043 + [[package]] 2044 2044 + name = "windows_x86_64_gnu" 1814 2045 version = "0.53.1" 1815 2046 source = "registry+https://github.com/rust-lang/crates.io-index" 1816 2047 checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499" 1817 2048 1818 2049 [[package]] 1819 2050 name = "windows_x86_64_gnullvm" 2051 2051 + version = "0.52.6" 2052 2052 + source = "registry+https://github.com/rust-lang/crates.io-index" 2053 2053 + checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" 2054 2054 + 2055 2055 + [[package]] 2056 2056 + name = "windows_x86_64_gnullvm" 1820 2057 version = "0.53.1" 1821 2058 source = "registry+https://github.com/rust-lang/crates.io-index" 1822 2059 checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1" 2060 2060 + 2061 2061 + [[package]] 2062 2062 + name = "windows_x86_64_msvc" 2063 2063 + version = "0.52.6" 2064 2064 + source = "registry+https://github.com/rust-lang/crates.io-index" 2065 2065 + checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec" 1823 2066 1824 2067 [[package]] 1825 2068 name = "windows_x86_64_msvc"

+66 -23

Cargo.toml

··· 1 1 + [workspace] 2 2 + resolver = "3" 3 3 + members = ["nara_io", "nara_slurper_1_12_core", "nara_slurper_1_12_infinity", "nara_slurper_1_12_world", "nara_core", "nara_mcr"] 4 4 + 5 5 + [workspace.package] 6 6 + version = "0.2.0" 7 7 + edition = "2024" 8 8 + 9 9 + [workspace.dependencies] 10 10 + ahash = "=0.8.12" 11 11 + anyhow = "=1.0.102" 12 12 + askama = "=0.15.4" 13 13 + askama_web = { version = "=0.15.1", features = ["axum-0.8", "tracing-0.1"] } 14 14 + axum = "=0.8.8" 15 15 + clap = { version = "=4.5.60", features = ["derive"] } 16 16 + crab_nbt = { version = "=0.2.11", features = ["serde"] } 17 17 + flate2 = "=1.1.9" 18 18 + hex = "=0.4.3" 19 19 + html-escape = "=0.2.13" 20 20 + insta = "=1.46.3" 21 21 + lru = "=0.16.3" 22 22 + nara_slurper_1_12_core = { path = "nara_slurper_1_12_core" } 23 23 + nara_io = { path = "nara_io" } 24 24 + nara_slurper_1_12_infinity = { path = "nara_slurper_1_12_infinity" } 25 25 + nara_slurper_1_12_world = { path = "nara_slurper_1_12_world" } 26 26 + nara_core = { path = "nara_core" } 27 27 + nara_mcr = { path = "nara_mcr" } 28 28 + serde = { version = "=1.0.228", features = ["derive"] } 29 29 + serde_json = "=1.0.149" 30 30 + serde_with = { version = "=3.17.0", features = ["hex"] } 31 31 + sha1 = "=0.11.0-rc.5" 32 32 + smol_str = "=0.3.5" 33 33 + strsim = "=0.11.1" 34 34 + thiserror = "=2.0.18" 35 35 + tokio = { version = "=1.49.0", features = ["full"] } 36 36 + tower-http = { version = "=0.6.8", features = ["compression-full"] } 37 37 + tracing = "=0.1.44" 38 38 + tracing-subscriber = "=0.3.22" 39 39 + uuid = { version = "=1.21.0", features = ["serde"] } 40 40 + 1 41 [package] 2 42 name = "nara" 3 3 - version = "0.1.0" 4 4 - edition = "2024" 43 43 + version.workspace = true 44 44 + edition.workspace = true 5 45 6 46 [dependencies] 7 7 - ahash = "0.8" 8 8 - anyhow = "1.0" 9 9 - askama = "0.15" 10 10 - askama_web = { version = "0.15", features = ["axum-0.8", "tracing-0.1"] } 11 11 - axum = "0.8" 12 12 - clap = { version = "4.5", features = ["derive"] } 13 13 - crab_nbt = { version = "0.2", features = ["serde"] } 14 14 - hex = "0.4" 15 15 - html-escape = "0.2" 16 16 - lru = "0.12" 17 17 - serde = { version = "1.0", features = ["derive"] } 18 18 - serde_json = "1.0" 19 19 - serde_with = "3.16" 20 20 - sha1 = "0.11.0-rc.5" 21 21 - smol_str = "0.2" 22 22 - strsim = "0.11" 23 23 - thiserror = "2.0" 24 24 - tokio = { version = "1.0", features = ["full"] } 25 25 - tower-http = { version = "0.6", features = ["compression-full"] } 26 26 - tracing = "0.1" 27 27 - tracing-subscriber = "0.3" 47 47 + ahash.workspace = true 48 48 + anyhow.workspace = true 49 49 + askama.workspace = true 50 50 + askama_web.workspace = true 51 51 + axum.workspace = true 52 52 + clap.workspace = true 53 53 + crab_nbt.workspace = true 54 54 + hex.workspace = true 55 55 + html-escape.workspace = true 56 56 + lru.workspace = true 57 57 + nara_core.workspace = true 58 58 + nara_slurper_1_12_infinity.workspace = true 59 59 + nara_slurper_1_12_world.workspace = true 60 60 + serde.workspace = true 61 61 + serde_json.workspace = true 62 62 + serde_with.workspace = true 63 63 + sha1.workspace = true 64 64 + smol_str.workspace = true 65 65 + strsim.workspace = true 66 66 + thiserror.workspace = true 67 67 + tokio.workspace = true 68 68 + tower-http.workspace = true 69 69 + tracing.workspace = true 70 70 + tracing-subscriber.workspace = true

+1 -75

README.md

··· 1 1 # nara 2 2 3 3 - A web-based book archival/viewing tool for Minecraft 1.12.2 data exported via Infinity Item Editor. 4 4 - 5 5 - ## Prerequisites 6 6 - 7 7 - - [Rust toolchain][rust] (to compile) 8 8 - - [Minecraft: Java Edition][mc] (1.12.2) 9 9 - - [Minecraft Forge for 1.12.2][forge] 10 10 - - [Infinity Item Editor][iie] mod 11 11 - 12 12 - ## Usage 13 13 - 14 14 - ### 1. Build 15 15 - 16 16 - ```sh 17 17 - cargo build --release 18 18 - ```` 19 19 - 20 20 - The binary will be in `target/release/` (`nara` or `nara.exe`). 21 21 - 22 22 - ### 2. Export books from Minecraft 23 23 - 24 24 - 1. Install the [Infinity Item Editor][iie] mod for Minecraft 1.12.2. 25 25 - 26 26 - 2. In Minecraft (with the mod installed), put your written books into Shulker Boxes (the colour of the Shulker Boxes does not matter). 27 27 - 28 28 - 3. Rename each shulker box in an anvil as: 29 29 - 30 30 - `CATEGORY_NAME ID` 31 31 - 32 32 - Example for a category named “Fiction”: 33 33 - 34 34 - `Fiction 1`, `Fiction 2`, `Fiction 3` 35 35 - 36 36 - 4. Save each shulker box using Infinity Item Editor (default keybind: `G`, configurable in Controls). 37 37 - 38 38 - Infinity Item Editor writes exports into `realm.nbt`. 39 39 - 40 40 - ### 3. Run 41 41 - 42 42 - 1. Make a new directory to hold both the app and the exported data. 43 43 - 2. Copy the `nara` binary into it. 44 44 - 3. Copy `realm.nbt` into it from your Minecraft directory: 45 45 - 46 46 - * **Windows:** `%AppData%\.minecraft\infinity-data\realm.nbt` 47 47 - * **Linux:** `~/.minecraft/infinity-data/realm.nbt` 48 48 - * **macOS:** `~/Library/Application Support/minecraft/infinity-data/realm.nbt` 49 49 - 50 50 - **macOS/Linux** 51 51 - 52 52 - ```sh 53 53 - ./nara 54 54 - ``` 55 55 - 56 56 - **Windows** 57 57 - 58 58 - ```bat 59 59 - nara.exe 60 60 - ``` 61 61 - 62 62 - nara will print a local URL in the terminal - open it in your browser. 63 63 - 64 64 - ## Customization 65 65 - 66 66 - All customization is via CLI flags: 67 67 - 68 68 - ```sh 69 69 - ./nara --help 70 70 - ``` 71 71 - 72 72 - Open an issue if anything is unclear. 73 73 - 74 74 - [rust]: https://rustup.rs/ "rustup.rs - the Rust toolchain installer" 75 75 - [mc]: https://minecraft.net/ "Minecraft" 76 76 - [forge]: https://files.minecraftforge.net/net/minecraftforge/forge/index_1.12.2.html "Downloads for Minecraft Forge for 1.12.2" 77 77 - [iie]: https://modrinth.com/mod/infinity-item-editor/version/0.15 "modrinth.com | 0.15 - Infinity Item Editor" 3 3 + A cross-version Minecraft written book archiver and viewer.

+8 -4

justfile

··· 13 13 @cargo run --release -- {{ args }} 14 14 15 15 lint: 16 16 - @cargo clippy 17 17 - 16 16 + @cargo clippy --workspace 17 17 + 18 18 alias b := build 19 19 20 20 build: 21 21 @cargo build --release 22 22 23 23 + review: 24 24 + @cargo insta review --workspace 25 25 + 23 26 test: 24 24 - @cargo test 27 27 + @cargo nextest r --workspace 25 28 26 26 - ok: lint test 29 29 + ok: lint test 30 30 + @cargo fmt --check

+17

nara_core/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_core" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + hex.workspace = true 8 8 + nara_io.workspace = true 9 9 + serde.workspace = true 10 10 + serde_json.workspace = true 11 11 + serde_with.workspace = true 12 12 + sha1.workspace = true 13 13 + uuid.workspace = true 14 14 + 15 15 + [dev-dependencies] 16 16 + insta.workspace = true 17 17 + serde_json.workspace = true

+5

nara_core/README.md

··· 1 1 + # nara_core 2 2 + 3 3 + This is intended to be a 1:1 model of Minecraft: Java Edition's [text component format][text]. 4 4 + 5 5 + [text]: https://minecraft.wiki/w/Text_component_format

+154

nara_core/src/book.rs

··· 1 1 + use serde::{Deserialize, Deserializer, Serialize, Serializer}; 2 2 + use sha1::Digest as _; 3 3 + use uuid::Uuid; 4 4 + 5 5 + use crate::component::{Component, ComponentObject}; 6 6 + 7 7 + pub type BookHash = [u8; 20]; 8 8 + 9 9 + #[derive(Debug, Clone, Serialize, Deserialize)] 10 10 + pub struct Book { 11 11 + pub metadata: BookMetadata, 12 12 + pub content: BookContent, 13 13 + } 14 14 + 15 15 + impl Book { 16 16 + /// Computes the hash of the book's contents. 17 17 + /// 18 18 + /// Metadata (such as source, generation, or resolved flag) is not taken 19 19 + /// into account when calculating the hash. 20 20 + pub fn hash(&self) -> BookHash { 21 21 + self.content.hash() 22 22 + } 23 23 + } 24 24 + 25 25 + #[derive(Debug, Clone, Serialize, Deserialize)] 26 26 + pub struct BookMetadata { 27 27 + pub source: BookSource, 28 28 + } 29 29 + 30 30 + #[derive(Debug, Clone, Serialize, Deserialize)] 31 31 + #[serde(tag = "type", rename_all = "snake_case")] 32 32 + pub enum BookSource { 33 33 + /// From an Infinity Item Editor realm file. 34 34 + InfinityRealm, 35 35 + /// From a player's save data. 36 36 + PlayerData { 37 37 + uuid: Uuid, 38 38 + inventory: PlayerInventoryKind, 39 39 + slot: i8, 40 40 + }, 41 41 + /// From a placed block entity, such as a chest. 42 42 + BlockEntity { 43 43 + dimension: String, 44 44 + id: String, 45 45 + x: i32, 46 46 + y: i32, 47 47 + z: i32, 48 48 + slot: i8, 49 49 + }, 50 50 + Entity { 51 51 + dimension: String, 52 52 + id: String, 53 53 + x: f64, 54 54 + y: f64, 55 55 + z: f64, 56 56 + }, 57 57 + EntityInventory { 58 58 + dimension: String, 59 59 + id: String, 60 60 + x: f64, 61 61 + y: f64, 62 62 + z: f64, 63 63 + slot: i8, 64 64 + }, 65 65 + /// Inside an item at `slot` within another container. 66 66 + ItemBlockEntity { 67 67 + id: String, 68 68 + slot: i8, 69 69 + within: Box<BookSource>, 70 70 + }, 71 71 + } 72 72 + 73 73 + #[derive(Debug, Clone, Copy, Serialize, Deserialize)] 74 74 + #[serde(rename_all = "snake_case")] 75 75 + pub enum PlayerInventoryKind { 76 76 + Inventory, 77 77 + EnderChest, 78 78 + } 79 79 + 80 80 + #[derive(Debug, Clone, Serialize, Deserialize)] 81 81 + #[serde(rename_all = "snake_case")] 82 82 + pub struct BookContent { 83 83 + pub author: String, 84 84 + #[serde( 85 85 + serialize_with = "serialize_pages", 86 86 + deserialize_with = "deserialize_pages" 87 87 + )] 88 88 + pub pages: Vec<Component>, 89 89 + pub title: String, 90 90 + #[serde(default)] 91 91 + pub generation: BookGeneration, 92 92 + #[serde(default)] 93 93 + pub resolved: bool, 94 94 + } 95 95 + 96 96 + fn serialize_pages<S: Serializer>( 97 97 + pages: &[Component], 98 98 + serializer: S, 99 99 + ) -> Result<S::Ok, S::Error> { 100 100 + pages 101 101 + .iter() 102 102 + .map(|c| c.clone().into_object()) 103 103 + .collect::<Vec<ComponentObject>>() 104 104 + .serialize(serializer) 105 105 + } 106 106 + 107 107 + fn deserialize_pages<'de, D: Deserializer<'de>>( 108 108 + deserializer: D, 109 109 + ) -> Result<Vec<Component>, D::Error> { 110 110 + Vec::<ComponentObject>::deserialize(deserializer).map(|objs| { 111 111 + objs.into_iter() 112 112 + .map(|o| Component::Object(Box::new(o))) 113 113 + .collect() 114 114 + }) 115 115 + } 116 116 + 117 117 + impl BookContent { 118 118 + /// Computes the hash of the book's contents. 119 119 + /// 120 120 + /// Metadata (such as generation or resolved flag) is not taken into account 121 121 + /// when calculating the hash. 122 122 + pub fn hash(&self) -> BookHash { 123 123 + let mut ctx = sha1::Sha1::new(); 124 124 + 125 125 + #[inline(always)] 126 126 + fn put_str(ctx: &mut sha1::Sha1, s: &str) { 127 127 + ctx.update(s.as_bytes()); 128 128 + } 129 129 + 130 130 + #[inline(always)] 131 131 + fn put_vec_page(ctx: &mut sha1::Sha1, v: &[Component]) { 132 132 + for c in v { 133 133 + let s = c.normalize(); 134 134 + put_str(ctx, &s); 135 135 + } 136 136 + } 137 137 + 138 138 + put_str(&mut ctx, &self.author); 139 139 + put_str(&mut ctx, &self.title); 140 140 + put_vec_page(&mut ctx, &self.pages); 141 141 + 142 142 + ctx.finalize().0 143 143 + } 144 144 + } 145 145 + 146 146 + #[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)] 147 147 + #[serde(rename_all = "snake_case")] 148 148 + pub enum BookGeneration { 149 149 + #[default] 150 150 + Original, 151 151 + CopyOfOriginal, 152 152 + CopyOfCopy, 153 153 + Tattered, 154 154 + }

+165

nara_core/src/color.rs

··· 1 1 + use serde::{Deserialize, Serialize}; 2 2 + 3 3 + #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] 4 4 + #[serde(rename_all = "snake_case")] 5 5 + pub enum NamedColor { 6 6 + Black, 7 7 + DarkBlue, 8 8 + DarkGreen, 9 9 + DarkAqua, 10 10 + DarkRed, 11 11 + DarkPurple, 12 12 + Gold, 13 13 + Gray, 14 14 + DarkGray, 15 15 + Blue, 16 16 + Green, 17 17 + Aqua, 18 18 + Red, 19 19 + LightPurple, 20 20 + Yellow, 21 21 + White, 22 22 + } 23 23 + 24 24 + impl NamedColor { 25 25 + pub fn as_hex(&self) -> [u8; 3] { 26 26 + match self { 27 27 + NamedColor::Black => [0x00, 0x00, 0x00], 28 28 + NamedColor::DarkBlue => [0x00, 0x00, 0xAA], 29 29 + NamedColor::DarkGreen => [0x00, 0xAA, 0x00], 30 30 + NamedColor::DarkAqua => [0x00, 0xAA, 0xAA], 31 31 + NamedColor::DarkRed => [0xAA, 0x00, 0x00], 32 32 + NamedColor::DarkPurple => [0xAA, 0x00, 0xAA], 33 33 + NamedColor::Gold => [0xFF, 0xAA, 0x00], 34 34 + NamedColor::Gray => [0xAA, 0xAA, 0xAA], 35 35 + NamedColor::DarkGray => [0x55, 0x55, 0x55], 36 36 + NamedColor::Blue => [0x55, 0x55, 0xFF], 37 37 + NamedColor::Green => [0x55, 0xFF, 0x55], 38 38 + NamedColor::Aqua => [0x55, 0xFF, 0xFF], 39 39 + NamedColor::Red => [0xFF, 0x55, 0x55], 40 40 + NamedColor::LightPurple => [0xFF, 0x55, 0xFF], 41 41 + NamedColor::Yellow => [0xFF, 0xFF, 0x55], 42 42 + NamedColor::White => [0xFF, 0xFF, 0xFF], 43 43 + } 44 44 + } 45 45 + 46 46 + pub fn as_hex_string(&self) -> String { 47 47 + hex_bytes_to_string(self.as_hex()) 48 48 + } 49 49 + 50 50 + pub fn from_hex(hex: [u8; 3]) -> Option<Self> { 51 51 + match hex { 52 52 + [0x00, 0x00, 0x00] => Some(NamedColor::Black), 53 53 + [0x00, 0x00, 0xAA] => Some(NamedColor::DarkBlue), 54 54 + [0x00, 0xAA, 0x00] => Some(NamedColor::DarkGreen), 55 55 + [0x00, 0xAA, 0xAA] => Some(NamedColor::DarkAqua), 56 56 + [0xAA, 0x00, 0x00] => Some(NamedColor::DarkRed), 57 57 + [0xAA, 0x00, 0xAA] => Some(NamedColor::DarkPurple), 58 58 + [0xFF, 0xAA, 0x00] => Some(NamedColor::Gold), 59 59 + [0xAA, 0xAA, 0xAA] => Some(NamedColor::Gray), 60 60 + [0x55, 0x55, 0x55] => Some(NamedColor::DarkGray), 61 61 + [0x55, 0x55, 0xFF] => Some(NamedColor::Blue), 62 62 + [0x55, 0xFF, 0x55] => Some(NamedColor::Green), 63 63 + [0x55, 0xFF, 0xFF] => Some(NamedColor::Aqua), 64 64 + [0xFF, 0x55, 0x55] => Some(NamedColor::Red), 65 65 + [0xFF, 0x55, 0xFF] => Some(NamedColor::LightPurple), 66 66 + [0xFF, 0xFF, 0x55] => Some(NamedColor::Yellow), 67 67 + [0xFF, 0xFF, 0xFF] => Some(NamedColor::White), 68 68 + _ => None, 69 69 + } 70 70 + } 71 71 + 72 72 + pub fn from_name(s: &str) -> Option<Self> { 73 73 + let normalized = s.trim().to_ascii_lowercase().replace([' ', '-'], "_"); 74 74 + 75 75 + match normalized.as_str() { 76 76 + "black" => Some(NamedColor::Black), 77 77 + "dark_blue" => Some(NamedColor::DarkBlue), 78 78 + "dark_green" => Some(NamedColor::DarkGreen), 79 79 + "dark_aqua" => Some(NamedColor::DarkAqua), 80 80 + "dark_red" => Some(NamedColor::DarkRed), 81 81 + "dark_purple" => Some(NamedColor::DarkPurple), 82 82 + "gold" => Some(NamedColor::Gold), 83 83 + "gray" | "grey" => Some(NamedColor::Gray), 84 84 + "dark_gray" | "dark_grey" => Some(NamedColor::DarkGray), 85 85 + "blue" => Some(NamedColor::Blue), 86 86 + "green" => Some(NamedColor::Green), 87 87 + "aqua" => Some(NamedColor::Aqua), 88 88 + "red" => Some(NamedColor::Red), 89 89 + "light_purple" => Some(NamedColor::LightPurple), 90 90 + "yellow" => Some(NamedColor::Yellow), 91 91 + "white" => Some(NamedColor::White), 92 92 + _ => None, 93 93 + } 94 94 + } 95 95 + } 96 96 + 97 97 + #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] 98 98 + #[serde(try_from = "String", into = "String")] 99 99 + pub enum Color { 100 100 + Named(NamedColor), 101 101 + Hex(String), 102 102 + } 103 103 + 104 104 + impl Color { 105 105 + pub fn as_hex(&self) -> Result<[u8; 3], String> { 106 106 + match self { 107 107 + Color::Named(named) => Ok(named.as_hex()), 108 108 + Color::Hex(hex) => hex_string_to_bytes(hex), 109 109 + } 110 110 + } 111 111 + 112 112 + pub fn as_hex_string(&self) -> String { 113 113 + match self { 114 114 + Color::Named(named) => named.as_hex_string(), 115 115 + Color::Hex(hex) => match hex_string_to_bytes(hex) { 116 116 + Ok(bytes) => hex_bytes_to_string(bytes), 117 117 + Err(_) => hex.clone(), 118 118 + }, 119 119 + } 120 120 + } 121 121 + } 122 122 + 123 123 + impl TryFrom<String> for Color { 124 124 + type Error = String; 125 125 + 126 126 + fn try_from(value: String) -> Result<Self, Self::Error> { 127 127 + if let Some(named) = NamedColor::from_name(&value) { 128 128 + return Ok(Color::Named(named)); 129 129 + } 130 130 + 131 131 + let bytes = hex_string_to_bytes(&value)?; 132 132 + if let Some(named) = NamedColor::from_hex(bytes) { 133 133 + Ok(Color::Named(named)) 134 134 + } else { 135 135 + Ok(Color::Hex(hex_bytes_to_string(bytes))) 136 136 + } 137 137 + } 138 138 + } 139 139 + 140 140 + impl From<Color> for String { 141 141 + fn from(value: Color) -> Self { 142 142 + value.as_hex_string() 143 143 + } 144 144 + } 145 145 + 146 146 + fn hex_string_to_bytes(s: &str) -> Result<[u8; 3], String> { 147 147 + let s = s.trim().strip_prefix('#').unwrap_or(s.trim()); 148 148 + 149 149 + if s.len() != 6 { 150 150 + return Err(format!("expected 6 hex characters, got {}", s.len())); 151 151 + } 152 152 + 153 153 + let r = u8::from_str_radix(&s[0..2], 16) 154 154 + .map_err(|_| "invalid red channel".to_string())?; 155 155 + let g = u8::from_str_radix(&s[2..4], 16) 156 156 + .map_err(|_| "invalid green channel".to_string())?; 157 157 + let b = u8::from_str_radix(&s[4..6], 16) 158 158 + .map_err(|_| "invalid blue channel".to_string())?; 159 159 + 160 160 + Ok([r, g, b]) 161 161 + } 162 162 + 163 163 + fn hex_bytes_to_string(bytes: [u8; 3]) -> String { 164 164 + format!("#{:02X}{:02X}{:02X}", bytes[0], bytes[1], bytes[2]) 165 165 + }

+579

nara_core/src/component.rs

··· 1 1 + use serde::{ 2 2 + Deserialize, Deserializer, Serialize, 3 3 + de::{ 4 4 + MapAccess, SeqAccess, Visitor, 5 5 + value::{MapAccessDeserializer, SeqAccessDeserializer}, 6 6 + }, 7 7 + }; 8 8 + 9 9 + #[derive(Debug, Clone, Serialize)] 10 10 + #[serde(untagged)] 11 11 + pub enum Component { 12 12 + String(String), 13 13 + Object(Box<ComponentObject>), 14 14 + Array(Vec<Component>), 15 15 + } 16 16 + 17 17 + #[serde_with::skip_serializing_none] 18 18 + #[derive(Debug, Clone, Serialize, Deserialize)] 19 19 + pub struct ComponentObject { 20 20 + #[serde(flatten)] 21 21 + text: Option<TextComponent>, 22 22 + #[serde(flatten)] 23 23 + translation: Option<TranslationComponent>, 24 24 + // DO NOT FLATTEN THE SCORE COMPONENT 25 25 + score: Option<ScoreComponent>, 26 26 + #[serde(flatten)] 27 27 + selector: Option<SelectorComponent>, 28 28 + #[serde(flatten)] 29 29 + keybind: Option<KeybindComponent>, 30 30 + #[serde(flatten)] 31 31 + nbt: Option<NbtComponent>, 32 32 + #[serde(flatten)] 33 33 + object: Option<ObjectComponent>, 34 34 + #[serde(flatten)] 35 35 + formatting: ComponentFormatting, 36 36 + #[serde(default, rename = "extra", skip_serializing_if = "Vec::is_empty")] 37 37 + children: Vec<Component>, 38 38 + } 39 39 + 40 40 + #[serde_with::skip_serializing_none] 41 41 + #[derive(Debug, Clone, Serialize, Deserialize)] 42 42 + pub struct ComponentFormatting { 43 43 + color: Option<crate::color::Color>, 44 44 + font: Option<String>, 45 45 + bold: Option<bool>, 46 46 + italic: Option<bool>, 47 47 + underlined: Option<bool>, 48 48 + strikethrough: Option<bool>, 49 49 + obfuscated: Option<bool>, 50 50 + } 51 51 + 52 52 + #[derive(Debug, Clone, Serialize, Deserialize)] 53 53 + pub struct TextComponent { 54 54 + text: String, 55 55 + } 56 56 + 57 57 + #[serde_with::skip_serializing_none] 58 58 + #[derive(Debug, Clone, Serialize, Deserialize)] 59 59 + pub struct TranslationComponent { 60 60 + translate: String, 61 61 + fallback: Option<String>, 62 62 + #[serde(default, skip_serializing_if = "Vec::is_empty")] 63 63 + with: Vec<Component>, 64 64 + } 65 65 + 66 66 + #[serde_with::skip_serializing_none] 67 67 + #[derive(Debug, Clone, Serialize, Deserialize)] 68 68 + pub struct ScoreComponent { 69 69 + name: String, 70 70 + objective: String, 71 71 + } 72 72 + 73 73 + #[serde_with::skip_serializing_none] 74 74 + #[derive(Debug, Clone, Serialize, Deserialize)] 75 75 + pub struct SelectorComponent { 76 76 + selector: String, 77 77 + separator: Option<Box<Component>>, 78 78 + } 79 79 + 80 80 + #[serde_with::skip_serializing_none] 81 81 + #[derive(Debug, Clone, Serialize, Deserialize)] 82 82 + pub struct KeybindComponent { 83 83 + keybind: String, 84 84 + } 85 85 + 86 86 + #[derive(Debug, Clone, Serialize, Deserialize)] 87 87 + #[serde(rename_all = "snake_case")] 88 88 + pub enum NbtComponentSource { 89 89 + Block, 90 90 + Entity, 91 91 + Storage, 92 92 + } 93 93 + 94 94 + #[serde_with::skip_serializing_none] 95 95 + #[derive(Debug, Clone, Serialize, Deserialize)] 96 96 + pub struct NbtComponent { 97 97 + source: Option<NbtComponentSource>, 98 98 + #[serde(rename = "nbt")] 99 99 + path: String, 100 100 + interpret: Option<bool>, 101 101 + separator: Option<Box<Component>>, 102 102 + entity: Option<String>, 103 103 + block: Option<String>, 104 104 + storage: Option<String>, 105 105 + } 106 106 + 107 107 + #[derive(Debug, Clone, Serialize, Deserialize)] 108 108 + #[serde(tag = "object", rename_all = "snake_case")] 109 109 + pub enum ObjectComponent { 110 110 + Atlas(AtlasObject), 111 111 + Player(PlayerObject), 112 112 + } 113 113 + 114 114 + #[serde_with::skip_serializing_none] 115 115 + #[derive(Debug, Clone, Serialize, Deserialize)] 116 116 + pub struct AtlasObject { 117 117 + atlas: Option<String>, 118 118 + sprite: String, 119 119 + } 120 120 + 121 121 + #[derive(Debug, Clone, Serialize, Deserialize)] 122 122 + #[serde(untagged)] 123 123 + pub enum PlayerProfileOrName { 124 124 + Profile(crate::profile::PlayerProfile), 125 125 + Name(String), 126 126 + } 127 127 + 128 128 + #[serde_with::skip_serializing_none] 129 129 + #[derive(Debug, Clone, Serialize, Deserialize)] 130 130 + pub struct PlayerObject { 131 131 + player: PlayerProfileOrName, 132 132 + hat: Option<bool>, 133 133 + } 134 134 + 135 135 + impl Component { 136 136 + /// Recursively converts any `Component` into its `ComponentObject` form, 137 137 + /// collapsing `String` variants into `{text: "..."}` objects and flattening 138 138 + /// `Array` variants so the first element becomes the root and the rest 139 139 + /// become children. 140 140 + pub fn into_object(self) -> ComponentObject { 141 141 + match self { 142 142 + Component::String(s) => raw_text_object(s, None), 143 143 + Component::Object(mut obj) => { 144 144 + obj.children = obj 145 145 + .children 146 146 + .into_iter() 147 147 + .map(|c| Component::Object(Box::new(c.into_object()))) 148 148 + .collect(); 149 149 + *obj 150 150 + } 151 151 + Component::Array(mut items) => { 152 152 + if items.is_empty() { 153 153 + return raw_text_object(String::new(), None); 154 154 + } 155 155 + let mut obj = items.remove(0).into_object(); 156 156 + obj.children.extend( 157 157 + items 158 158 + .into_iter() 159 159 + .map(|c| Component::Object(Box::new(c.into_object()))), 160 160 + ); 161 161 + obj 162 162 + } 163 163 + } 164 164 + } 165 165 + 166 166 + pub fn to_plain_text(&self) -> String { 167 167 + match self { 168 168 + Component::String(s) => s.clone(), 169 169 + Component::Array(items) => { 170 170 + items.iter().map(|c| c.to_plain_text()).collect() 171 171 + } 172 172 + Component::Object(obj) => { 173 173 + let mut s = 174 174 + obj.text.as_ref().map_or(String::new(), |t| t.text.clone()); 175 175 + for child in &obj.children { 176 176 + s.push_str(&child.to_plain_text()); 177 177 + } 178 178 + s 179 179 + } 180 180 + } 181 181 + } 182 182 + 183 183 + pub fn normalize(&self) -> String { 184 184 + let text = self.to_plain_text(); 185 185 + strip_section_codes(&text) 186 186 + } 187 187 + } 188 188 + 189 189 + /// Removes legacy section symbol formatting codes. 190 190 + fn strip_section_codes(s: &str) -> String { 191 191 + let mut out = String::with_capacity(s.len()); 192 192 + let mut chars = s.chars(); 193 193 + while let Some(c) = chars.next() { 194 194 + if c == SECTION_SIGN { 195 195 + // Skip formatting code character if present. 196 196 + chars.next(); 197 197 + continue; 198 198 + } 199 199 + out.push(c); 200 200 + } 201 201 + out 202 202 + } 203 203 + 204 204 + /// Parses a page string into a component, handling stringified JSON. 205 205 + pub fn parse_component_from_str(raw: &str) -> Component { 206 206 + let mut current = raw.trim().to_string(); 207 207 + if current.is_empty() { 208 208 + return Component::String(String::new()); 209 209 + } 210 210 + if let Some(extracted) = extract_text_prefix(&current) { 211 211 + return expand_legacy(legacy_or_plain(&extracted)); 212 212 + } 213 213 + 214 214 + // Try parsing as JSON component once. 215 215 + if let Ok(component) = serde_json::from_str::<Component>(&current) { 216 216 + return expand_legacy(component); 217 217 + } 218 218 + 219 219 + // Try parsing as a JSON string, then re-parse if it was a JSON string that 220 220 + // itself contains JSON (stringified JSON). 221 221 + for _ in 0..3 { 222 222 + let s = match serde_json::from_str::<String>(&current) { 223 223 + Ok(v) => v, 224 224 + Err(_) => break, 225 225 + }; 226 226 + let s_trim = s.trim(); 227 227 + if looks_like_json(s_trim) { 228 228 + current = s_trim.to_string(); 229 229 + if let Ok(component) = serde_json::from_str::<Component>(&current) { 230 230 + return expand_legacy(component); 231 231 + } 232 232 + continue; 233 233 + } 234 234 + return expand_legacy(legacy_or_plain(&s)); 235 235 + } 236 236 + 237 237 + expand_legacy(legacy_or_plain(raw)) 238 238 + } 239 239 + 240 240 + fn looks_like_json(s: &str) -> bool { 241 241 + s.starts_with('{') || s.starts_with('[') 242 242 + } 243 243 + 244 244 + fn extract_text_prefix(s: &str) -> Option<String> { 245 245 + let s = s.trim_start(); 246 246 + if !s.starts_with("text") { 247 247 + return None; 248 248 + } 249 249 + let mut rest = s[4..].trim_start(); 250 250 + if rest.starts_with(':') { 251 251 + rest = rest[1..].trim_start(); 252 252 + } 253 253 + let start = rest.find('"')?; 254 254 + let rest = &rest[start..]; 255 255 + if let Ok(parsed) = serde_json::from_str::<String>(rest) { 256 256 + return Some(parsed); 257 257 + } 258 258 + if let Some(end) = rest[1..].rfind('"') { 259 259 + let slice = &rest[..end + 2]; 260 260 + if let Ok(parsed) = serde_json::from_str::<String>(slice) { 261 261 + return Some(parsed); 262 262 + } 263 263 + let content = &rest[1..end + 1]; 264 264 + return Some(unescape_json_string_lossy(content)); 265 265 + } 266 266 + None 267 267 + } 268 268 + 269 269 + fn unescape_json_string_lossy(s: &str) -> String { 270 270 + let mut out = String::with_capacity(s.len()); 271 271 + let mut chars = s.chars(); 272 272 + while let Some(c) = chars.next() { 273 273 + if c != '\\' { 274 274 + out.push(c); 275 275 + continue; 276 276 + } 277 277 + match chars.next() { 278 278 + Some('"') => out.push('"'), 279 279 + Some('\\') => out.push('\\'), 280 280 + Some('/') => out.push('/'), 281 281 + Some('b') => out.push('\u{0008}'), 282 282 + Some('f') => out.push('\u{000C}'), 283 283 + Some('n') => out.push('\n'), 284 284 + Some('r') => out.push('\r'), 285 285 + Some('t') => out.push('\t'), 286 286 + Some('u') => { 287 287 + let mut hex = String::new(); 288 288 + for _ in 0..4 { 289 289 + if let Some(h) = chars.next() { 290 290 + hex.push(h); 291 291 + } else { 292 292 + break; 293 293 + } 294 294 + } 295 295 + if let Ok(code) = u16::from_str_radix(&hex, 16) 296 296 + && let Some(ch) = char::from_u32(code as u32) 297 297 + { 298 298 + out.push(ch); 299 299 + } 300 300 + } 301 301 + Some(other) => out.push(other), 302 302 + None => break, 303 303 + } 304 304 + } 305 305 + out 306 306 + } 307 307 + 308 308 + fn legacy_or_plain(s: &str) -> Component { 309 309 + if s.contains(SECTION_SIGN) { 310 310 + parse_legacy_section_text(s) 311 311 + } else { 312 312 + Component::String(s.to_string()) 313 313 + } 314 314 + } 315 315 + 316 316 + fn expand_legacy(component: Component) -> Component { 317 317 + match component { 318 318 + Component::String(s) => legacy_or_plain(&s), 319 319 + Component::Array(items) => { 320 320 + Component::Array(items.into_iter().map(expand_legacy).collect()) 321 321 + } 322 322 + Component::Object(mut obj) => { 323 323 + if obj.translation.is_none() 324 324 + && let Some(ref tc) = obj.text 325 325 + && tc.text.contains('§') 326 326 + { 327 327 + let expanded = parse_legacy_section_text_with_color( 328 328 + &tc.text.clone(), 329 329 + obj.formatting.color.clone(), 330 330 + ); 331 331 + return merge_expanded_with_extra(expanded, obj.children); 332 332 + } 333 333 + obj.children = 334 334 + obj.children.into_iter().map(expand_legacy).collect(); 335 335 + if let Some(ref mut trans) = obj.translation { 336 336 + trans.with = trans.with.drain(..).map(expand_legacy).collect(); 337 337 + } 338 338 + Component::Object(obj) 339 339 + } 340 340 + } 341 341 + } 342 342 + 343 343 + fn merge_expanded_with_extra( 344 344 + expanded: Component, 345 345 + extra: Vec<Component>, 346 346 + ) -> Component { 347 347 + if extra.is_empty() { 348 348 + return expanded; 349 349 + } 350 350 + match expanded { 351 351 + Component::Array(mut items) => { 352 352 + items.extend(extra.into_iter().map(expand_legacy)); 353 353 + Component::Array(items) 354 354 + } 355 355 + other => Component::Array( 356 356 + std::iter::once(other) 357 357 + .chain(extra.into_iter().map(expand_legacy)) 358 358 + .collect(), 359 359 + ), 360 360 + } 361 361 + } 362 362 + 363 363 + fn raw_text_object( 364 364 + text: String, 365 365 + color: Option<crate::color::Color>, 366 366 + ) -> ComponentObject { 367 367 + ComponentObject { 368 368 + text: Some(TextComponent { text }), 369 369 + translation: None, 370 370 + score: None, 371 371 + selector: None, 372 372 + keybind: None, 373 373 + nbt: None, 374 374 + object: None, 375 375 + formatting: ComponentFormatting { 376 376 + color, 377 377 + font: None, 378 378 + bold: None, 379 379 + italic: None, 380 380 + underlined: None, 381 381 + strikethrough: None, 382 382 + obfuscated: None, 383 383 + }, 384 384 + children: Vec::new(), 385 385 + } 386 386 + } 387 387 + 388 388 + fn make_text_object( 389 389 + text: String, 390 390 + color: Option<crate::color::Color>, 391 391 + ) -> Component { 392 392 + Component::Object(Box::new(raw_text_object(text, color))) 393 393 + } 394 394 + 395 395 + fn parse_legacy_section_text(s: &str) -> Component { 396 396 + parse_legacy_section_text_with_color(s, None) 397 397 + } 398 398 + 399 399 + fn parse_legacy_section_text_with_color( 400 400 + s: &str, 401 401 + initial_color: Option<crate::color::Color>, 402 402 + ) -> Component { 403 403 + let mut out: Vec<Component> = Vec::new(); 404 404 + let mut buf = String::new(); 405 405 + let mut color: Option<crate::color::Color> = initial_color; 406 406 + 407 407 + let mut chars = s.chars(); 408 408 + while let Some(c) = chars.next() { 409 409 + if c == SECTION_SIGN 410 410 + && let Some(code) = chars.next() 411 411 + { 412 412 + if !buf.is_empty() { 413 413 + out.push(make_text_object( 414 414 + std::mem::take(&mut buf), 415 415 + color.clone(), 416 416 + )); 417 417 + } 418 418 + 419 419 + match legacy_color_name(code) { 420 420 + Some(name) => { 421 421 + color = crate::color::Color::try_from(name).ok(); 422 422 + } 423 423 + None => { 424 424 + if code == LEGACY_RESET_LOWER || code == LEGACY_RESET_UPPER 425 425 + { 426 426 + color = None; 427 427 + } 428 428 + } 429 429 + } 430 430 + continue; 431 431 + } 432 432 + buf.push(c); 433 433 + } 434 434 + 435 435 + if !buf.is_empty() { 436 436 + out.push(make_text_object(buf, color)); 437 437 + } 438 438 + 439 439 + if out.is_empty() { 440 440 + Component::String(String::new()) 441 441 + } else if out.len() == 1 { 442 442 + out.pop() 443 443 + .unwrap_or_else(|| Component::String(String::new())) 444 444 + } else { 445 445 + Component::Array(out) 446 446 + } 447 447 + } 448 448 + 449 449 + fn legacy_color_name(code: char) -> Option<String> { 450 450 + let name = match code { 451 451 + '0' => "black", 452 452 + '1' => "dark_blue", 453 453 + '2' => "dark_green", 454 454 + '3' => "dark_aqua", 455 455 + '4' => "dark_red", 456 456 + '5' => "dark_purple", 457 457 + '6' => "gold", 458 458 + '7' => "gray", 459 459 + '8' => "dark_gray", 460 460 + '9' => "blue", 461 461 + 'a' | 'A' => "green", 462 462 + 'b' | 'B' => "aqua", 463 463 + 'c' | 'C' => "red", 464 464 + 'd' | 'D' => "light_purple", 465 465 + 'e' | 'E' => "yellow", 466 466 + 'f' | 'F' => "white", 467 467 + _ => return None, 468 468 + }; 469 469 + Some(name.to_string()) 470 470 + } 471 471 + 472 472 + const SECTION_SIGN: char = '§'; 473 473 + const LEGACY_RESET_LOWER: char = 'r'; 474 474 + const LEGACY_RESET_UPPER: char = 'R'; 475 475 + 476 476 + impl<'de> Deserialize<'de> for Component { 477 477 + fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 478 478 + where 479 479 + D: Deserializer<'de>, 480 480 + { 481 481 + struct ComponentVisitor; 482 482 + 483 483 + impl<'de> Visitor<'de> for ComponentVisitor { 484 484 + type Value = Component; 485 485 + 486 486 + fn expecting( 487 487 + &self, 488 488 + f: &mut std::fmt::Formatter, 489 489 + ) -> std::fmt::Result { 490 490 + f.write_str("a Minecraft text component") 491 491 + } 492 492 + 493 493 + fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> 494 494 + where 495 495 + E: serde::de::Error, 496 496 + { 497 497 + Ok(parse_component_from_str(v)) 498 498 + } 499 499 + 500 500 + fn visit_string<E>(self, v: String) -> Result<Self::Value, E> 501 501 + where 502 502 + E: serde::de::Error, 503 503 + { 504 504 + Ok(parse_component_from_str(&v)) 505 505 + } 506 506 + 507 507 + fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> 508 508 + where 509 509 + A: SeqAccess<'de>, 510 510 + { 511 511 + let items = Vec::<Component>::deserialize( 512 512 + SeqAccessDeserializer::new(seq), 513 513 + )?; 514 514 + Ok(expand_legacy(Component::Array(items))) 515 515 + } 516 516 + 517 517 + fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error> 518 518 + where 519 519 + A: MapAccess<'de>, 520 520 + { 521 521 + let obj = ComponentObject::deserialize( 522 522 + MapAccessDeserializer::new(map), 523 523 + )?; 524 524 + Ok(expand_legacy(Component::Object(Box::new(obj)))) 525 525 + } 526 526 + } 527 527 + 528 528 + deserializer.deserialize_any(ComponentVisitor) 529 529 + } 530 530 + } 531 531 + 532 532 + #[cfg(test)] 533 533 + mod tests { 534 534 + use super::*; 535 535 + 536 536 + #[test] 537 537 + fn normalize_plain_text() { 538 538 + let c = parse_component_from_str("hello world"); 539 539 + assert_eq!(c.normalize(), "hello world"); 540 540 + } 541 541 + 542 542 + #[test] 543 543 + fn normalize_json_object() { 544 544 + let c = parse_component_from_str(r#"{"text":"hello §aworld"}"#); 545 545 + assert_eq!(c.normalize(), "hello world"); 546 546 + } 547 547 + 548 548 + #[test] 549 549 + fn normalize_json_array() { 550 550 + let c = 551 551 + parse_component_from_str(r#"[{"text":"hi "},{"text":"there"}]"#); 552 552 + assert_eq!(c.normalize(), "hi there"); 553 553 + } 554 554 + 555 555 + #[test] 556 556 + fn normalize_stringified_json() { 557 557 + let c = parse_component_from_str(r#""{\"text\":\"hello\"}""#); 558 558 + assert_eq!(c.normalize(), "hello"); 559 559 + } 560 560 + 561 561 + #[test] 562 562 + fn legacy_section_colors() { 563 563 + let c = parse_component_from_str("hi §aworld"); 564 564 + let text = c.to_plain_text(); 565 565 + assert_eq!(text, "hi world"); 566 566 + match c { 567 567 + Component::Array(items) => { 568 568 + assert_eq!(items.len(), 2); 569 569 + } 570 570 + _ => panic!("expected array component"), 571 571 + } 572 572 + } 573 573 + 574 574 + #[test] 575 575 + fn legacy_text_prefix() { 576 576 + let c = parse_component_from_str("text\t\"hello §aworld\""); 577 577 + assert_eq!(c.normalize(), "hello world"); 578 578 + } 579 579 + }

+76

nara_core/src/lib.rs

··· 1 1 + use std::{collections::HashMap, path::Path}; 2 2 + 3 3 + use ::uuid::Uuid; 4 4 + use serde::{Deserialize, Serialize}; 5 5 + use serde_with::{hex::Hex, serde_as}; 6 6 + 7 7 + use crate::book::{Book, BookHash}; 8 8 + 9 9 + pub mod book; 10 10 + pub mod color; 11 11 + pub mod component; 12 12 + pub mod profile; 13 13 + pub mod uuid; 14 14 + 15 15 + #[serde_as] 16 16 + #[derive(Debug, Default, Serialize, Deserialize)] 17 17 + pub struct BookContainer { 18 18 + #[serde_as(as = "HashMap<Hex, _>")] 19 19 + books: HashMap<BookHash, Book>, 20 20 + } 21 21 + 22 22 + impl BookContainer { 23 23 + /// Opens an existing container at `path`, or returns an empty one if the 24 24 + /// file does not exist yet. 25 25 + pub fn open_or_new<P>(path: P) -> nara_io::Result<BookContainer> 26 26 + where 27 27 + P: AsRef<Path>, 28 28 + { 29 29 + if path.as_ref().exists() { 30 30 + let buffer = std::fs::read(path)?; 31 31 + nara_io::read_json_gz(&buffer) 32 32 + } else { 33 33 + Ok(Self::default()) 34 34 + } 35 35 + } 36 36 + 37 37 + pub fn read<P>(path: P) -> nara_io::Result<BookContainer> 38 38 + where 39 39 + P: AsRef<Path>, 40 40 + { 41 41 + let buffer = std::fs::read(path)?; 42 42 + nara_io::read_json_gz(&buffer) 43 43 + } 44 44 + 45 45 + /// Adds a book. Returns `true` if the book was new, `false` if it was 46 46 + /// already present (duplicate hash). 47 47 + pub fn add(&mut self, book: Book) -> bool { 48 48 + let hash = book.hash(); 49 49 + if self.books.contains_key(&hash) { 50 50 + return false; 51 51 + } 52 52 + self.books.insert(hash, book); 53 53 + true 54 54 + } 55 55 + 56 56 + pub fn remove(&mut self, book: Book) { 57 57 + self.books.remove(&book.hash()); 58 58 + } 59 59 + 60 60 + pub fn books(&self) -> impl Iterator<Item = &Book> { 61 61 + self.books.values() 62 62 + } 63 63 + 64 64 + pub fn save<P>(&self, path: P) -> nara_io::Result<()> 65 65 + where 66 66 + P: AsRef<Path>, 67 67 + { 68 68 + let bytes = nara_io::write_json_gz(self)?; 69 69 + std::fs::write(path, bytes)?; 70 70 + Ok(()) 71 71 + } 72 72 + } 73 73 + 74 74 + pub fn i64_pair_to_uuid(most_significant: i64, least_signifcant: i64) -> Uuid { 75 75 + Uuid::from_u64_pair(most_significant as u64, least_signifcant as u64) 76 76 + }

+29

nara_core/src/profile.rs

··· 1 1 + use serde::{Deserialize, Serialize}; 2 2 + 3 3 + #[serde_with::skip_serializing_none] 4 4 + #[derive(Debug, Clone, Serialize, Deserialize)] 5 5 + pub struct PlayerProfile { 6 6 + name: Option<String>, 7 7 + id: Option<[i32; 4]>, // TODO(kokiriglade): use an actual UUID type 8 8 + #[serde(default, skip_serializing_if = "Vec::is_empty")] 9 9 + properties: Vec<PlayerProfileProperty>, 10 10 + texture: Option<String>, 11 11 + cape: Option<String>, 12 12 + elytra: Option<String>, 13 13 + model: Option<PlayerModel>, 14 14 + } 15 15 + 16 16 + #[serde_with::skip_serializing_none] 17 17 + #[derive(Debug, Clone, Serialize, Deserialize)] 18 18 + pub struct PlayerProfileProperty { 19 19 + name: String, 20 20 + value: String, 21 21 + signature: Option<String>, 22 22 + } 23 23 + 24 24 + #[derive(Debug, Clone, Copy, Serialize, Deserialize)] 25 25 + #[serde(rename_all = "snake_case")] 26 26 + pub enum PlayerModel { 27 27 + Slim, 28 28 + Wide, 29 29 + }

+67

nara_core/src/uuid.rs

··· 1 1 + use serde::{Deserialize, Deserializer, Serialize, Serializer}; 2 2 + use serde_with::{DeserializeAs, SerializeAs}; 3 3 + 4 4 + /// Usage: `#[serde_as(as = "UuidIntArray")]` or 5 5 + /// `#[serde_as(as = "Option<UuidIntArray>")]`. 6 6 + pub struct UuidIntArray; 7 7 + 8 8 + impl SerializeAs<::uuid::Uuid> for UuidIntArray { 9 9 + fn serialize_as<S>( 10 10 + uuid: &::uuid::Uuid, 11 11 + serializer: S, 12 12 + ) -> Result<S::Ok, S::Error> 13 13 + where 14 14 + S: Serializer, 15 15 + { 16 16 + let b = uuid.as_bytes(); 17 17 + let arr: [i32; 4] = [ 18 18 + i32::from_be_bytes([b[0], b[1], b[2], b[3]]), 19 19 + i32::from_be_bytes([b[4], b[5], b[6], b[7]]), 20 20 + i32::from_be_bytes([b[8], b[9], b[10], b[11]]), 21 21 + i32::from_be_bytes([b[12], b[13], b[14], b[15]]), 22 22 + ]; 23 23 + arr.serialize(serializer) 24 24 + } 25 25 + } 26 26 + 27 27 + impl<'de> DeserializeAs<'de, ::uuid::Uuid> for UuidIntArray { 28 28 + fn deserialize_as<D>(deserializer: D) -> Result<::uuid::Uuid, D::Error> 29 29 + where 30 30 + D: Deserializer<'de>, 31 31 + { 32 32 + let [a, b, c, d] = <[i32; 4]>::deserialize(deserializer)?; 33 33 + let mut bytes = [0u8; 16]; 34 34 + bytes[0..4].copy_from_slice(&a.to_be_bytes()); 35 35 + bytes[4..8].copy_from_slice(&b.to_be_bytes()); 36 36 + bytes[8..12].copy_from_slice(&c.to_be_bytes()); 37 37 + bytes[12..16].copy_from_slice(&d.to_be_bytes()); 38 38 + Ok(::uuid::Uuid::from_bytes(bytes)) 39 39 + } 40 40 + } 41 41 + 42 42 + /// Usage: `#[serde_as(as = "UuidLongPair")]` or 43 43 + /// `#[serde_as(as = "Option<UuidLongPair>")]`. 44 44 + pub struct UuidLongPair; 45 45 + 46 46 + impl SerializeAs<::uuid::Uuid> for UuidLongPair { 47 47 + fn serialize_as<S>( 48 48 + uuid: &::uuid::Uuid, 49 49 + serializer: S, 50 50 + ) -> Result<S::Ok, S::Error> 51 51 + where 52 52 + S: Serializer, 53 53 + { 54 54 + let (msb, lsb) = uuid.as_u64_pair(); 55 55 + [msb as i64, lsb as i64].serialize(serializer) 56 56 + } 57 57 + } 58 58 + 59 59 + impl<'de> DeserializeAs<'de, ::uuid::Uuid> for UuidLongPair { 60 60 + fn deserialize_as<D>(deserializer: D) -> Result<::uuid::Uuid, D::Error> 61 61 + where 62 62 + D: Deserializer<'de>, 63 63 + { 64 64 + let [msb, lsb] = <[i64; 2]>::deserialize(deserializer)?; 65 65 + Ok(::uuid::Uuid::from_u64_pair(msb as u64, lsb as u64)) 66 66 + } 67 67 + }

+3

nara_core/tests/fixtures/keybind.json

··· 1 1 + { 2 2 + "keybind": "key.inventory" 3 3 + }

+7

nara_core/tests/fixtures/nbt_block.json

··· 1 1 + { 2 2 + "source": "block", 3 3 + "nbt": "foo", 4 4 + "interpret": true, 5 5 + "separator": ", ", 6 6 + "block": "~ ~ ~" 7 7 + }

+7

nara_core/tests/fixtures/nbt_entity.json

··· 1 1 + { 2 2 + "source": "entity", 3 3 + "nbt": "foo", 4 4 + "interpret": true, 5 5 + "separator": ", ", 6 6 + "entity": "@p" 7 7 + }

+7

nara_core/tests/fixtures/nbt_storage.json

··· 1 1 + { 2 2 + "source": "storage", 3 3 + "nbt": "foo", 4 4 + "interpret": true, 5 5 + "separator": ", ", 6 6 + "storage": "minecraft:example" 7 7 + }

+5

nara_core/tests/fixtures/object_atlas.json

··· 1 1 + { 2 2 + "object": "atlas", 3 3 + "atlas": "minecraft:blocks", 4 4 + "sprite": "minecraft:stone" 5 5 + }

+4

nara_core/tests/fixtures/object_player.json

··· 1 1 + { 2 2 + "object": "player", 3 3 + "player": "kokiriglade" 4 4 + }

+18

nara_core/tests/fixtures/object_player_profile.json

··· 1 1 + { 2 2 + "object": "player", 3 3 + "player": { 4 4 + "name": "kokiriglade", 5 5 + "id": [452952, 452952, 459252, 459252], 6 6 + "properties": [ 7 7 + { 8 8 + "name": "textures", 9 9 + "value": "foo", 10 10 + "signature": "bar" 11 11 + } 12 12 + ], 13 13 + "texture": "minecraft:steve", 14 14 + "cape": "minecraft:some_cape", 15 15 + "model": "wide" 16 16 + }, 17 17 + "hat": false 18 18 + }

+6

nara_core/tests/fixtures/score.json

··· 1 1 + { 2 2 + "score": { 3 3 + "name": "@p", 4 4 + "objective": "foo.bar" 5 5 + } 6 6 + }

+4

nara_core/tests/fixtures/selector.json

··· 1 1 + { 2 2 + "selector": "@p", 3 3 + "separator": ", " 4 4 + }

+1

nara_core/tests/fixtures/text_plain.json

··· 1 1 + "Hello, World!"

+3

nara_core/tests/fixtures/text_tagged.json

··· 1 1 + { 2 2 + "text": "Hello, World!" 3 3 + }

+10

nara_core/tests/fixtures/translation.json

··· 1 1 + { 2 2 + "translate": "foo.bar", 3 3 + "fallback": "foo bar xyzzy", 4 4 + "with": [ 5 5 + "foo", 6 6 + { 7 7 + "text": "bar" 8 8 + } 9 9 + ] 10 10 + }

+9

nara_core/tests/keybind.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const FIXTURE: &str = include_str!("fixtures/keybind.json"); 4 4 + 5 5 + #[test] 6 6 + fn keybind() { 7 7 + let parsed = serde_json::from_str::<Component>(FIXTURE).unwrap(); 8 8 + insta::assert_debug_snapshot!(parsed); 9 9 + }

+23

nara_core/tests/nbt.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const BLOCK_FIXTURE: &str = include_str!("fixtures/nbt_block.json"); 4 4 + const ENTITY_FIXTURE: &str = include_str!("fixtures/nbt_entity.json"); 5 5 + const STORAGE_FIXTURE: &str = include_str!("fixtures/nbt_storage.json"); 6 6 + 7 7 + #[test] 8 8 + fn block() { 9 9 + let parsed = serde_json::from_str::<Component>(BLOCK_FIXTURE).unwrap(); 10 10 + insta::assert_debug_snapshot!(parsed); 11 11 + } 12 12 + 13 13 + #[test] 14 14 + fn entity() { 15 15 + let parsed = serde_json::from_str::<Component>(ENTITY_FIXTURE).unwrap(); 16 16 + insta::assert_debug_snapshot!(parsed); 17 17 + } 18 18 + 19 19 + #[test] 20 20 + fn storage() { 21 21 + let parsed = serde_json::from_str::<Component>(STORAGE_FIXTURE).unwrap(); 22 22 + insta::assert_debug_snapshot!(parsed); 23 23 + }

+25

nara_core/tests/object.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const ATLAS_FIXTURE: &str = include_str!("fixtures/object_atlas.json"); 4 4 + const PLAYER_FIXTURE: &str = include_str!("fixtures/object_player.json"); 5 5 + const PLAYER_PROFILE_FIXTURE: &str = 6 6 + include_str!("fixtures/object_player_profile.json"); 7 7 + 8 8 + #[test] 9 9 + fn atlas() { 10 10 + let parsed = serde_json::from_str::<Component>(ATLAS_FIXTURE).unwrap(); 11 11 + insta::assert_debug_snapshot!(parsed); 12 12 + } 13 13 + 14 14 + #[test] 15 15 + fn player() { 16 16 + let parsed = serde_json::from_str::<Component>(PLAYER_FIXTURE).unwrap(); 17 17 + insta::assert_debug_snapshot!(parsed); 18 18 + } 19 19 + 20 20 + #[test] 21 21 + fn player_profile() { 22 22 + let parsed = 23 23 + serde_json::from_str::<Component>(PLAYER_PROFILE_FIXTURE).unwrap(); 24 24 + insta::assert_debug_snapshot!(parsed); 25 25 + }

+9

nara_core/tests/score.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const FIXTURE: &str = include_str!("fixtures/score.json"); 4 4 + 5 5 + #[test] 6 6 + fn score() { 7 7 + let parsed = serde_json::from_str::<Component>(FIXTURE).unwrap(); 8 8 + insta::assert_debug_snapshot!(parsed); 9 9 + }

+9

nara_core/tests/selector.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const FIXTURE: &str = include_str!("fixtures/selector.json"); 4 4 + 5 5 + #[test] 6 6 + fn selector() { 7 7 + let parsed = serde_json::from_str::<Component>(FIXTURE).unwrap(); 8 8 + insta::assert_debug_snapshot!(parsed); 9 9 + }

+29

nara_core/tests/snapshots/keybind__keybind.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/keybind.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: Some( 12 12 + KeybindComponent { 13 13 + keybind: "key.inventory", 14 14 + }, 15 15 + ), 16 16 + nbt: None, 17 17 + object: None, 18 18 + formatting: ComponentFormatting { 19 19 + color: None, 20 20 + font: None, 21 21 + bold: None, 22 22 + italic: None, 23 23 + underlined: None, 24 24 + strikethrough: None, 25 25 + obfuscated: None, 26 26 + }, 27 27 + children: [], 28 28 + }, 29 29 + )

+41

nara_core/tests/snapshots/nbt__block.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/nbt.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: Some( 13 13 + NbtComponent { 14 14 + source: Some( 15 15 + Block, 16 16 + ), 17 17 + path: "foo", 18 18 + interpret: Some( 19 19 + true, 20 20 + ), 21 21 + separator: None, 22 22 + entity: None, 23 23 + block: Some( 24 24 + "~ ~ ~", 25 25 + ), 26 26 + storage: None, 27 27 + }, 28 28 + ), 29 29 + object: None, 30 30 + formatting: ComponentFormatting { 31 31 + color: None, 32 32 + font: None, 33 33 + bold: None, 34 34 + italic: None, 35 35 + underlined: None, 36 36 + strikethrough: None, 37 37 + obfuscated: None, 38 38 + }, 39 39 + children: [], 40 40 + }, 41 41 + )

+41

nara_core/tests/snapshots/nbt__entity.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/nbt.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: Some( 13 13 + NbtComponent { 14 14 + source: Some( 15 15 + Entity, 16 16 + ), 17 17 + path: "foo", 18 18 + interpret: Some( 19 19 + true, 20 20 + ), 21 21 + separator: None, 22 22 + entity: Some( 23 23 + "@p", 24 24 + ), 25 25 + block: None, 26 26 + storage: None, 27 27 + }, 28 28 + ), 29 29 + object: None, 30 30 + formatting: ComponentFormatting { 31 31 + color: None, 32 32 + font: None, 33 33 + bold: None, 34 34 + italic: None, 35 35 + underlined: None, 36 36 + strikethrough: None, 37 37 + obfuscated: None, 38 38 + }, 39 39 + children: [], 40 40 + }, 41 41 + )

+41

nara_core/tests/snapshots/nbt__storage.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/nbt.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: Some( 13 13 + NbtComponent { 14 14 + source: Some( 15 15 + Storage, 16 16 + ), 17 17 + path: "foo", 18 18 + interpret: Some( 19 19 + true, 20 20 + ), 21 21 + separator: None, 22 22 + entity: None, 23 23 + block: None, 24 24 + storage: Some( 25 25 + "minecraft:example", 26 26 + ), 27 27 + }, 28 28 + ), 29 29 + object: None, 30 30 + formatting: ComponentFormatting { 31 31 + color: None, 32 32 + font: None, 33 33 + bold: None, 34 34 + italic: None, 35 35 + underlined: None, 36 36 + strikethrough: None, 37 37 + obfuscated: None, 38 38 + }, 39 39 + children: [], 40 40 + }, 41 41 + )

+34

nara_core/tests/snapshots/object__atlas.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/object.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: None, 13 13 + object: Some( 14 14 + Atlas( 15 15 + AtlasObject { 16 16 + atlas: Some( 17 17 + "minecraft:blocks", 18 18 + ), 19 19 + sprite: "minecraft:stone", 20 20 + }, 21 21 + ), 22 22 + ), 23 23 + formatting: ComponentFormatting { 24 24 + color: None, 25 25 + font: None, 26 26 + bold: None, 27 27 + italic: None, 28 28 + underlined: None, 29 29 + strikethrough: None, 30 30 + obfuscated: None, 31 31 + }, 32 32 + children: [], 33 33 + }, 34 34 + )

+34

nara_core/tests/snapshots/object__player.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/object.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: None, 13 13 + object: Some( 14 14 + Player( 15 15 + PlayerObject { 16 16 + player: Name( 17 17 + "kokiriglade", 18 18 + ), 19 19 + hat: None, 20 20 + }, 21 21 + ), 22 22 + ), 23 23 + formatting: ComponentFormatting { 24 24 + color: None, 25 25 + font: None, 26 26 + bold: None, 27 27 + italic: None, 28 28 + underlined: None, 29 29 + strikethrough: None, 30 30 + obfuscated: None, 31 31 + }, 32 32 + children: [], 33 33 + }, 34 34 + )

+67

nara_core/tests/snapshots/object__player_profile.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/object.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: None, 11 11 + keybind: None, 12 12 + nbt: None, 13 13 + object: Some( 14 14 + Player( 15 15 + PlayerObject { 16 16 + player: Profile( 17 17 + PlayerProfile { 18 18 + name: Some( 19 19 + "kokiriglade", 20 20 + ), 21 21 + id: Some( 22 22 + [ 23 23 + 452952, 24 24 + 452952, 25 25 + 459252, 26 26 + 459252, 27 27 + ], 28 28 + ), 29 29 + properties: [ 30 30 + PlayerProfileProperty { 31 31 + name: "textures", 32 32 + value: "foo", 33 33 + signature: Some( 34 34 + "bar", 35 35 + ), 36 36 + }, 37 37 + ], 38 38 + texture: Some( 39 39 + "minecraft:steve", 40 40 + ), 41 41 + cape: Some( 42 42 + "minecraft:some_cape", 43 43 + ), 44 44 + elytra: None, 45 45 + model: Some( 46 46 + Wide, 47 47 + ), 48 48 + }, 49 49 + ), 50 50 + hat: Some( 51 51 + false, 52 52 + ), 53 53 + }, 54 54 + ), 55 55 + ), 56 56 + formatting: ComponentFormatting { 57 57 + color: None, 58 58 + font: None, 59 59 + bold: None, 60 60 + italic: None, 61 61 + underlined: None, 62 62 + strikethrough: None, 63 63 + obfuscated: None, 64 64 + }, 65 65 + children: [], 66 66 + }, 67 67 + )

+30

nara_core/tests/snapshots/score__score.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/score.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: Some( 10 10 + ScoreComponent { 11 11 + name: "@p", 12 12 + objective: "foo.bar", 13 13 + }, 14 14 + ), 15 15 + selector: None, 16 16 + keybind: None, 17 17 + nbt: None, 18 18 + object: None, 19 19 + formatting: ComponentFormatting { 20 20 + color: None, 21 21 + font: None, 22 22 + bold: None, 23 23 + italic: None, 24 24 + underlined: None, 25 25 + strikethrough: None, 26 26 + obfuscated: None, 27 27 + }, 28 28 + children: [], 29 29 + }, 30 30 + )

+34

nara_core/tests/snapshots/selector__selector.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/selector.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: None, 9 9 + score: None, 10 10 + selector: Some( 11 11 + SelectorComponent { 12 12 + selector: "@p", 13 13 + separator: Some( 14 14 + String( 15 15 + ", ", 16 16 + ), 17 17 + ), 18 18 + }, 19 19 + ), 20 20 + keybind: None, 21 21 + nbt: None, 22 22 + object: None, 23 23 + formatting: ComponentFormatting { 24 24 + color: None, 25 25 + font: None, 26 26 + bold: None, 27 27 + italic: None, 28 28 + underlined: None, 29 29 + strikethrough: None, 30 30 + obfuscated: None, 31 31 + }, 32 32 + children: [], 33 33 + }, 34 34 + )

+7

nara_core/tests/snapshots/text__plain.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/text.rs 3 3 + expression: parsed 4 4 + --- 5 5 + String( 6 6 + "Hello, World!", 7 7 + )

+29

nara_core/tests/snapshots/text__tagged.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/text.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: Some( 8 8 + TextComponent { 9 9 + text: "Hello, World!", 10 10 + }, 11 11 + ), 12 12 + translation: None, 13 13 + score: None, 14 14 + selector: None, 15 15 + keybind: None, 16 16 + nbt: None, 17 17 + object: None, 18 18 + formatting: ComponentFormatting { 19 19 + color: None, 20 20 + font: None, 21 21 + bold: None, 22 22 + italic: None, 23 23 + underlined: None, 24 24 + strikethrough: None, 25 25 + obfuscated: None, 26 26 + }, 27 27 + children: [], 28 28 + }, 29 29 + )

+62

nara_core/tests/snapshots/translation__translation.snap

··· 1 1 + --- 2 2 + source: nara_core/tests/translation.rs 3 3 + expression: parsed 4 4 + --- 5 5 + Object( 6 6 + ComponentObject { 7 7 + text: None, 8 8 + translation: Some( 9 9 + TranslationComponent { 10 10 + translate: "foo.bar", 11 11 + fallback: Some( 12 12 + "foo bar xyzzy", 13 13 + ), 14 14 + with: [ 15 15 + String( 16 16 + "foo", 17 17 + ), 18 18 + Object( 19 19 + ComponentObject { 20 20 + text: Some( 21 21 + TextComponent { 22 22 + text: "bar", 23 23 + }, 24 24 + ), 25 25 + translation: None, 26 26 + score: None, 27 27 + selector: None, 28 28 + keybind: None, 29 29 + nbt: None, 30 30 + object: None, 31 31 + formatting: ComponentFormatting { 32 32 + color: None, 33 33 + font: None, 34 34 + bold: None, 35 35 + italic: None, 36 36 + underlined: None, 37 37 + strikethrough: None, 38 38 + obfuscated: None, 39 39 + }, 40 40 + children: [], 41 41 + }, 42 42 + ), 43 43 + ], 44 44 + }, 45 45 + ), 46 46 + score: None, 47 47 + selector: None, 48 48 + keybind: None, 49 49 + nbt: None, 50 50 + object: None, 51 51 + formatting: ComponentFormatting { 52 52 + color: None, 53 53 + font: None, 54 54 + bold: None, 55 55 + italic: None, 56 56 + underlined: None, 57 57 + strikethrough: None, 58 58 + obfuscated: None, 59 59 + }, 60 60 + children: [], 61 61 + }, 62 62 + )

+16

nara_core/tests/text.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const PLAIN_FIXTURE: &str = include_str!("fixtures/text_plain.json"); 4 4 + const TAGGED_FIXTURE: &str = include_str!("fixtures/text_tagged.json"); 5 5 + 6 6 + #[test] 7 7 + fn plain() { 8 8 + let parsed = serde_json::from_str::<Component>(PLAIN_FIXTURE).unwrap(); 9 9 + insta::assert_debug_snapshot!(parsed); 10 10 + } 11 11 + 12 12 + #[test] 13 13 + fn tagged() { 14 14 + let parsed = serde_json::from_str::<Component>(TAGGED_FIXTURE).unwrap(); 15 15 + insta::assert_debug_snapshot!(parsed); 16 16 + }

+9

nara_core/tests/translation.rs

··· 1 1 + use nara_core::component::Component; 2 2 + 3 3 + const FIXTURE: &str = include_str!("fixtures/translation.json"); 4 4 + 5 5 + #[test] 6 6 + fn translation() { 7 7 + let parsed = serde_json::from_str::<Component>(FIXTURE).unwrap(); 8 8 + insta::assert_debug_snapshot!(parsed); 9 9 + }

+11

nara_io/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_io" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + crab_nbt.workspace = true 8 8 + flate2.workspace = true 9 9 + serde.workspace = true 10 10 + serde_json.workspace = true 11 11 + thiserror.workspace = true

+86

nara_io/src/lib.rs

··· 1 1 + use flate2::{ 2 2 + Compression, 3 3 + read::{GzDecoder, ZlibDecoder}, 4 4 + write::GzEncoder, 5 5 + }; 6 6 + use serde::{Deserialize, Serialize}; 7 7 + use std::io::{Cursor, Read, Write}; 8 8 + 9 9 + #[derive(Debug, thiserror::Error)] 10 10 + pub enum Error { 11 11 + #[error(transparent)] 12 12 + Io(#[from] std::io::Error), 13 13 + #[error(transparent)] 14 14 + Nbt(#[from] crab_nbt::error::Error), 15 15 + #[error(transparent)] 16 16 + Json(#[from] serde_json::Error), 17 17 + } 18 18 + 19 19 + pub type Result<T> = std::result::Result<T, Error>; 20 20 + 21 21 + pub fn read_nbt<T>(src: &[u8]) -> Result<T> 22 22 + where 23 23 + T: for<'de> Deserialize<'de>, 24 24 + { 25 25 + let decomp = maybe_decompress(src)?; 26 26 + let mut cur = Cursor::new(decomp.as_slice()); 27 27 + 28 28 + Ok(crab_nbt::serde::de::from_cursor::<T>(&mut cur)?) 29 29 + } 30 30 + 31 31 + pub fn write_nbt<T>(value: &T) -> Result<Vec<u8>> 32 32 + where 33 33 + T: Serialize, 34 34 + { 35 35 + let nbt_bytes = crab_nbt::serde::ser::to_bytes_unnamed(value)?; 36 36 + let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); 37 37 + encoder.write_all(&nbt_bytes)?; 38 38 + Ok(encoder.finish()?) 39 39 + } 40 40 + 41 41 + pub fn write_json_gz<T>(value: &T) -> Result<Vec<u8>> 42 42 + where 43 43 + T: Serialize, 44 44 + { 45 45 + let json = serde_json::to_vec(value)?; 46 46 + let mut encoder = GzEncoder::new(Vec::new(), Compression::default()); 47 47 + encoder.write_all(&json)?; 48 48 + Ok(encoder.finish()?) 49 49 + } 50 50 + 51 51 + pub fn read_json_gz<T>(src: &[u8]) -> Result<T> 52 52 + where 53 53 + T: for<'de> Deserialize<'de>, 54 54 + { 55 55 + let decompressed = maybe_decompress(src)?; 56 56 + Ok(serde_json::from_slice(&decompressed)?) 57 57 + } 58 58 + 59 59 + pub fn maybe_decompress(src: &[u8]) -> Result<Vec<u8>> { 60 60 + let mut src_cursor = Cursor::new(src); 61 61 + 62 62 + src_cursor.set_position(0); 63 63 + let mut header = [0u8; 2]; 64 64 + src_cursor.read_exact(&mut header)?; 65 65 + 66 66 + let mut decoded = Vec::new(); 67 67 + match &header { 68 68 + [0x1f, 0x8b] => { 69 69 + src_cursor.set_position(0); 70 70 + GzDecoder::new(src_cursor).read_to_end(&mut decoded)?; 71 71 + } 72 72 + [0x78, _b @ 0x01..=0xda] 73 73 + if (u16::from(header[0]) * 256 + u16::from(header[1])) % 31 74 74 + == 0 => 75 75 + { 76 76 + src_cursor.set_position(0); 77 77 + ZlibDecoder::new(src_cursor).read_to_end(&mut decoded)?; 78 78 + } 79 79 + _ => { 80 80 + src_cursor.set_position(0); 81 81 + src_cursor.read_to_end(&mut decoded)?; 82 82 + } 83 83 + } 84 84 + 85 85 + Ok(decoded) 86 86 + }

+10

nara_mcr/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_mcr" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + crab_nbt.workspace = true 8 8 + flate2.workspace = true 9 9 + serde.workspace = true 10 10 + thiserror.workspace = true

+131

nara_mcr/src/lib.rs

··· 1 1 + use std::io::{Cursor, Read}; 2 2 + 3 3 + use flate2::read::{GzDecoder, ZlibDecoder}; 4 4 + use serde::de::DeserializeOwned; 5 5 + 6 6 + const SECTOR_BYTES: usize = 4096; 7 7 + const REGION_SIDE: usize = 32; 8 8 + const CHUNK_COUNT: usize = REGION_SIDE * REGION_SIDE; 9 9 + const HEADER_BYTES: usize = 2 * SECTOR_BYTES; 10 10 + 11 11 + #[derive(Debug, thiserror::Error)] 12 12 + pub enum Error { 13 13 + #[error( 14 14 + "region data too short: need at least {HEADER_BYTES} bytes, got {0}" 15 15 + )] 16 16 + TooShort(usize), 17 17 + #[error( 18 18 + "chunk ({0}, {1}) references sector offset {2} which is outside the file" 19 19 + )] 20 20 + ChunkOutOfBounds(u8, u8, usize), 21 21 + #[error("unknown compression type {0} for chunk ({1}, {2})")] 22 22 + UnknownCompression(u8, u8, u8), 23 23 + #[error(transparent)] 24 24 + Io(#[from] std::io::Error), 25 25 + #[error(transparent)] 26 26 + Nbt(#[from] crab_nbt::error::Error), 27 27 + } 28 28 + 29 29 + pub type Result<T> = std::result::Result<T, Error>; 30 30 + 31 31 + #[derive(Debug)] 32 32 + pub struct McRegion<C> { 33 33 + chunks: Vec<Option<C>>, 34 34 + } 35 35 + 36 36 + impl<C: DeserializeOwned> McRegion<C> { 37 37 + pub fn from_bytes(data: &[u8]) -> Result<Self> { 38 38 + if data.len() < HEADER_BYTES { 39 39 + return Err(Error::TooShort(data.len())); 40 40 + } 41 41 + 42 42 + let mut chunks: Vec<Option<C>> = 43 43 + (0..CHUNK_COUNT).map(|_| None).collect(); 44 44 + 45 45 + for (i, chunk) in chunks.iter_mut().enumerate().take(CHUNK_COUNT) { 46 46 + let x = (i % REGION_SIDE) as u8; 47 47 + let z = (i / REGION_SIDE) as u8; 48 48 + 49 49 + // location table: first 4096 bytes, 4 bytes per entry. 50 50 + // [offset_hi, offset_mid, offset_lo, sector_count] 51 51 + // offset is in units of 4096-byte sectors from the file start. 52 52 + let loc = i * 4; 53 53 + let offset_sectors = u32::from_be_bytes([ 54 54 + 0, 55 55 + data[loc], 56 56 + data[loc + 1], 57 57 + data[loc + 2], 58 58 + ]) as usize; 59 59 + 60 60 + if offset_sectors == 0 { 61 61 + continue; 62 62 + } 63 63 + 64 64 + let byte_offset = offset_sectors * SECTOR_BYTES; 65 65 + if byte_offset + 5 > data.len() { 66 66 + return Err(Error::ChunkOutOfBounds(x, z, offset_sectors)); 67 67 + } 68 68 + 69 69 + let length = u32::from_be_bytes([ 70 70 + data[byte_offset], 71 71 + data[byte_offset + 1], 72 72 + data[byte_offset + 2], 73 73 + data[byte_offset + 3], 74 74 + ]) as usize; 75 75 + 76 76 + if length == 0 || byte_offset + 4 + length > data.len() { 77 77 + return Err(Error::ChunkOutOfBounds(x, z, offset_sectors)); 78 78 + } 79 79 + 80 80 + let compression = data[byte_offset + 4]; 81 81 + let compressed = &data[byte_offset + 5..byte_offset + 4 + length]; 82 82 + 83 83 + let decompressed = decompress(compressed, compression, x, z)?; 84 84 + let mut cursor = Cursor::new(decompressed.as_slice()); 85 85 + *chunk = Some(crab_nbt::serde::de::from_cursor::<C>(&mut cursor)?); 86 86 + } 87 87 + 88 88 + Ok(Self { chunks }) 89 89 + } 90 90 + 91 91 + pub fn chunk(&self, local_x: u8, local_z: u8) -> Option<&C> { 92 92 + if local_x as usize >= REGION_SIDE || local_z as usize >= REGION_SIDE { 93 93 + return None; 94 94 + } 95 95 + self.chunks[local_z as usize * REGION_SIDE + local_x as usize].as_ref() 96 96 + } 97 97 + 98 98 + pub fn iter(&self) -> impl Iterator<Item = ((u8, u8), &C)> { 99 99 + self.chunks.iter().enumerate().filter_map(|(i, slot)| { 100 100 + slot.as_ref().map(|c| { 101 101 + let x = (i % REGION_SIDE) as u8; 102 102 + let z = (i / REGION_SIDE) as u8; 103 103 + ((x, z), c) 104 104 + }) 105 105 + }) 106 106 + } 107 107 + 108 108 + pub fn into_iter_chunks(self) -> impl Iterator<Item = ((u8, u8), C)> { 109 109 + self.chunks.into_iter().enumerate().filter_map(|(i, slot)| { 110 110 + slot.map(|c| { 111 111 + let x = (i % REGION_SIDE) as u8; 112 112 + let z = (i / REGION_SIDE) as u8; 113 113 + ((x, z), c) 114 114 + }) 115 115 + }) 116 116 + } 117 117 + } 118 118 + 119 119 + fn decompress(data: &[u8], compression: u8, x: u8, z: u8) -> Result<Vec<u8>> { 120 120 + let mut buf = Vec::new(); 121 121 + match compression { 122 122 + 1 => GzDecoder::new(data).read_to_end(&mut buf)?, 123 123 + 2 => ZlibDecoder::new(data).read_to_end(&mut buf)?, 124 124 + 3 => { 125 125 + buf.extend_from_slice(data); 126 126 + buf.len() 127 127 + } 128 128 + other => return Err(Error::UnknownCompression(other, x, z)), 129 129 + }; 130 130 + Ok(buf) 131 131 + }

nara_mcr/tests/fixtures/r.0.0.mca

This is a binary file and will not be displayed.

+11

nara_slurper_1_12_core/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_slurper_1_12_core" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + nara_core.workspace = true 8 8 + serde.workspace = true 9 9 + 10 10 + [dev-dependencies] 11 11 + nara_mcr.workspace = true

+3

nara_slurper_1_12_core/README.md

··· 1 1 + # nara_slurper_1_12_core 2 2 + 3 3 + Shared code for 1.12.2 version handling.

+70

nara_slurper_1_12_core/src/chunk.rs

··· 1 1 + use serde::Deserialize; 2 2 + 3 3 + use crate::item::{InventoryItemStack, ItemStack}; 4 4 + 5 5 + /// A 1.12.2 Anvil chunk, containing only the fields we care about. 6 6 + /// Unknown fields are silently ignored by serde. 7 7 + #[derive(Debug, Deserialize)] 8 8 + pub struct Chunk { 9 9 + #[serde(rename = "DataVersion")] 10 10 + pub data_version: i32, 11 11 + #[serde(rename = "Level")] 12 12 + pub level: ChunkLevel, 13 13 + } 14 14 + 15 15 + #[derive(Debug, Deserialize)] 16 16 + pub struct ChunkLevel { 17 17 + #[serde(rename = "xPos")] 18 18 + pub x_pos: i32, 19 19 + #[serde(rename = "zPos")] 20 20 + pub z_pos: i32, 21 21 + #[serde(rename = "TileEntities", default)] 22 22 + pub tile_entities: Vec<TileEntity>, 23 23 + #[serde(rename = "Entities", default)] 24 24 + pub entities: Vec<Entity>, 25 25 + } 26 26 + 27 27 + #[derive(Debug, Deserialize)] 28 28 + #[serde(untagged)] 29 29 + pub enum Entity { 30 30 + ItemHolder(ItemHolderEntity), 31 31 + Inventoried(InventoriedEntity), 32 32 + Base(BaseEntity), 33 33 + } 34 34 + 35 35 + #[derive(Debug, Deserialize)] 36 36 + pub struct BaseEntity { 37 37 + #[serde(rename = "Pos")] 38 38 + pub position: [f64; 3], 39 39 + pub id: String, 40 40 + } 41 41 + 42 42 + #[derive(Debug, Deserialize)] 43 43 + pub struct ItemHolderEntity { 44 44 + #[serde(flatten)] 45 45 + pub base: BaseEntity, 46 46 + #[serde(rename = "Item")] 47 47 + pub item: ItemStack, 48 48 + } 49 49 + 50 50 + #[derive(Debug, Deserialize)] 51 51 + pub struct InventoriedEntity { 52 52 + #[serde(flatten)] 53 53 + pub base: BaseEntity, 54 54 + #[serde(rename = "Items")] 55 55 + pub items: Vec<InventoryItemStack>, 56 56 + } 57 57 + 58 58 + /// A placed block entity (chest, furnace, shulker box, …). 59 59 + /// `Items` is present on container block entities and absent on others, 60 60 + /// so it defaults to an empty vec. 61 61 + #[derive(Debug, Deserialize)] 62 62 + pub struct TileEntity { 63 63 + pub id: String, 64 64 + pub x: i32, 65 65 + pub y: i32, 66 66 + pub z: i32, 67 67 + #[serde(rename = "Items", default)] 68 68 + // TODO(kokiriglade): not every tile entity has items, but its probably ok to assume they do 69 69 + pub items: Vec<InventoryItemStack>, 70 70 + }

+275

nara_slurper_1_12_core/src/item.rs

··· 1 1 + use nara_core::{ 2 2 + book::BookContent, 3 3 + component::{Component, parse_component_from_str}, 4 4 + }; 5 5 + use serde::{Deserialize, Deserializer}; 6 6 + 7 7 + #[derive(Debug, Clone)] 8 8 + pub enum ItemStack { 9 9 + WrittenBook(WrittenBookStack), 10 10 + BlockEntity(BlockEntityStack), 11 11 + Base(BaseItemStack), 12 12 + } 13 13 + 14 14 + #[derive(Debug, Clone)] 15 15 + pub struct BaseItemStack { 16 16 + pub count: i8, 17 17 + pub damage: i16, 18 18 + pub id: String, 19 19 + } 20 20 + 21 21 + #[derive(Debug, Clone, Deserialize)] 22 22 + #[serde(rename_all = "PascalCase")] 23 23 + pub struct DisplayTag { 24 24 + pub name: Option<String>, 25 25 + } 26 26 + 27 27 + #[derive(Debug, Clone)] 28 28 + pub struct BaseTag { 29 29 + pub display: Option<DisplayTag>, 30 30 + } 31 31 + 32 32 + #[derive(Debug, Clone)] 33 33 + pub struct WrittenBookStack { 34 34 + pub count: i8, 35 35 + pub damage: i16, 36 36 + pub id: String, 37 37 + pub tag: WrittenBookTag, 38 38 + } 39 39 + 40 40 + #[derive(Debug, Clone)] 41 41 + pub struct WrittenBookTag { 42 42 + pub base: BaseTag, 43 43 + pub author: String, 44 44 + pub title: String, 45 45 + pub generation: BookGeneration, 46 46 + pub resolved: bool, 47 47 + pub pages: Vec<Component>, 48 48 + } 49 49 + 50 50 + #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] 51 51 + pub enum BookGeneration { 52 52 + #[default] 53 53 + Original, 54 54 + CopyOfOriginal, 55 55 + CopyOfCopy, 56 56 + Tattered, 57 57 + } 58 58 + 59 59 + impl TryFrom<i32> for BookGeneration { 60 60 + type Error = i32; 61 61 + 62 62 + fn try_from(value: i32) -> Result<Self, Self::Error> { 63 63 + match value { 64 64 + 0 => Ok(Self::Original), 65 65 + 1 => Ok(Self::CopyOfOriginal), 66 66 + 2 => Ok(Self::CopyOfCopy), 67 67 + 3 => Ok(Self::Tattered), 68 68 + other => Err(other), 69 69 + } 70 70 + } 71 71 + } 72 72 + 73 73 + #[derive(Debug, Clone)] 74 74 + pub struct BlockEntityStack { 75 75 + pub count: i8, 76 76 + pub damage: i16, 77 77 + pub id: String, 78 78 + pub tag: BlockEntityTag, 79 79 + } 80 80 + 81 81 + #[derive(Debug, Clone)] 82 82 + pub struct BlockEntityTag { 83 83 + pub base: BaseTag, 84 84 + pub block_entity: BlockEntity, 85 85 + } 86 86 + 87 87 + #[derive(Debug, Clone, Deserialize)] 88 88 + #[serde(rename_all = "PascalCase")] 89 89 + pub struct BlockEntity { 90 90 + #[serde(default)] 91 91 + pub items: Vec<InventoryItemStack>, 92 92 + } 93 93 + 94 94 + #[derive(Debug, Clone, Copy, PartialEq, Eq)] 95 95 + pub enum BlockEntityKind { 96 96 + ShulkerBox, 97 97 + Chest, 98 98 + TrappedChest, 99 99 + Hopper, 100 100 + Dropper, 101 101 + Dispenser, 102 102 + Barrel, 103 103 + Other, 104 104 + } 105 105 + 106 106 + impl BlockEntityStack { 107 107 + pub fn kind(&self) -> BlockEntityKind { 108 108 + match self.id.as_str() { 109 109 + id if id.contains("shulker_box") => BlockEntityKind::ShulkerBox, 110 110 + "minecraft:chest" => BlockEntityKind::Chest, 111 111 + "minecraft:trapped_chest" => BlockEntityKind::TrappedChest, 112 112 + "minecraft:hopper" => BlockEntityKind::Hopper, 113 113 + "minecraft:dropper" => BlockEntityKind::Dropper, 114 114 + "minecraft:dispenser" => BlockEntityKind::Dispenser, 115 115 + _ => BlockEntityKind::Other, 116 116 + } 117 117 + } 118 118 + } 119 119 + 120 120 + #[derive(Debug, Clone)] 121 121 + pub struct InventoryItemStack { 122 122 + pub item: ItemStack, 123 123 + pub slot: i8, 124 124 + } 125 125 + 126 126 + #[derive(Deserialize)] 127 127 + struct RawItemStack { 128 128 + #[serde(rename = "id")] 129 129 + id: String, 130 130 + #[serde(rename = "Count")] 131 131 + count: i8, 132 132 + #[serde(rename = "Damage")] 133 133 + damage: i16, 134 134 + #[serde(default)] 135 135 + tag: Option<RawTag>, 136 136 + } 137 137 + 138 138 + #[derive(Deserialize)] 139 139 + struct RawInventoryItemStack { 140 140 + #[serde(rename = "id")] 141 141 + id: String, 142 142 + #[serde(rename = "Count")] 143 143 + count: i8, 144 144 + #[serde(rename = "Damage")] 145 145 + damage: i16, 146 146 + #[serde(rename = "Slot")] 147 147 + slot: i8, 148 148 + #[serde(default)] 149 149 + tag: Option<RawTag>, 150 150 + } 151 151 + 152 152 + #[derive(Deserialize, Default)] 153 153 + struct RawTag { 154 154 + #[serde(default)] 155 155 + author: Option<String>, 156 156 + #[serde(default)] 157 157 + title: Option<String>, 158 158 + #[serde(default)] 159 159 + pages: Option<Vec<String>>, 160 160 + #[serde(default)] 161 161 + generation: Option<i32>, 162 162 + #[serde(default)] 163 163 + resolved: Option<i8>, 164 164 + 165 165 + #[serde(default, rename = "BlockEntityTag")] 166 166 + block_entity: Option<BlockEntity>, 167 167 + 168 168 + #[serde(default)] 169 169 + display: Option<DisplayTag>, 170 170 + } 171 171 + 172 172 + fn build_item_stack( 173 173 + id: String, 174 174 + count: i8, 175 175 + damage: i16, 176 176 + tag: Option<RawTag>, 177 177 + ) -> ItemStack { 178 178 + if id == "minecraft:written_book" 179 179 + && let Some(ref t) = tag 180 180 + && let (Some(author), Some(title), Some(pages)) = 181 181 + (t.author.clone(), t.title.clone(), t.pages.clone()) 182 182 + { 183 183 + let generation = t 184 184 + .generation 185 185 + .and_then(|g| BookGeneration::try_from(g).ok()) 186 186 + .unwrap_or_default(); 187 187 + let resolved = t.resolved.map(|b| b != 0).unwrap_or(false); 188 188 + let display = t.display.clone(); 189 189 + return ItemStack::WrittenBook(WrittenBookStack { 190 190 + count, 191 191 + damage, 192 192 + id, 193 193 + tag: WrittenBookTag { 194 194 + base: BaseTag { display }, 195 195 + author, 196 196 + title, 197 197 + generation, 198 198 + resolved, 199 199 + pages: pages 200 200 + .into_iter() 201 201 + .map(|s| parse_component_from_str(&s)) 202 202 + .collect(), 203 203 + }, 204 204 + }); 205 205 + } 206 206 + 207 207 + if let Some(ref t) = tag 208 208 + && let Some(ref be) = t.block_entity 209 209 + { 210 210 + let display = t.display.clone(); 211 211 + return ItemStack::BlockEntity(BlockEntityStack { 212 212 + count, 213 213 + damage, 214 214 + id, 215 215 + tag: BlockEntityTag { 216 216 + base: BaseTag { display }, 217 217 + block_entity: be.clone(), 218 218 + }, 219 219 + }); 220 220 + } 221 221 + 222 222 + ItemStack::Base(BaseItemStack { count, damage, id }) 223 223 + } 224 224 + 225 225 + impl<'de> Deserialize<'de> for ItemStack { 226 226 + fn deserialize<D: Deserializer<'de>>( 227 227 + deserializer: D, 228 228 + ) -> Result<Self, D::Error> { 229 229 + let raw = RawItemStack::deserialize(deserializer)?; 230 230 + Ok(build_item_stack(raw.id, raw.count, raw.damage, raw.tag)) 231 231 + } 232 232 + } 233 233 + 234 234 + impl<'de> Deserialize<'de> for InventoryItemStack { 235 235 + fn deserialize<D: Deserializer<'de>>( 236 236 + deserializer: D, 237 237 + ) -> Result<Self, D::Error> { 238 238 + let raw = RawInventoryItemStack::deserialize(deserializer)?; 239 239 + Ok(InventoryItemStack { 240 240 + item: build_item_stack(raw.id, raw.count, raw.damage, raw.tag), 241 241 + slot: raw.slot, 242 242 + }) 243 243 + } 244 244 + } 245 245 + 246 246 + impl From<BookGeneration> for nara_core::book::BookGeneration { 247 247 + fn from(value: BookGeneration) -> Self { 248 248 + match value { 249 249 + BookGeneration::Original => { 250 250 + nara_core::book::BookGeneration::Original 251 251 + } 252 252 + BookGeneration::CopyOfOriginal => { 253 253 + nara_core::book::BookGeneration::CopyOfOriginal 254 254 + } 255 255 + BookGeneration::CopyOfCopy => { 256 256 + nara_core::book::BookGeneration::CopyOfCopy 257 257 + } 258 258 + BookGeneration::Tattered => { 259 259 + nara_core::book::BookGeneration::Tattered 260 260 + } 261 261 + } 262 262 + } 263 263 + } 264 264 + 265 265 + impl From<WrittenBookStack> for BookContent { 266 266 + fn from(value: WrittenBookStack) -> Self { 267 267 + BookContent { 268 268 + author: value.tag.author, 269 269 + pages: value.tag.pages, 270 270 + title: value.tag.title, 271 271 + generation: value.tag.generation.into(), 272 272 + resolved: value.tag.resolved, 273 273 + } 274 274 + } 275 275 + }

+65

nara_slurper_1_12_core/src/lib.rs

··· 1 1 + use nara_core::book::{Book, BookMetadata, BookSource}; 2 2 + 3 3 + use crate::item::{InventoryItemStack, ItemStack, WrittenBookStack}; 4 4 + 5 5 + pub mod chunk; 6 6 + pub mod item; 7 7 + 8 8 + pub fn extract_books_from_inventory( 9 9 + inventory: &[InventoryItemStack], 10 10 + ) -> Vec<WrittenBookStack> { 11 11 + let mut books: Vec<WrittenBookStack> = Vec::new(); 12 12 + 13 13 + inventory.iter().for_each(|item| match &item.item { 14 14 + ItemStack::WrittenBook(written_book_stack) => { 15 15 + books.push(written_book_stack.clone()) 16 16 + } 17 17 + ItemStack::BlockEntity(block_entity_stack) => { 18 18 + books.extend(extract_books_from_inventory( 19 19 + &block_entity_stack.tag.block_entity.items, 20 20 + )); 21 21 + } 22 22 + _ => {} 23 23 + }); 24 24 + 25 25 + books 26 26 + } 27 27 + 28 28 + pub fn extract_books_with_source( 29 29 + inventory: &[InventoryItemStack], 30 30 + nested_block_entity_id: Option<String>, 31 31 + nested_source: Option<BookSource>, 32 32 + make_root: &impl Fn(i8) -> BookSource, 33 33 + ) -> Vec<Book> { 34 34 + let mut books = Vec::new(); 35 35 + for item in inventory { 36 36 + let item_source = match &nested_source { 37 37 + Some(outer) => BookSource::ItemBlockEntity { 38 38 + id: nested_block_entity_id.clone().unwrap(), 39 39 + slot: item.slot, 40 40 + within: Box::new(outer.clone()), 41 41 + }, 42 42 + None => make_root(item.slot), 43 43 + }; 44 44 + match &item.item { 45 45 + ItemStack::WrittenBook(written_book) => { 46 46 + books.push(Book { 47 47 + metadata: BookMetadata { 48 48 + source: item_source, 49 49 + }, 50 50 + content: written_book.clone().into(), 51 51 + }); 52 52 + } 53 53 + ItemStack::BlockEntity(block_entity) => { 54 54 + books.extend(extract_books_with_source( 55 55 + &block_entity.tag.block_entity.items, 56 56 + Some(block_entity.id.clone()), 57 57 + Some(item_source), 58 58 + make_root, 59 59 + )); 60 60 + } 61 61 + _ => {} 62 62 + } 63 63 + } 64 64 + books 65 65 + }

+10

nara_slurper_1_12_infinity/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_slurper_1_12_infinity" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + nara_core.workspace = true 8 8 + nara_io.workspace = true 9 9 + nara_slurper_1_12_core.workspace = true 10 10 + serde.workspace = true

+5

nara_slurper_1_12_infinity/README.md

··· 1 1 + # nara_slurper_1_12_infinity 2 2 + 3 3 + Pulls books from an [Infinity Item Editor][iie] vault. 4 4 + 5 5 + [iie]: https://modrinth.com/mod/infinity-item-editor/version/0.15

+40

nara_slurper_1_12_infinity/src/lib.rs

··· 1 1 + use std::path::Path; 2 2 + 3 3 + use nara_core::book::{Book, BookSource}; 4 4 + use nara_slurper_1_12_core::{ 5 5 + extract_books_with_source, 6 6 + item::{InventoryItemStack, ItemStack}, 7 7 + }; 8 8 + use serde::Deserialize; 9 9 + 10 10 + #[derive(Debug, Deserialize)] 11 11 + pub struct Realm { 12 12 + pub realm: Vec<ItemStack>, 13 13 + pub realm_version: String, 14 14 + } 15 15 + 16 16 + impl Realm { 17 17 + pub fn read<P>(path: P) -> nara_io::Result<Realm> 18 18 + where 19 19 + P: AsRef<Path>, 20 20 + { 21 21 + let buffer = std::fs::read(path)?; 22 22 + nara_io::read_nbt(&buffer) 23 23 + } 24 24 + 25 25 + pub fn slurp(&self) -> Vec<Book> { 26 26 + let fake_inventory: Vec<InventoryItemStack> = self 27 27 + .realm 28 28 + .iter() 29 29 + .enumerate() 30 30 + .map(|(slot, item)| InventoryItemStack { 31 31 + item: item.clone(), 32 32 + slot: slot as i8, 33 33 + }) 34 34 + .collect(); 35 35 + 36 36 + extract_books_with_source(&fake_inventory, None, None, &|_| { 37 37 + BookSource::InfinityRealm 38 38 + }) 39 39 + } 40 40 + }

+20

nara_slurper_1_12_world/Cargo.toml

··· 1 1 + [package] 2 2 + name = "nara_slurper_1_12_world" 3 3 + version.workspace = true 4 4 + edition.workspace = true 5 5 + 6 6 + [dependencies] 7 7 + crab_nbt.workspace = true 8 8 + nara_mcr.workspace = true 9 9 + nara_slurper_1_12_core.workspace = true 10 10 + nara_io.workspace = true 11 11 + nara_core.workspace = true 12 12 + serde.workspace = true 13 13 + serde_with.workspace = true 14 14 + thiserror.workspace = true 15 15 + tokio.workspace = true 16 16 + tracing.workspace = true 17 17 + uuid.workspace = true 18 18 + 19 19 + [dev-dependencies] 20 20 + insta.workspace = true

+9

nara_slurper_1_12_world/README.md

··· 1 1 + # nara_slurper_1_12_world 2 2 + 3 3 + Pulls book data from everywhere it possibly can from Minecraft: Java Edition 4 4 + worlds saved in 1.12.2's world format. 5 5 + 6 6 + Checks: 7 7 + 8 8 + - entitydata 9 9 + - item frames

+218

nara_slurper_1_12_world/src/lib.rs

··· 1 1 + use std::{ 2 2 + path::{Path, PathBuf}, 3 3 + sync::{Arc, Mutex}, 4 4 + }; 5 5 + 6 6 + use nara_core::book::{Book, BookSource}; 7 7 + use nara_io::read_nbt; 8 8 + use nara_mcr::McRegion; 9 9 + use nara_slurper_1_12_core::{ 10 10 + chunk::{Chunk, Entity}, 11 11 + extract_books_with_source, 12 12 + item::InventoryItemStack, 13 13 + }; 14 14 + use tokio::task::JoinSet; 15 15 + 16 16 + use crate::playerdata::PlayerData; 17 17 + 18 18 + pub mod playerdata; 19 19 + 20 20 + #[derive(Debug, thiserror::Error)] 21 21 + pub enum Error { 22 22 + #[error(transparent)] 23 23 + Io(#[from] std::io::Error), 24 24 + #[error(transparent)] 25 25 + NaraIo(#[from] nara_io::Error), 26 26 + #[error(transparent)] 27 27 + McRegion(#[from] nara_mcr::Error), 28 28 + #[error("worker task panicked: {0}")] 29 29 + Join(#[from] tokio::task::JoinError), 30 30 + } 31 31 + 32 32 + pub type Result<T> = std::result::Result<T, Error>; 33 33 + 34 34 + enum Job { 35 35 + Playerdata(PathBuf), 36 36 + Region { path: PathBuf, dimension: String }, 37 37 + } 38 38 + 39 39 + pub async fn slurp_world( 40 40 + world_directory: &Path, 41 41 + num_workers: usize, 42 42 + ) -> Result<Vec<Book>> { 43 43 + let (tx, rx) = std::sync::mpsc::channel::<Job>(); 44 44 + let rx = Arc::new(Mutex::new(rx)); 45 45 + 46 46 + let mut set: JoinSet<Result<Vec<Book>>> = JoinSet::new(); 47 47 + for _ in 0..num_workers { 48 48 + let rx = Arc::clone(&rx); 49 49 + set.spawn_blocking(move || { 50 50 + let mut books = Vec::new(); 51 51 + loop { 52 52 + let job = rx.lock().unwrap().recv(); 53 53 + match job { 54 54 + Ok(Job::Playerdata(path)) => { 55 55 + books.extend(slurp_playerdata_file(&path)?); 56 56 + } 57 57 + Ok(Job::Region { path, dimension }) => { 58 58 + books.extend(slurp_region_file(&path, &dimension)?); 59 59 + } 60 60 + Err(_) => break, // channel closed, no more jobs 61 61 + } 62 62 + } 63 63 + Ok(books) 64 64 + }); 65 65 + } 66 66 + 67 67 + // Enumerate files and queue jobs. This is fast synchronous directory I/O 68 68 + // so it stays in the async task. 69 69 + let playerdata_dir = world_directory.join("playerdata"); 70 70 + if playerdata_dir.exists() { 71 71 + for entry in std::fs::read_dir(&playerdata_dir)? { 72 72 + let _ = tx.send(Job::Playerdata(entry?.path())); 73 73 + } 74 74 + } 75 75 + 76 76 + for (dimension_dir, dimension) in [( 77 77 + world_directory.to_owned(), 78 78 + world_directory 79 79 + .file_name() 80 80 + .unwrap() 81 81 + .to_os_string() 82 82 + .into_string() 83 83 + .unwrap(), 84 84 + )] { 85 85 + let region_dir = dimension_dir.join("region"); 86 86 + if !region_dir.exists() { 87 87 + continue; 88 88 + } 89 89 + for entry in std::fs::read_dir(&region_dir)? { 90 90 + let path = entry?.path(); 91 91 + if path.extension().and_then(|e| e.to_str()) != Some("mca") { 92 92 + continue; 93 93 + } 94 94 + let _ = tx.send(Job::Region { 95 95 + path, 96 96 + dimension: dimension.to_owned(), 97 97 + }); 98 98 + } 99 99 + } 100 100 + 101 101 + drop(tx); 102 102 + 103 103 + let mut books = Vec::new(); 104 104 + while let Some(result) = set.join_next().await { 105 105 + books.extend(result??); 106 106 + } 107 107 + Ok(books) 108 108 + } 109 109 + 110 110 + fn slurp_playerdata_file(path: &Path) -> Result<Vec<Book>> { 111 111 + let buffer = std::fs::read(path)?; 112 112 + let playerdata = read_nbt::<PlayerData>(&buffer)?; 113 113 + let books = playerdata.slurp(); 114 114 + if !books.is_empty() { 115 115 + tracing::debug!( 116 116 + "Slurped {} book(s) from {}", 117 117 + books.len(), 118 118 + playerdata.uuid() 119 119 + ); 120 120 + } 121 121 + Ok(books) 122 122 + } 123 123 + 124 124 + fn slurp_region_file(path: &Path, dimension: &str) -> Result<Vec<Book>> { 125 125 + tracing::debug!("Slurping {path:?}..."); 126 126 + let data = std::fs::read(path)?; 127 127 + let region = McRegion::<Chunk>::from_bytes(&data)?; 128 128 + 129 129 + let mut books = Vec::new(); 130 130 + for (_, chunk) in region.iter() { 131 131 + for e in &chunk.level.entities { 132 132 + match e { 133 133 + Entity::ItemHolder(item_holder_entity) => { 134 134 + let fake_inventory = vec![InventoryItemStack { 135 135 + slot: 0, 136 136 + item: item_holder_entity.item.clone(), 137 137 + }]; 138 138 + let slurped = extract_books_with_source( 139 139 + &fake_inventory, 140 140 + None, 141 141 + None, 142 142 + &|_| BookSource::Entity { 143 143 + dimension: dimension.to_string(), 144 144 + id: item_holder_entity.base.id.clone(), 145 145 + x: item_holder_entity.base.position[0], 146 146 + y: item_holder_entity.base.position[1], 147 147 + z: item_holder_entity.base.position[2], 148 148 + }, 149 149 + ); 150 150 + if !slurped.is_empty() { 151 151 + tracing::debug!( 152 152 + "Slurped a book from a {} at {:?} in chunk ({}, {}) of {path:?}", 153 153 + item_holder_entity.base.id, 154 154 + item_holder_entity.base.position, 155 155 + chunk.level.x_pos, 156 156 + chunk.level.z_pos 157 157 + ); 158 158 + } 159 159 + books.extend(slurped); 160 160 + } 161 161 + Entity::Inventoried(inventoried_entity) => { 162 162 + let slurped = extract_books_with_source( 163 163 + &inventoried_entity.items, 164 164 + None, 165 165 + None, 166 166 + &|slot| BookSource::EntityInventory { 167 167 + dimension: dimension.to_string(), 168 168 + id: inventoried_entity.base.id.clone(), 169 169 + x: inventoried_entity.base.position[0], 170 170 + y: inventoried_entity.base.position[1], 171 171 + z: inventoried_entity.base.position[2], 172 172 + slot, 173 173 + }, 174 174 + ); 175 175 + if !slurped.is_empty() { 176 176 + tracing::debug!( 177 177 + "Slurped {} book(s) from a {} at {:?} in chunk ({}, {}) of {path:?}", 178 178 + slurped.len(), 179 179 + inventoried_entity.base.id, 180 180 + inventoried_entity.base.position, 181 181 + chunk.level.x_pos, 182 182 + chunk.level.z_pos 183 183 + ); 184 184 + } 185 185 + books.extend(slurped); 186 186 + } 187 187 + _ => {} 188 188 + } 189 189 + } 190 190 + for te in &chunk.level.tile_entities { 191 191 + let slurped = 192 192 + extract_books_with_source(&te.items, None, None, &|slot| { 193 193 + BookSource::BlockEntity { 194 194 + dimension: dimension.to_string(), 195 195 + id: te.id.clone(), 196 196 + x: te.x, 197 197 + y: te.y, 198 198 + z: te.z, 199 199 + slot, 200 200 + } 201 201 + }); 202 202 + if !slurped.is_empty() { 203 203 + tracing::debug!( 204 204 + "Slurped {} book(s) from a {} at ({},{},{}) in chunk ({},{}) of {path:?}", 205 205 + slurped.len(), 206 206 + te.id, 207 207 + te.x, 208 208 + te.y, 209 209 + te.z, 210 210 + chunk.level.x_pos, 211 211 + chunk.level.z_pos, 212 212 + ); 213 213 + } 214 214 + books.extend(slurped); 215 215 + } 216 216 + } 217 217 + Ok(books) 218 218 + }

+58

nara_slurper_1_12_world/src/playerdata.rs

··· 1 1 + use nara_core::{ 2 2 + book::{Book, BookSource, PlayerInventoryKind}, 3 3 + i64_pair_to_uuid, 4 4 + }; 5 5 + use nara_slurper_1_12_core::{ 6 6 + extract_books_with_source, item::InventoryItemStack, 7 7 + }; 8 8 + use serde::Deserialize; 9 9 + use uuid::Uuid; 10 10 + 11 11 + // the shit we care about from playerdata.dat files :^) 12 12 + #[derive(Debug, Deserialize)] 13 13 + #[serde(rename_all = "PascalCase")] 14 14 + pub struct PlayerData { 15 15 + #[serde(rename = "UUIDLeast")] 16 16 + pub uuid_least: i64, 17 17 + #[serde(rename = "UUIDMost")] 18 18 + pub uuid_most: i64, 19 19 + #[serde(default)] 20 20 + pub inventory: Vec<InventoryItemStack>, 21 21 + #[serde(default, rename = "EnderItems")] 22 22 + pub ender_chest: Vec<InventoryItemStack>, 23 23 + } 24 24 + 25 25 + impl PlayerData { 26 26 + pub fn uuid(&self) -> Uuid { 27 27 + i64_pair_to_uuid(self.uuid_most, self.uuid_least) 28 28 + } 29 29 + 30 30 + pub fn slurp(&self) -> Vec<Book> { 31 31 + let uuid = self.uuid(); 32 32 + let mut books = Vec::new(); 33 33 + 34 34 + books.extend(extract_books_with_source( 35 35 + &self.inventory, 36 36 + None, 37 37 + None, 38 38 + &|slot| BookSource::PlayerData { 39 39 + uuid, 40 40 + inventory: PlayerInventoryKind::Inventory, 41 41 + slot, 42 42 + }, 43 43 + )); 44 44 + 45 45 + books.extend(extract_books_with_source( 46 46 + &self.ender_chest, 47 47 + None, 48 48 + None, 49 49 + &|slot| BookSource::PlayerData { 50 50 + uuid, 51 51 + inventory: PlayerInventoryKind::EnderChest, 52 52 + slot, 53 53 + }, 54 54 + )); 55 55 + 56 56 + books 57 57 + } 58 58 + }

+17

nara_slurper_1_12_world/tests/data.rs

··· 1 1 + use nara_slurper_1_12_world::playerdata::PlayerData; 2 2 + 3 3 + const PLAYER_DATA_FIXTURE: &[u8] = include_bytes!("fixtures/playerdata.dat"); 4 4 + 5 5 + fn get_playerdata() -> PlayerData { 6 6 + nara_io::read_nbt(PLAYER_DATA_FIXTURE).unwrap() 7 7 + } 8 8 + 9 9 + #[test] 10 10 + fn playerdata() { 11 11 + insta::assert_debug_snapshot!(get_playerdata()); 12 12 + } 13 13 + 14 14 + #[test] 15 15 + fn playerdata_slurp() { 16 16 + insta::assert_debug_snapshot!(get_playerdata().slurp()); 17 17 + }

nara_slurper_1_12_world/tests/fixtures/playerdata.dat

This is a binary file and will not be displayed.

+296

nara_slurper_1_12_world/tests/snapshots/data__playerdata.snap

··· 1 1 + --- 2 2 + source: nara_slurper_1_12_world/tests/data.rs 3 3 + expression: get_playerdata() 4 4 + --- 5 5 + PlayerData { 6 6 + uuid_least: -7869178909067405374, 7 7 + uuid_most: -8520075660724779485, 8 8 + inventory: [ 9 9 + InventoryItemStack { 10 10 + item: WrittenBook( 11 11 + WrittenBookStack { 12 12 + count: 1, 13 13 + damage: 0, 14 14 + id: "minecraft:written_book", 15 15 + tag: WrittenBookTag { 16 16 + base: BaseTag { 17 17 + display: None, 18 18 + }, 19 19 + author: "kokiriglade", 20 20 + title: "just a book", 21 21 + generation: Original, 22 22 + resolved: false, 23 23 + pages: [ 24 24 + Array( 25 25 + [ 26 26 + Object( 27 27 + ComponentObject { 28 28 + text: Some( 29 29 + TextComponent { 30 30 + text: "Hello, World!\n\n", 31 31 + }, 32 32 + ), 33 33 + translation: None, 34 34 + score: None, 35 35 + selector: None, 36 36 + keybind: None, 37 37 + nbt: None, 38 38 + object: None, 39 39 + formatting: ComponentFormatting { 40 40 + color: None, 41 41 + font: None, 42 42 + bold: None, 43 43 + italic: None, 44 44 + underlined: None, 45 45 + strikethrough: None, 46 46 + obfuscated: None, 47 47 + }, 48 48 + children: [], 49 49 + }, 50 50 + ), 51 51 + Object( 52 52 + ComponentObject { 53 53 + text: Some( 54 54 + TextComponent { 55 55 + text: "This is red text!", 56 56 + }, 57 57 + ), 58 58 + translation: None, 59 59 + score: None, 60 60 + selector: None, 61 61 + keybind: None, 62 62 + nbt: None, 63 63 + object: None, 64 64 + formatting: ComponentFormatting { 65 65 + color: Some( 66 66 + Named( 67 67 + Red, 68 68 + ), 69 69 + ), 70 70 + font: None, 71 71 + bold: None, 72 72 + italic: None, 73 73 + underlined: None, 74 74 + strikethrough: None, 75 75 + obfuscated: None, 76 76 + }, 77 77 + children: [], 78 78 + }, 79 79 + ), 80 80 + Object( 81 81 + ComponentObject { 82 82 + text: Some( 83 83 + TextComponent { 84 84 + text: "\n\n", 85 85 + }, 86 86 + ), 87 87 + translation: None, 88 88 + score: None, 89 89 + selector: None, 90 90 + keybind: None, 91 91 + nbt: None, 92 92 + object: None, 93 93 + formatting: ComponentFormatting { 94 94 + color: None, 95 95 + font: None, 96 96 + bold: None, 97 97 + italic: None, 98 98 + underlined: None, 99 99 + strikethrough: None, 100 100 + obfuscated: None, 101 101 + }, 102 102 + children: [], 103 103 + }, 104 104 + ), 105 105 + Object( 106 106 + ComponentObject { 107 107 + text: Some( 108 108 + TextComponent { 109 109 + text: "This is blue :^)", 110 110 + }, 111 111 + ), 112 112 + translation: None, 113 113 + score: None, 114 114 + selector: None, 115 115 + keybind: None, 116 116 + nbt: None, 117 117 + object: None, 118 118 + formatting: ComponentFormatting { 119 119 + color: Some( 120 120 + Named( 121 121 + Blue, 122 122 + ), 123 123 + ), 124 124 + font: None, 125 125 + bold: None, 126 126 + italic: None, 127 127 + underlined: None, 128 128 + strikethrough: None, 129 129 + obfuscated: None, 130 130 + }, 131 131 + children: [], 132 132 + }, 133 133 + ), 134 134 + ], 135 135 + ), 136 136 + ], 137 137 + }, 138 138 + }, 139 139 + ), 140 140 + slot: 0, 141 141 + }, 142 142 + InventoryItemStack { 143 143 + item: BlockEntity( 144 144 + BlockEntityStack { 145 145 + count: 1, 146 146 + damage: 0, 147 147 + id: "minecraft:pink_shulker_box", 148 148 + tag: BlockEntityTag { 149 149 + base: BaseTag { 150 150 + display: None, 151 151 + }, 152 152 + block_entity: BlockEntity { 153 153 + items: [ 154 154 + InventoryItemStack { 155 155 + item: WrittenBook( 156 156 + WrittenBookStack { 157 157 + count: 1, 158 158 + damage: 0, 159 159 + id: "minecraft:written_book", 160 160 + tag: WrittenBookTag { 161 161 + base: BaseTag { 162 162 + display: None, 163 163 + }, 164 164 + author: "kokiriglade", 165 165 + title: "in a shulker box", 166 166 + generation: Original, 167 167 + resolved: false, 168 168 + pages: [ 169 169 + Object( 170 170 + ComponentObject { 171 171 + text: Some( 172 172 + TextComponent { 173 173 + text: "this one is in a shulker box!! wow!!!", 174 174 + }, 175 175 + ), 176 176 + translation: None, 177 177 + score: None, 178 178 + selector: None, 179 179 + keybind: None, 180 180 + nbt: None, 181 181 + object: None, 182 182 + formatting: ComponentFormatting { 183 183 + color: None, 184 184 + font: None, 185 185 + bold: None, 186 186 + italic: None, 187 187 + underlined: None, 188 188 + strikethrough: None, 189 189 + obfuscated: None, 190 190 + }, 191 191 + children: [], 192 192 + }, 193 193 + ), 194 194 + ], 195 195 + }, 196 196 + }, 197 197 + ), 198 198 + slot: 2, 199 199 + }, 200 200 + ], 201 201 + }, 202 202 + }, 203 203 + }, 204 204 + ), 205 205 + slot: 1, 206 206 + }, 207 207 + InventoryItemStack { 208 208 + item: Base( 209 209 + BaseItemStack { 210 210 + count: 1, 211 211 + damage: 0, 212 212 + id: "minecraft:stone", 213 213 + }, 214 214 + ), 215 215 + slot: 2, 216 216 + }, 217 217 + InventoryItemStack { 218 218 + item: Base( 219 219 + BaseItemStack { 220 220 + count: 1, 221 221 + damage: 0, 222 222 + id: "minecraft:reeds", 223 223 + }, 224 224 + ), 225 225 + slot: 4, 226 226 + }, 227 227 + InventoryItemStack { 228 228 + item: Base( 229 229 + BaseItemStack { 230 230 + count: 1, 231 231 + damage: 0, 232 232 + id: "minecraft:golden_chestplate", 233 233 + }, 234 234 + ), 235 235 + slot: 5, 236 236 + }, 237 237 + InventoryItemStack { 238 238 + item: Base( 239 239 + BaseItemStack { 240 240 + count: 1, 241 241 + damage: 0, 242 242 + id: "minecraft:ender_chest", 243 243 + }, 244 244 + ), 245 245 + slot: 7, 246 246 + }, 247 247 + ], 248 248 + ender_chest: [ 249 249 + InventoryItemStack { 250 250 + item: WrittenBook( 251 251 + WrittenBookStack { 252 252 + count: 1, 253 253 + damage: 0, 254 254 + id: "minecraft:written_book", 255 255 + tag: WrittenBookTag { 256 256 + base: BaseTag { 257 257 + display: None, 258 258 + }, 259 259 + author: "kokiriglade", 260 260 + title: "ender book :^)", 261 261 + generation: Original, 262 262 + resolved: false, 263 263 + pages: [ 264 264 + Object( 265 265 + ComponentObject { 266 266 + text: Some( 267 267 + TextComponent { 268 268 + text: "this ones in my ender chest !! wow !!!!", 269 269 + }, 270 270 + ), 271 271 + translation: None, 272 272 + score: None, 273 273 + selector: None, 274 274 + keybind: None, 275 275 + nbt: None, 276 276 + object: None, 277 277 + formatting: ComponentFormatting { 278 278 + color: None, 279 279 + font: None, 280 280 + bold: None, 281 281 + italic: None, 282 282 + underlined: None, 283 283 + strikethrough: None, 284 284 + obfuscated: None, 285 285 + }, 286 286 + children: [], 287 287 + }, 288 288 + ), 289 289 + ], 290 290 + }, 291 291 + }, 292 292 + ), 293 293 + slot: 16, 294 294 + }, 295 295 + ], 296 296 + }

+223

nara_slurper_1_12_world/tests/snapshots/data__playerdata_slurp.snap

··· 1 1 + --- 2 2 + source: nara_slurper_1_12_world/tests/data.rs 3 3 + expression: get_playerdata().slurp() 4 4 + --- 5 5 + [ 6 6 + Book { 7 7 + metadata: BookMetadata { 8 8 + source: PlayerData { 9 9 + uuid: 89c29c53-ef0c-4623-92cb-0f79930a97c2, 10 10 + inventory: Inventory, 11 11 + slot: 0, 12 12 + }, 13 13 + }, 14 14 + content: BookContent { 15 15 + author: "kokiriglade", 16 16 + pages: [ 17 17 + Array( 18 18 + [ 19 19 + Object( 20 20 + ComponentObject { 21 21 + text: Some( 22 22 + TextComponent { 23 23 + text: "Hello, World!\n\n", 24 24 + }, 25 25 + ), 26 26 + translation: None, 27 27 + score: None, 28 28 + selector: None, 29 29 + keybind: None, 30 30 + nbt: None, 31 31 + object: None, 32 32 + formatting: ComponentFormatting { 33 33 + color: None, 34 34 + font: None, 35 35 + bold: None, 36 36 + italic: None, 37 37 + underlined: None, 38 38 + strikethrough: None, 39 39 + obfuscated: None, 40 40 + }, 41 41 + children: [], 42 42 + }, 43 43 + ), 44 44 + Object( 45 45 + ComponentObject { 46 46 + text: Some( 47 47 + TextComponent { 48 48 + text: "This is red text!", 49 49 + }, 50 50 + ), 51 51 + translation: None, 52 52 + score: None, 53 53 + selector: None, 54 54 + keybind: None, 55 55 + nbt: None, 56 56 + object: None, 57 57 + formatting: ComponentFormatting { 58 58 + color: Some( 59 59 + Named( 60 60 + Red, 61 61 + ), 62 62 + ), 63 63 + font: None, 64 64 + bold: None, 65 65 + italic: None, 66 66 + underlined: None, 67 67 + strikethrough: None, 68 68 + obfuscated: None, 69 69 + }, 70 70 + children: [], 71 71 + }, 72 72 + ), 73 73 + Object( 74 74 + ComponentObject { 75 75 + text: Some( 76 76 + TextComponent { 77 77 + text: "\n\n", 78 78 + }, 79 79 + ), 80 80 + translation: None, 81 81 + score: None, 82 82 + selector: None, 83 83 + keybind: None, 84 84 + nbt: None, 85 85 + object: None, 86 86 + formatting: ComponentFormatting { 87 87 + color: None, 88 88 + font: None, 89 89 + bold: None, 90 90 + italic: None, 91 91 + underlined: None, 92 92 + strikethrough: None, 93 93 + obfuscated: None, 94 94 + }, 95 95 + children: [], 96 96 + }, 97 97 + ), 98 98 + Object( 99 99 + ComponentObject { 100 100 + text: Some( 101 101 + TextComponent { 102 102 + text: "This is blue :^)", 103 103 + }, 104 104 + ), 105 105 + translation: None, 106 106 + score: None, 107 107 + selector: None, 108 108 + keybind: None, 109 109 + nbt: None, 110 110 + object: None, 111 111 + formatting: ComponentFormatting { 112 112 + color: Some( 113 113 + Named( 114 114 + Blue, 115 115 + ), 116 116 + ), 117 117 + font: None, 118 118 + bold: None, 119 119 + italic: None, 120 120 + underlined: None, 121 121 + strikethrough: None, 122 122 + obfuscated: None, 123 123 + }, 124 124 + children: [], 125 125 + }, 126 126 + ), 127 127 + ], 128 128 + ), 129 129 + ], 130 130 + title: "just a book", 131 131 + generation: Original, 132 132 + resolved: false, 133 133 + }, 134 134 + }, 135 135 + Book { 136 136 + metadata: BookMetadata { 137 137 + source: ItemBlockEntity { 138 138 + id: "minecraft:pink_shulker_box", 139 139 + slot: 2, 140 140 + within: PlayerData { 141 141 + uuid: 89c29c53-ef0c-4623-92cb-0f79930a97c2, 142 142 + inventory: Inventory, 143 143 + slot: 1, 144 144 + }, 145 145 + }, 146 146 + }, 147 147 + content: BookContent { 148 148 + author: "kokiriglade", 149 149 + pages: [ 150 150 + Object( 151 151 + ComponentObject { 152 152 + text: Some( 153 153 + TextComponent { 154 154 + text: "this one is in a shulker box!! wow!!!", 155 155 + }, 156 156 + ), 157 157 + translation: None, 158 158 + score: None, 159 159 + selector: None, 160 160 + keybind: None, 161 161 + nbt: None, 162 162 + object: None, 163 163 + formatting: ComponentFormatting { 164 164 + color: None, 165 165 + font: None, 166 166 + bold: None, 167 167 + italic: None, 168 168 + underlined: None, 169 169 + strikethrough: None, 170 170 + obfuscated: None, 171 171 + }, 172 172 + children: [], 173 173 + }, 174 174 + ), 175 175 + ], 176 176 + title: "in a shulker box", 177 177 + generation: Original, 178 178 + resolved: false, 179 179 + }, 180 180 + }, 181 181 + Book { 182 182 + metadata: BookMetadata { 183 183 + source: PlayerData { 184 184 + uuid: 89c29c53-ef0c-4623-92cb-0f79930a97c2, 185 185 + inventory: EnderChest, 186 186 + slot: 16, 187 187 + }, 188 188 + }, 189 189 + content: BookContent { 190 190 + author: "kokiriglade", 191 191 + pages: [ 192 192 + Object( 193 193 + ComponentObject { 194 194 + text: Some( 195 195 + TextComponent { 196 196 + text: "this ones in my ender chest !! wow !!!!", 197 197 + }, 198 198 + ), 199 199 + translation: None, 200 200 + score: None, 201 201 + selector: None, 202 202 + keybind: None, 203 203 + nbt: None, 204 204 + object: None, 205 205 + formatting: ComponentFormatting { 206 206 + color: None, 207 207 + font: None, 208 208 + bold: None, 209 209 + italic: None, 210 210 + underlined: None, 211 211 + strikethrough: None, 212 212 + obfuscated: None, 213 213 + }, 214 214 + children: [], 215 215 + }, 216 216 + ), 217 217 + ], 218 218 + title: "ender book :^)", 219 219 + generation: Original, 220 220 + resolved: false, 221 221 + }, 222 222 + }, 223 223 + ]

+69 -5

src/cli.rs

··· 1 1 use std::path::PathBuf; 2 2 3 3 - use clap::{ArgAction, Parser}; 3 3 + use clap::{ArgAction, Args, Parser, Subcommand}; 4 4 5 5 use crate::web::TextureKind; 6 6 7 7 #[derive(Parser, Debug)] 8 8 #[command(version, about, long_about = None)] 9 9 - pub struct Args { 9 9 + pub struct Cli { 10 10 + #[command(subcommand)] 11 11 + pub command: Command, 12 12 + } 13 13 + 14 14 + #[derive(Subcommand, Debug)] 15 15 + pub enum Command { 16 16 + /// Build the library and optionally run the webserver. 17 17 + Serve(ServeArgs), 18 18 + /// Slurp a world directory. 19 19 + SlurpWorld(SlurpWorldArgs), 20 20 + /// Slurp an Infinity Item Editor realm. 21 21 + SlurpRealm(SlurpRealmArgs), 22 22 + } 23 23 + 24 24 + #[derive(Debug, Clone, Copy, clap::ValueEnum)] 25 25 + #[clap(rename_all = "snake_case")] 26 26 + pub enum MinecraftVersion { 27 27 + V1_12, 28 28 + } 29 29 + 30 30 + #[derive(Args, Debug)] 31 31 + pub struct SlurpRealmArgs { 32 32 + #[arg(short = 'v', long = "version", default_value = "v1_12")] 33 33 + pub version: MinecraftVersion, 34 34 + 10 35 /// The path to the `realm.nbt` file created by Infinity Item Editor. 11 36 #[arg(short = 'r', long = "realm", default_value = "realm.nbt")] 12 37 pub realm_path: PathBuf, 13 38 14 14 - /// Whether to warn about duplicate books being found during initial indexing. 15 15 - #[arg(short = 'd', long, default_value_t = true, action = ArgAction::Set)] 16 16 - pub warn_duplicates: bool, 39 39 + /// Path to the book container to create or update. 40 40 + #[arg( 41 41 + short = 'c', 42 42 + long = "container", 43 43 + default_value = "container.json.gz" 44 44 + )] 45 45 + pub container_path: PathBuf, 46 46 + } 47 47 + 48 48 + #[derive(Args, Debug)] 49 49 + pub struct SlurpWorldArgs { 50 50 + #[arg(short = 'v', long = "version", default_value = "v1_12")] 51 51 + pub version: MinecraftVersion, 52 52 + 53 53 + /// Path to the world directory. 54 54 + #[arg(short = 'w', long = "world")] 55 55 + pub world_path: PathBuf, 56 56 + 57 57 + /// Number of worker threads used for parallel file slurping. 58 58 + /// Defaults to the number of logical CPUs. 59 59 + #[arg(short = 'j', long = "workers")] 60 60 + pub workers: Option<usize>, 61 61 + 62 62 + /// Path to the book container to create or update. 63 63 + #[arg( 64 64 + short = 'c', 65 65 + long = "container", 66 66 + default_value = "container.json.gz" 67 67 + )] 68 68 + pub container_path: PathBuf, 69 69 + } 70 70 + 71 71 + #[derive(Args, Debug)] 72 72 + pub struct ServeArgs { 17 73 /// Whether to warn about empty/whitespace books being skipped during indexing. 18 74 #[arg(short = 'e', long, default_value_t = true, action = ArgAction::Set)] 19 75 pub warn_empty: bool, ··· 30 86 /// The score threshold for fuzzy finding book authors. 31 87 #[arg(short = 'A', long, default_value_t = 0.82)] 32 88 pub author_threshold: f64, 89 89 + 90 90 + /// Path to the book container to load. 91 91 + #[arg( 92 92 + short = 'c', 93 93 + long = "container", 94 94 + default_value = "container.json.gz" 95 95 + )] 96 96 + pub container_path: PathBuf, 33 97 34 98 #[arg(short = 's', long = "dont-start-webserver", action = ArgAction::SetFalse)] 35 99 pub start_webserver: bool,

-131

src/library/item.rs

··· 1 1 - use serde::{Deserialize, Serialize}; 2 2 - use serde_with::skip_serializing_none; 3 3 - use sha1::Digest; 4 4 - 5 5 - use crate::library::{ 6 6 - BookHash, 7 7 - text::{Component, normalize_page}, 8 8 - }; 9 9 - 10 10 - /// Top-level item container parsed from realm exports. 11 11 - #[skip_serializing_none] 12 12 - #[derive(Debug, Clone, Serialize, Deserialize)] 13 13 - #[serde(tag = "id", rename_all_fields = "PascalCase")] 14 14 - pub enum ItemStack { 15 15 - /// A written book stack with the data we index. 16 16 - #[serde(rename = "minecraft:written_book")] 17 17 - WrittenBook { 18 18 - count: i8, 19 19 - damage: i16, 20 20 - slot: Option<i8>, 21 21 - #[serde(rename = "tag")] 22 22 - tag: WrittenBookTag, 23 23 - }, 24 24 - /// A shulker box that can contain nested items. 25 25 - #[serde( 26 26 - rename = "minecraft:red_shulker_box", 27 27 - alias = "minecraft:orange_shulker_box", 28 28 - alias = "minecraft:yellow_shulker_box", 29 29 - alias = "minecraft:lime_shulker_box", 30 30 - alias = "minecraft:green_shulker_box", 31 31 - alias = "minecraft:cyan_shulker_box", 32 32 - alias = "minecraft:light_blue_shulker_box", 33 33 - alias = "minecraft:blue_shulker_box", 34 34 - alias = "minecraft:purple_shulker_box", 35 35 - alias = "minecraft:magenta_shulker_box", 36 36 - alias = "minecraft:pink_shulker_box", 37 37 - alias = "minecraft:brown_shulker_box", 38 38 - alias = "minecraft:black_shulker_box", 39 39 - alias = "minecraft:gray_shulker_box", 40 40 - alias = "minecraft:light_gray_shulker_box", 41 41 - alias = "minecraft:white_shulker_box", 42 42 - alias = "minecraft:shulker_box" 43 43 - )] 44 44 - ShulkerBox { 45 45 - count: i8, 46 46 - damage: i16, 47 47 - slot: Option<i8>, 48 48 - #[serde(rename = "tag")] 49 49 - tag: ShulkerBoxTag, 50 50 - }, 51 51 - } 52 52 - 53 53 - /// NBT tag data for a written book. 54 54 - #[skip_serializing_none] 55 55 - #[derive(Debug, Clone, Serialize, Deserialize)] 56 56 - pub struct WrittenBookTag { 57 57 - pub display: Option<DisplayTag>, 58 58 - 59 59 - #[serde(rename = "author")] 60 60 - pub author: String, 61 61 - 62 62 - #[serde(rename = "title")] 63 63 - pub title: String, 64 64 - 65 65 - #[serde(rename = "generation")] 66 66 - pub generation: Option<i32>, 67 67 - 68 68 - #[serde(rename = "resolved")] 69 69 - pub resolved: Option<i8>, 70 70 - 71 71 - #[serde(rename = "pages", default)] 72 72 - pub pages: Vec<Component>, 73 73 - } 74 74 - 75 75 - impl WrittenBookTag { 76 76 - /// Computes the hash of the book's contents. 77 77 - /// 78 78 - /// Metadata is not taken into account when calculating the hash. The hash should _only_ be used 79 79 - /// to quantify "content uniqueness". 80 80 - pub fn hash(&self) -> BookHash { 81 81 - let mut ctx = sha1::Sha1::new(); 82 82 - 83 83 - #[inline(always)] 84 84 - fn put_str(ctx: &mut sha1::Sha1, s: &str) { 85 85 - ctx.update(s.as_bytes()); 86 86 - } 87 87 - 88 88 - #[inline(always)] 89 89 - fn put_vec_page(ctx: &mut sha1::Sha1, v: &[Component]) { 90 90 - for c in v { 91 91 - let s = normalize_page(c); 92 92 - put_str(ctx, &s); 93 93 - } 94 94 - } 95 95 - 96 96 - put_str(&mut ctx, &self.author); 97 97 - put_str(&mut ctx, &self.title); 98 98 - put_vec_page(&mut ctx, &self.pages); 99 99 - 100 100 - ctx.finalize().0 101 101 - } 102 102 - } 103 103 - 104 104 - /// NBT tag data for a shulker box. 105 105 - #[skip_serializing_none] 106 106 - #[derive(Debug, Clone, Serialize, Deserialize)] 107 107 - pub struct ShulkerBoxTag { 108 108 - pub display: Option<DisplayTag>, 109 109 - 110 110 - #[serde(rename = "BlockEntityTag")] 111 111 - pub block_entity: ShulkerBlockEntityTag, 112 112 - } 113 113 - 114 114 - /// Block entity payload for a shulker box, containing its items. 115 115 - #[skip_serializing_none] 116 116 - #[derive(Debug, Clone, Serialize, Deserialize)] 117 117 - #[serde(rename_all = "PascalCase")] 118 118 - pub struct ShulkerBlockEntityTag { 119 119 - pub custom_name: Option<String>, 120 120 - 121 121 - #[serde(default)] 122 122 - pub items: Vec<ItemStack>, 123 123 - } 124 124 - 125 125 - /// Common display metadata (custom name, etc.). 126 126 - #[skip_serializing_none] 127 127 - #[derive(Debug, Clone, Serialize, Deserialize)] 128 128 - #[serde(rename_all = "PascalCase")] 129 129 - pub struct DisplayTag { 130 130 - pub name: Option<String>, 131 131 - }

-550

src/library/text.rs

··· 1 1 - use html_escape::encode_text; 2 2 - use serde::de::{ 3 3 - MapAccess, SeqAccess, Visitor, 4 4 - value::{MapAccessDeserializer, SeqAccessDeserializer}, 5 5 - }; 6 6 - use serde::{Deserialize, Deserializer, Serialize}; 7 7 - 8 8 - /// A simplified representation of Minecraft 1.12.2 text components. 9 9 - #[derive(Debug, Clone, Serialize)] 10 10 - #[serde(untagged)] 11 11 - pub enum Component { 12 12 - String(String), 13 13 - Object(ComponentObject), 14 14 - Array(Vec<Component>), 15 15 - } 16 16 - 17 17 - #[serde_with::skip_serializing_none] 18 18 - #[derive(Debug, Clone, Serialize, Deserialize)] 19 19 - pub struct ComponentObject { 20 20 - #[serde(default)] 21 21 - pub text: Option<String>, 22 22 - #[serde(default)] 23 23 - pub color: Option<String>, 24 24 - #[serde(default, skip_serializing_if = "Vec::is_empty")] 25 25 - pub extra: Vec<Component>, 26 26 - #[serde(default)] 27 27 - pub translate: Option<String>, 28 28 - #[serde(default, rename = "with", skip_serializing_if = "Vec::is_empty")] 29 29 - pub with_: Vec<Component>, 30 30 - } 31 31 - 32 32 - impl Component { 33 33 - pub fn to_plain_text(&self) -> String { 34 34 - let mut out = String::new(); 35 35 - self.push_plain_text(&mut out); 36 36 - out 37 37 - } 38 38 - 39 39 - pub fn to_html(&self) -> String { 40 40 - let mut out = String::new(); 41 41 - self.push_html(&mut out, None); 42 42 - out 43 43 - } 44 44 - 45 45 - fn push_plain_text(&self, out: &mut String) { 46 46 - match self { 47 47 - Component::String(s) => out.push_str(s), 48 48 - Component::Array(items) => { 49 49 - for c in items { 50 50 - c.push_plain_text(out); 51 51 - } 52 52 - } 53 53 - Component::Object(obj) => { 54 54 - if let Some(t) = &obj.text { 55 55 - out.push_str(t); 56 56 - } else if let Some(t) = &obj.translate { 57 57 - out.push_str(t); 58 58 - } 59 59 - for c in &obj.with_ { 60 60 - c.push_plain_text(out); 61 61 - } 62 62 - for c in &obj.extra { 63 63 - c.push_plain_text(out); 64 64 - } 65 65 - } 66 66 - } 67 67 - } 68 68 - 69 69 - fn push_html<'a>(&'a self, out: &mut String, color: Option<&'a str>) { 70 70 - match self { 71 71 - Component::String(s) => { 72 72 - push_text_with_color(out, s, color); 73 73 - } 74 74 - Component::Array(items) => { 75 75 - for c in items { 76 76 - c.push_html(out, color); 77 77 - } 78 78 - } 79 79 - Component::Object(obj) => { 80 80 - let next_color = obj.color.as_deref().or(color); 81 81 - if let Some(t) = &obj.text { 82 82 - push_text_with_color(out, t, next_color); 83 83 - } else if let Some(t) = &obj.translate { 84 84 - push_text_with_color(out, t, next_color); 85 85 - } 86 86 - for c in &obj.with_ { 87 87 - c.push_html(out, next_color); 88 88 - } 89 89 - for c in &obj.extra { 90 90 - c.push_html(out, next_color); 91 91 - } 92 92 - } 93 93 - } 94 94 - } 95 95 - } 96 96 - 97 97 - const SCRUBBED_GLYPH: char = '\u{f702}'; 98 98 - 99 99 - /// Removes known unwanted glyphs from text content. 100 100 - pub fn scrub_unwanted_glyphs(raw: &str) -> String { 101 101 - raw.chars().filter(|&c| c != SCRUBBED_GLYPH).collect() 102 102 - } 103 103 - 104 104 - /// Recursively removes unwanted glyphs from a component tree. 105 105 - pub fn scrub_component(component: &mut Component) { 106 106 - match component { 107 107 - Component::String(s) => { 108 108 - *s = scrub_unwanted_glyphs(s); 109 109 - } 110 110 - Component::Array(items) => { 111 111 - for item in items { 112 112 - scrub_component(item); 113 113 - } 114 114 - } 115 115 - Component::Object(obj) => { 116 116 - if let Some(text) = &mut obj.text { 117 117 - *text = scrub_unwanted_glyphs(text); 118 118 - } 119 119 - if let Some(translate) = &mut obj.translate { 120 120 - *translate = scrub_unwanted_glyphs(translate); 121 121 - } 122 122 - for item in &mut obj.with_ { 123 123 - scrub_component(item); 124 124 - } 125 125 - for item in &mut obj.extra { 126 126 - scrub_component(item); 127 127 - } 128 128 - } 129 129 - } 130 130 - } 131 131 - 132 132 - /// Removes legacy section symbol formatting codes. 133 133 - fn strip_section_codes(s: &str) -> String { 134 134 - let mut out = String::with_capacity(s.len()); 135 135 - let mut chars = s.chars(); 136 136 - while let Some(c) = chars.next() { 137 137 - if c == SECTION_SIGN { 138 138 - // Skip formatting code character if present. 139 139 - chars.next(); 140 140 - continue; 141 141 - } 142 142 - out.push(c); 143 143 - } 144 144 - out 145 145 - } 146 146 - 147 147 - /// Normalizes a component for hashing. 148 148 - pub fn normalize_page(component: &Component) -> String { 149 149 - let text = component.to_plain_text(); 150 150 - strip_section_codes(&text) 151 151 - } 152 152 - 153 153 - /// Parses a page string into a component, handling stringified JSON. 154 154 - pub fn parse_component_from_str(raw: &str) -> Component { 155 155 - let mut current = raw.trim().to_string(); 156 156 - if current.is_empty() { 157 157 - return Component::String(String::new()); 158 158 - } 159 159 - if let Some(extracted) = extract_text_prefix(&current) { 160 160 - return expand_legacy(legacy_or_plain(&extracted)); 161 161 - } 162 162 - 163 163 - // Try parsing as JSON component once. 164 164 - if let Ok(component) = serde_json::from_str::<Component>(&current) { 165 165 - return expand_legacy(component); 166 166 - } 167 167 - 168 168 - // Try parsing as a JSON string, then re-parse if it was a JSON string that 169 169 - // itself contains JSON (stringified JSON). 170 170 - for _ in 0..3 { 171 171 - let s = match serde_json::from_str::<String>(&current) { 172 172 - Ok(v) => v, 173 173 - Err(_) => break, 174 174 - }; 175 175 - let s_trim = s.trim(); 176 176 - if looks_like_json(s_trim) { 177 177 - current = s_trim.to_string(); 178 178 - if let Ok(component) = serde_json::from_str::<Component>(&current) { 179 179 - return expand_legacy(component); 180 180 - } 181 181 - continue; 182 182 - } 183 183 - return expand_legacy(legacy_or_plain(&s)); 184 184 - } 185 185 - 186 186 - expand_legacy(legacy_or_plain(raw)) 187 187 - } 188 188 - 189 189 - fn looks_like_json(s: &str) -> bool { 190 190 - s.starts_with('{') || s.starts_with('[') 191 191 - } 192 192 - 193 193 - fn extract_text_prefix(s: &str) -> Option<String> { 194 194 - let s = s.trim_start(); 195 195 - if !s.starts_with("text") { 196 196 - return None; 197 197 - } 198 198 - let mut rest = s[4..].trim_start(); 199 199 - if rest.starts_with(':') { 200 200 - rest = rest[1..].trim_start(); 201 201 - } 202 202 - let start = rest.find('"')?; 203 203 - let rest = &rest[start..]; 204 204 - if let Ok(parsed) = serde_json::from_str::<String>(rest) { 205 205 - return Some(parsed); 206 206 - } 207 207 - if let Some(end) = rest[1..].rfind('"') { 208 208 - let slice = &rest[..end + 2]; 209 209 - if let Ok(parsed) = serde_json::from_str::<String>(slice) { 210 210 - return Some(parsed); 211 211 - } 212 212 - let content = &rest[1..end + 1]; 213 213 - return Some(unescape_json_string_lossy(content)); 214 214 - } 215 215 - None 216 216 - } 217 217 - 218 218 - fn unescape_json_string_lossy(s: &str) -> String { 219 219 - let mut out = String::with_capacity(s.len()); 220 220 - let mut chars = s.chars(); 221 221 - while let Some(c) = chars.next() { 222 222 - if c != '\\' { 223 223 - out.push(c); 224 224 - continue; 225 225 - } 226 226 - match chars.next() { 227 227 - Some('"') => out.push('"'), 228 228 - Some('\\') => out.push('\\'), 229 229 - Some('/') => out.push('/'), 230 230 - Some('b') => out.push('\u{0008}'), 231 231 - Some('f') => out.push('\u{000C}'), 232 232 - Some('n') => out.push('\n'), 233 233 - Some('r') => out.push('\r'), 234 234 - Some('t') => out.push('\t'), 235 235 - Some('u') => { 236 236 - let mut hex = String::new(); 237 237 - for _ in 0..4 { 238 238 - if let Some(h) = chars.next() { 239 239 - hex.push(h); 240 240 - } else { 241 241 - break; 242 242 - } 243 243 - } 244 244 - if let Ok(code) = u16::from_str_radix(&hex, 16) 245 245 - && let Some(ch) = char::from_u32(code as u32) 246 246 - { 247 247 - out.push(ch); 248 248 - } 249 249 - } 250 250 - Some(other) => out.push(other), 251 251 - None => break, 252 252 - } 253 253 - } 254 254 - out 255 255 - } 256 256 - 257 257 - fn legacy_or_plain(s: &str) -> Component { 258 258 - if s.contains(SECTION_SIGN) { 259 259 - parse_legacy_section_text(s) 260 260 - } else { 261 261 - Component::String(s.to_string()) 262 262 - } 263 263 - } 264 264 - 265 265 - fn expand_legacy(component: Component) -> Component { 266 266 - match component { 267 267 - Component::String(s) => legacy_or_plain(&s), 268 268 - Component::Array(items) => { 269 269 - Component::Array(items.into_iter().map(expand_legacy).collect()) 270 270 - } 271 271 - Component::Object(mut obj) => { 272 272 - if obj.translate.is_none() 273 273 - && obj.with_.is_empty() 274 274 - && let Some(text) = obj.text.clone() 275 275 - && text.contains('§') 276 276 - { 277 277 - let expanded = parse_legacy_section_text_with_color( 278 278 - &text, 279 279 - obj.color.clone(), 280 280 - ); 281 281 - return merge_expanded_with_extra(expanded, obj.extra); 282 282 - } 283 283 - obj.extra = obj.extra.into_iter().map(expand_legacy).collect(); 284 284 - obj.with_ = obj.with_.into_iter().map(expand_legacy).collect(); 285 285 - Component::Object(obj) 286 286 - } 287 287 - } 288 288 - } 289 289 - 290 290 - fn merge_expanded_with_extra( 291 291 - expanded: Component, 292 292 - extra: Vec<Component>, 293 293 - ) -> Component { 294 294 - if extra.is_empty() { 295 295 - return expanded; 296 296 - } 297 297 - match expanded { 298 298 - Component::Array(mut items) => { 299 299 - items.extend(extra.into_iter().map(expand_legacy)); 300 300 - Component::Array(items) 301 301 - } 302 302 - other => Component::Array( 303 303 - std::iter::once(other) 304 304 - .chain(extra.into_iter().map(expand_legacy)) 305 305 - .collect(), 306 306 - ), 307 307 - } 308 308 - } 309 309 - 310 310 - fn parse_legacy_section_text(s: &str) -> Component { 311 311 - parse_legacy_section_text_with_color(s, None) 312 312 - } 313 313 - 314 314 - fn parse_legacy_section_text_with_color( 315 315 - s: &str, 316 316 - initial_color: Option<String>, 317 317 - ) -> Component { 318 318 - let mut out: Vec<Component> = Vec::new(); 319 319 - let mut buf = String::new(); 320 320 - let mut color: Option<String> = initial_color; 321 321 - 322 322 - let mut chars = s.chars(); 323 323 - while let Some(c) = chars.next() { 324 324 - if c == SECTION_SIGN 325 325 - && let Some(code) = chars.next() 326 326 - { 327 327 - if !buf.is_empty() { 328 328 - out.push(Component::Object(ComponentObject { 329 329 - text: Some(std::mem::take(&mut buf)), 330 330 - color: color.clone(), 331 331 - extra: Vec::new(), 332 332 - translate: None, 333 333 - with_: Vec::new(), 334 334 - })); 335 335 - } 336 336 - 337 337 - match legacy_color_name(code) { 338 338 - Some(name) => color = Some(name), 339 339 - None => { 340 340 - if code == LEGACY_RESET_LOWER || code == LEGACY_RESET_UPPER 341 341 - { 342 342 - color = None; 343 343 - } 344 344 - } 345 345 - } 346 346 - continue; 347 347 - } 348 348 - buf.push(c); 349 349 - } 350 350 - 351 351 - if !buf.is_empty() { 352 352 - out.push(Component::Object(ComponentObject { 353 353 - text: Some(buf), 354 354 - color, 355 355 - extra: Vec::new(), 356 356 - translate: None, 357 357 - with_: Vec::new(), 358 358 - })); 359 359 - } 360 360 - 361 361 - if out.is_empty() { 362 362 - Component::String(String::new()) 363 363 - } else if out.len() == 1 { 364 364 - out.pop() 365 365 - .unwrap_or_else(|| Component::String(String::new())) 366 366 - } else { 367 367 - Component::Array(out) 368 368 - } 369 369 - } 370 370 - 371 371 - fn legacy_color_name(code: char) -> Option<String> { 372 372 - let name = match code { 373 373 - '0' => "black", 374 374 - '1' => "dark_blue", 375 375 - '2' => "dark_green", 376 376 - '3' => "dark_aqua", 377 377 - '4' => "dark_red", 378 378 - '5' => "dark_purple", 379 379 - '6' => "gold", 380 380 - '7' => "gray", 381 381 - '8' => "dark_gray", 382 382 - '9' => "blue", 383 383 - 'a' | 'A' => "green", 384 384 - 'b' | 'B' => "aqua", 385 385 - 'c' | 'C' => "red", 386 386 - 'd' | 'D' => "light_purple", 387 387 - 'e' | 'E' => "yellow", 388 388 - 'f' | 'F' => "white", 389 389 - _ => return None, 390 390 - }; 391 391 - Some(name.to_string()) 392 392 - } 393 393 - 394 394 - const SECTION_SIGN: char = '§'; 395 395 - const LEGACY_RESET_LOWER: char = 'r'; 396 396 - const LEGACY_RESET_UPPER: char = 'R'; 397 397 - 398 398 - fn push_text_with_color(out: &mut String, text: &str, color: Option<&str>) { 399 399 - let class_color = color 400 400 - .and_then(sanitize_color_class) 401 401 - .map(|c| format!("text-{}", c)); 402 402 - if let Some(class_color) = class_color { 403 403 - out.push_str("<span class=\""); 404 404 - out.push_str(&class_color); 405 405 - out.push_str("\">"); 406 406 - push_escaped_with_breaks(out, text); 407 407 - out.push_str("</span>"); 408 408 - } else { 409 409 - push_escaped_with_breaks(out, text); 410 410 - } 411 411 - } 412 412 - 413 413 - fn sanitize_color_class(color: &str) -> Option<&str> { 414 414 - if color.is_empty() { 415 415 - return None; 416 416 - } 417 417 - if color 418 418 - .chars() 419 419 - .all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '_') 420 420 - { 421 421 - Some(color) 422 422 - } else { 423 423 - None 424 424 - } 425 425 - } 426 426 - 427 427 - fn push_escaped_with_breaks(out: &mut String, text: &str) { 428 428 - let mut first = true; 429 429 - for part in text.split('\n') { 430 430 - if !first { 431 431 - out.push_str("<br>"); 432 432 - } 433 433 - first = false; 434 434 - out.push_str(encode_text(part).as_ref()); 435 435 - } 436 436 - } 437 437 - 438 438 - impl<'de> Deserialize<'de> for Component { 439 439 - fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> 440 440 - where 441 441 - D: Deserializer<'de>, 442 442 - { 443 443 - struct ComponentVisitor; 444 444 - 445 445 - impl<'de> Visitor<'de> for ComponentVisitor { 446 446 - type Value = Component; 447 447 - 448 448 - fn expecting( 449 449 - &self, 450 450 - f: &mut std::fmt::Formatter, 451 451 - ) -> std::fmt::Result { 452 452 - f.write_str("a Minecraft text component") 453 453 - } 454 454 - 455 455 - fn visit_str<E>(self, v: &str) -> Result<Self::Value, E> 456 456 - where 457 457 - E: serde::de::Error, 458 458 - { 459 459 - Ok(parse_component_from_str(v)) 460 460 - } 461 461 - 462 462 - fn visit_string<E>(self, v: String) -> Result<Self::Value, E> 463 463 - where 464 464 - E: serde::de::Error, 465 465 - { 466 466 - Ok(parse_component_from_str(&v)) 467 467 - } 468 468 - 469 469 - fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error> 470 470 - where 471 471 - A: SeqAccess<'de>, 472 472 - { 473 473 - let items = Vec::<Component>::deserialize( 474 474 - SeqAccessDeserializer::new(seq), 475 475 - )?; 476 476 - Ok(expand_legacy(Component::Array(items))) 477 477 - } 478 478 - 479 479 - fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error> 480 480 - where 481 481 - A: MapAccess<'de>, 482 482 - { 483 483 - let obj = ComponentObject::deserialize( 484 484 - MapAccessDeserializer::new(map), 485 485 - )?; 486 486 - Ok(expand_legacy(Component::Object(obj))) 487 487 - } 488 488 - } 489 489 - 490 490 - deserializer.deserialize_any(ComponentVisitor) 491 491 - } 492 492 - } 493 493 - 494 494 - #[cfg(test)] 495 495 - mod tests { 496 496 - use super::*; 497 497 - 498 498 - #[test] 499 499 - fn normalize_plain_text() { 500 500 - let c = parse_component_from_str("hello world"); 501 501 - assert_eq!(normalize_page(&c), "hello world"); 502 502 - } 503 503 - 504 504 - #[test] 505 505 - fn normalize_json_object() { 506 506 - let c = parse_component_from_str(r#"{"text":"hello §aworld"}"#); 507 507 - assert_eq!(normalize_page(&c), "hello world"); 508 508 - } 509 509 - 510 510 - #[test] 511 511 - fn normalize_json_array() { 512 512 - let c = 513 513 - parse_component_from_str(r#"[{"text":"hi "},{"text":"there"}]"#); 514 514 - assert_eq!(normalize_page(&c), "hi there"); 515 515 - } 516 516 - 517 517 - #[test] 518 518 - fn normalize_stringified_json() { 519 519 - let c = parse_component_from_str(r#""{\"text\":\"hello\"}""#); 520 520 - assert_eq!(normalize_page(&c), "hello"); 521 521 - } 522 522 - 523 523 - #[test] 524 524 - fn legacy_section_colors() { 525 525 - let c = parse_component_from_str("hi §aworld"); 526 526 - let text = c.to_plain_text(); 527 527 - assert_eq!(text, "hi world"); 528 528 - match c { 529 529 - Component::Array(items) => { 530 530 - assert_eq!(items.len(), 2); 531 531 - } 532 532 - _ => panic!("expected array component"), 533 533 - } 534 534 - } 535 535 - 536 536 - #[test] 537 537 - fn legacy_text_prefix() { 538 538 - let c = parse_component_from_str("text\t\"hello §aworld\""); 539 539 - assert_eq!(normalize_page(&c), "hello world"); 540 540 - } 541 541 - 542 542 - #[test] 543 543 - fn scrub_unwanted_glyph_from_component_tree() { 544 544 - let mut c = parse_component_from_str( 545 545 - r#"[{"text":"hi there"},{"text":" and more"}]"#, 546 546 - ); 547 547 - scrub_component(&mut c); 548 548 - assert_eq!(c.to_plain_text(), "hi there and more"); 549 549 - } 550 550 - }

+45 -244

src/library.rs

··· 1 1 - use std::time::{SystemTime, SystemTimeError}; 2 2 - 3 1 use ahash::{AHashMap, AHashSet}; 4 2 use lru::LruCache; 3 3 + use nara_core::{ 4 4 + book::{Book, BookHash, BookSource}, 5 5 + component::Component, 6 6 + }; 5 7 use smol_str::SmolStr; 6 8 use std::{cell::RefCell, num::NonZeroUsize}; 7 9 use strsim::jaro_winkler; 8 10 9 9 - use serde::{Deserialize, Serialize}; 10 10 - 11 11 - /// Item model types parsed from realm data. 12 12 - pub mod item; 13 13 - pub mod text; 14 14 - 15 15 - use item::{ItemStack, WrittenBookTag}; 16 16 - use text::{Component, normalize_page, scrub_component, scrub_unwanted_glyphs}; 17 17 - 18 18 - pub type BookHash = [u8; 20]; 19 11 pub type BookId = usize; 20 12 21 21 - /// Raw realm export data (top-level list of items). 22 22 - #[derive(Debug, Serialize, Deserialize)] 23 23 - pub struct Realm { 24 24 - pub realm: Vec<ItemStack>, 25 25 - pub realm_version: String, 26 26 - } 27 27 - 28 13 /// In-memory index of all books with lookup and fuzzy search helpers. 29 14 #[derive(Debug)] 30 15 pub struct Library { 31 31 - books: Vec<WrittenBookTag>, 16 16 + books: Vec<Book>, 32 17 33 18 by_hash: AHashMap<BookHash, BookId>, 34 34 - location_by_hash: AHashMap<BookHash, SmolStr>, 35 35 - by_category: AHashMap<SmolStr, Vec<BookId>>, 19 19 + source_by_hash: AHashMap<BookHash, BookSource>, 36 20 by_author_lc: AHashMap<SmolStr, Vec<BookId>>, 37 21 38 22 // normalized blobs for scoring (same index as `books`) ··· 50 34 title_threshold: f64, 51 35 52 36 cache_books_by_author: RefCell<LruCache<SmolStr, Vec<BookId>>>, 53 53 - cache_books_in_category: RefCell<LruCache<SmolStr, Vec<BookId>>>, 54 37 cache_fuzzy_title: RefCell<LruCache<FuzzyKey, Vec<(BookId, f64)>>>, 55 38 cache_fuzzy_author: RefCell<LruCache<FuzzyKey, Vec<(BookId, f64)>>>, 56 39 cache_fuzzy_contents: RefCell<LruCache<FuzzyKey, Vec<(BookId, f64)>>>, 57 40 cache_fuzzy_all: RefCell<LruCache<FuzzyKey, Vec<(BookId, f64)>>>, 58 41 59 59 - duplicate_books_filtered: u16, 60 42 empty_books_filtered: u16, 61 43 } 62 44 ··· 67 49 limit: usize, 68 50 } 69 51 70 70 - #[derive(Debug, thiserror::Error)] 71 71 - pub enum LibraryError { 72 72 - #[error("Book has no location: {0:?}")] 73 73 - MissingLocation(WrittenBookTag), 74 74 - #[error("Unsupported realm version '{0}'")] 75 75 - UnsupportedRealmVersion(String), 76 76 - #[error(transparent)] 77 77 - SystemTimeError(#[from] SystemTimeError), 78 78 - } 79 79 - 80 80 - pub type Result<T> = std::result::Result<T, LibraryError>; 81 81 - 82 52 impl Library { 83 83 - /// Builds a library index from a realm export. 84 53 pub fn new( 85 85 - realm: Realm, 86 54 content_threshold: f64, 87 87 - author_threshold: f64, 88 55 title_threshold: f64, 89 89 - warn_duplicates: bool, 90 90 - warn_empty: bool, 91 91 - filter_empty_books: bool, 92 92 - ) -> Result<Library> { 93 93 - if realm.realm_version != "0.2" { 94 94 - return Err(LibraryError::UnsupportedRealmVersion( 95 95 - realm.realm_version, 96 96 - )); 97 97 - } 98 98 - 99 99 - let start = SystemTime::now(); 100 100 - let mut library = Library { 56 56 + author_threshold: f64, 57 57 + ) -> Self { 58 58 + Self { 101 59 books: Vec::new(), 102 60 by_hash: AHashMap::new(), 103 103 - location_by_hash: AHashMap::new(), 104 104 - by_category: AHashMap::new(), 61 61 + source_by_hash: AHashMap::new(), 105 62 by_author_lc: AHashMap::new(), 106 63 norm_title: Vec::new(), 107 64 norm_author: Vec::new(), ··· 110 67 tri_author: AHashMap::new(), 111 68 tri_contents: AHashMap::new(), 112 69 content_threshold, 113 113 - author_threshold, 114 70 title_threshold, 71 71 + author_threshold, 115 72 cache_books_by_author: RefCell::new(new_lru(CACHE_BY_AUTHOR_CAP)), 116 116 - cache_books_in_category: RefCell::new(new_lru( 117 117 - CACHE_BY_CATEGORY_CAP, 118 118 - )), 119 73 cache_fuzzy_title: RefCell::new(new_lru(CACHE_FUZZY_CAP)), 120 74 cache_fuzzy_author: RefCell::new(new_lru(CACHE_FUZZY_CAP)), 121 75 cache_fuzzy_contents: RefCell::new(new_lru(CACHE_FUZZY_CAP)), 122 76 cache_fuzzy_all: RefCell::new(new_lru(CACHE_FUZZY_CAP)), 123 123 - duplicate_books_filtered: 0, 124 77 empty_books_filtered: 0, 125 125 - }; 126 126 - 127 127 - fn traverse_items( 128 128 - items: Vec<ItemStack>, 129 129 - current_location: Option<SmolStr>, 130 130 - library: &mut Library, 131 131 - warn_duplicates: bool, 132 132 - warn_empty: bool, 133 133 - filter_empty_books: bool, 134 134 - ) -> Result<()> { 135 135 - for item in items { 136 136 - match item { 137 137 - ItemStack::WrittenBook { tag, .. } => { 138 138 - library.add_book( 139 139 - tag, 140 140 - current_location.clone(), 141 141 - warn_duplicates, 142 142 - warn_empty, 143 143 - filter_empty_books, 144 144 - )?; 145 145 - } 146 146 - ItemStack::ShulkerBox { tag, .. } => { 147 147 - let shulker_location = tag 148 148 - .display 149 149 - .as_ref() 150 150 - .and_then(|d| d.name.as_deref()) 151 151 - .map(SmolStr::new); 152 152 - 153 153 - let next_location = shulker_location 154 154 - .or_else(|| current_location.clone()); 155 155 - traverse_items( 156 156 - tag.block_entity.items, 157 157 - next_location, 158 158 - library, 159 159 - warn_duplicates, 160 160 - warn_empty, 161 161 - filter_empty_books, 162 162 - )?; 163 163 - } 164 164 - } 165 165 - } 166 166 - Ok(()) 167 78 } 168 168 - 169 169 - traverse_items( 170 170 - realm.realm, 171 171 - None, 172 172 - &mut library, 173 173 - warn_duplicates, 174 174 - warn_empty, 175 175 - filter_empty_books, 176 176 - )?; 177 177 - 178 178 - let elapsed_ms = SystemTime::now().duration_since(start)?.as_nanos() 179 179 - as f64 180 180 - / 1_000_000.0; 181 181 - tracing::info!( 182 182 - "Indexed {0} books in {1} categories in {2}ms (filtered {3} duplicates, {4} empty)", 183 183 - library.books.len(), 184 184 - library.by_category.keys().len(), 185 185 - elapsed_ms, 186 186 - library.duplicate_books_filtered, 187 187 - library.empty_books_filtered, 188 188 - ); 189 189 - Ok(library) 190 79 } 191 80 192 192 - /// Inserts a book and updates all indices and caches. 193 193 - fn add_book( 81 81 + /// Inserts a book 82 82 + pub fn add_book( 194 83 &mut self, 195 195 - mut book: WrittenBookTag, 196 196 - location: Option<SmolStr>, 197 197 - warn_duplicates: bool, 84 84 + book: Book, 198 85 warn_empty: bool, 199 86 filter_empty_books: bool, 200 200 - ) -> Result<()> { 201 201 - book.title = scrub_unwanted_glyphs(&book.title); 202 202 - book.author = scrub_unwanted_glyphs(&book.author); 203 203 - for page in &mut book.pages { 204 204 - scrub_component(page); 205 205 - } 87 87 + ) { 206 88 if filter_empty_books && book_plain_text_empty(&book) { 207 89 if warn_empty { 208 90 tracing::warn!( 209 209 - "Skipping empty book in location {0:?}: {1} by {2}", 210 210 - location, 211 211 - book.title, 212 212 - book.author 91 91 + "Skipping empty book with source {0:?}: {1} by {2}", 92 92 + book.metadata.source, 93 93 + book.content.title, 94 94 + book.content.author 213 95 ); 214 96 } 215 97 self.empty_books_filtered += 1; 216 216 - return Ok(()); 217 217 - } 218 218 - 219 219 - let Some(location) = location else { 220 220 - return Err(LibraryError::MissingLocation(book)); 221 221 - }; 222 222 - 223 223 - let Some(category) = category_from_location(&location) else { 224 224 - return Err(LibraryError::MissingLocation(book)); 98 98 + return; 225 99 }; 226 100 227 101 let h = book.hash(); 228 102 if self.by_hash.contains_key(&h) { 229 229 - if warn_duplicates { 230 230 - let existing_book_location = 231 231 - self.location_by_hash.get(&h).expect("book to exist"); 232 232 - tracing::warn!( 233 233 - "Duplicate book in location {0:?}: {1} by {2} [already in {3}]", 234 234 - location, 235 235 - book.title, 236 236 - book.author, 237 237 - existing_book_location 238 238 - ); 239 239 - } 240 240 - self.duplicate_books_filtered += 1; 241 241 - return Ok(()); 103 103 + return; 242 104 } 243 105 244 106 let id = self.books.len(); 107 107 + 108 108 + let source = book.metadata.source.clone(); 245 109 self.books.push(book); 246 110 247 111 // indices... 248 112 self.by_hash.insert(h, id); 249 249 - self.by_category 250 250 - .entry(category.clone()) 251 251 - .or_default() 252 252 - .push(id); 253 253 - self.location_by_hash.insert(h, location); 113 113 + self.source_by_hash.insert(h, source); 254 114 255 255 - let author_lc = SmolStr::new(normalize(&self.books[id].author)); 115 115 + let author_lc = SmolStr::new(normalize(&self.books[id].content.author)); 256 116 if !author_lc.is_empty() { 257 117 self.by_author_lc.entry(author_lc).or_default().push(id); 258 118 } 259 119 260 120 // normalized blobs (for scoring) 261 261 - self.norm_title.push(normalize(&self.books[id].title)); 262 262 - self.norm_author.push(normalize(&self.books[id].author)); 121 121 + self.norm_title 122 122 + .push(normalize(&self.books[id].content.title)); 123 123 + self.norm_author 124 124 + .push(normalize(&self.books[id].content.author)); 263 125 self.norm_contents 264 264 - .push(normalize_contents(&self.books[id].pages)); 126 126 + .push(normalize_contents(&self.books[id].content.pages)); 265 127 266 128 // candidate-generation indices 267 129 index_trigrams(&mut self.tri_title, id, &self.norm_title[id]); ··· 269 131 index_trigrams(&mut self.tri_contents, id, &self.norm_contents[id]); 270 132 271 133 self.cache_books_by_author.borrow_mut().clear(); 272 272 - self.cache_books_in_category.borrow_mut().clear(); 273 134 self.cache_fuzzy_title.borrow_mut().clear(); 274 135 self.cache_fuzzy_author.borrow_mut().clear(); 275 136 self.cache_fuzzy_contents.borrow_mut().clear(); 276 137 self.cache_fuzzy_all.borrow_mut().clear(); 277 277 - 278 278 - Ok(()) 279 138 } 280 139 281 140 /// Looks up a book by its content hash. 282 141 #[inline] 283 283 - pub fn book_by_hash(&self, hash: BookHash) -> Option<&WrittenBookTag> { 142 142 + pub fn book_by_hash(&self, hash: BookHash) -> Option<&Book> { 284 143 self.by_hash.get(&hash).map(|&id| &self.books[id]) 285 144 } 286 145 ··· 289 148 pub fn books_by_author<'a>( 290 149 &'a self, 291 150 author: &str, 292 292 - ) -> impl Iterator<Item = &'a WrittenBookTag> + 'a { 151 151 + ) -> impl Iterator<Item = &'a Book> + 'a { 293 152 let key = SmolStr::new(normalize(author)); 294 153 let ids = if key.is_empty() { 295 154 Vec::new() ··· 308 167 ids.into_iter().map(|id| &self.books[id]) 309 168 } 310 169 311 311 - /// Lists books by category derived from location strings. 312 312 - #[inline] 313 313 - pub fn books_in_category<'a>( 314 314 - &'a self, 315 315 - category: &str, 316 316 - ) -> impl Iterator<Item = &'a WrittenBookTag> + 'a { 317 317 - let key = SmolStr::new(category); 318 318 - let ids = if key.is_empty() { 319 319 - Vec::new() 320 320 - } else if let Some(ids) = 321 321 - self.cache_books_in_category.borrow_mut().get(&key).cloned() 322 322 - { 323 323 - ids 324 324 - } else { 325 325 - let ids = self.by_category.get(&key).cloned().unwrap_or_default(); 326 326 - self.cache_books_in_category 327 327 - .borrow_mut() 328 328 - .put(key.clone(), ids.clone()); 329 329 - ids 330 330 - }; 331 331 - 332 332 - ids.into_iter().map(|id| &self.books[id]) 333 333 - } 334 334 - 335 170 /// Fuzzy search over normalized titles. 336 336 - pub fn fuzzy_title( 337 337 - &self, 338 338 - query: &str, 339 339 - limit: usize, 340 340 - ) -> Vec<(&WrittenBookTag, f64)> { 171 171 + pub fn fuzzy_title(&self, query: &str, limit: usize) -> Vec<(&Book, f64)> { 341 172 let key = SmolStr::new(normalize(query)); 342 173 if key.is_empty() || limit == 0 { 343 174 return Vec::new(); ··· 373 204 } 374 205 375 206 /// Fuzzy search over normalized author names. 376 376 - pub fn fuzzy_author( 377 377 - &self, 378 378 - query: &str, 379 379 - limit: usize, 380 380 - ) -> Vec<(&WrittenBookTag, f64)> { 207 207 + pub fn fuzzy_author(&self, query: &str, limit: usize) -> Vec<(&Book, f64)> { 381 208 let key = SmolStr::new(normalize(query)); 382 209 if key.is_empty() || limit == 0 { 383 210 return Vec::new(); ··· 420 247 &self, 421 248 query: &str, 422 249 limit: usize, 423 423 - ) -> Vec<(&WrittenBookTag, f64)> { 250 250 + ) -> Vec<(&Book, f64)> { 424 251 let key = SmolStr::new(normalize(query)); 425 252 if key.is_empty() || limit == 0 { 426 253 return Vec::new(); ··· 459 286 } 460 287 461 288 /// Combined fuzzy search (title + author + contents). 462 462 - pub fn fuzzy( 463 463 - &self, 464 464 - query: &str, 465 465 - limit: usize, 466 466 - ) -> Vec<(&WrittenBookTag, f64)> { 289 289 + pub fn fuzzy(&self, query: &str, limit: usize) -> Vec<(&Book, f64)> { 467 290 let key = SmolStr::new(normalize(query)); 468 291 if key.is_empty() || limit == 0 { 469 292 return Vec::new(); ··· 540 363 541 364 /// Returns a list of all books in the library. 542 365 #[inline] 543 543 - pub fn all_books<'a>( 544 544 - &'a self, 545 545 - ) -> impl Iterator<Item = &'a WrittenBookTag> + 'a { 366 366 + pub fn all_books<'a>(&'a self) -> impl Iterator<Item = &'a Book> + 'a { 546 367 self.books.iter() 547 368 } 548 369 549 549 - /// Returns all categories with their book counts. 370 370 + /// Returns the source for a book hash, if present. 550 371 #[inline] 551 551 - pub fn categories(&self) -> Vec<(SmolStr, usize)> { 552 552 - self.by_category 553 553 - .iter() 554 554 - .map(|(k, v)| (k.clone(), v.len())) 555 555 - .collect() 556 556 - } 557 557 - 558 558 - /// Returns the location string for a book hash, if present. 559 559 - #[inline] 560 560 - pub fn location_for_hash(&self, hash: &BookHash) -> Option<&SmolStr> { 561 561 - self.location_by_hash.get(hash) 372 372 + pub fn source_for_hash(&self, hash: &BookHash) -> Option<&BookSource> { 373 373 + self.source_by_hash.get(hash) 562 374 } 563 375 } 564 376 ··· 568 380 s.to_lowercase() 569 381 } 570 382 571 571 - fn book_plain_text_empty(book: &WrittenBookTag) -> bool { 572 572 - book.pages.is_empty() 383 383 + fn book_plain_text_empty(book: &Book) -> bool { 384 384 + book.content.pages.is_empty() 573 385 || book 386 386 + .content 574 387 .pages 575 388 .iter() 576 576 - .all(|page| normalize_page(page).trim().is_empty()) 389 389 + .all(|page| page.normalize().trim().is_empty()) 577 390 } 578 391 579 392 const CACHE_BY_AUTHOR_CAP: usize = 1024; 580 580 - const CACHE_BY_CATEGORY_CAP: usize = 1024; 581 393 const CACHE_FUZZY_CAP: usize = 256; 582 394 583 395 /// Helper to build LRU caches with non-zero capacity. 584 396 fn new_lru<K: std::hash::Hash + Eq, V>(cap: usize) -> LruCache<K, V> { 585 397 LruCache::new(NonZeroUsize::new(cap).expect("cache cap must be > 0")) 586 586 - } 587 587 - 588 588 - /// Extracts category prefix from a location string. 589 589 - pub(crate) fn category_from_location(location: &str) -> Option<SmolStr> { 590 590 - let first_digit = location.find(|c: char| c.is_ascii_digit())?; 591 591 - let category = location[..first_digit].trim_end(); 592 592 - if category.is_empty() { 593 593 - None 594 594 - } else { 595 595 - Some(SmolStr::new(category)) 596 596 - } 597 398 } 598 399 599 400 const MAX_CONTENT_INDEX_CHARS: usize = 16_384; ··· 784 585 fn fuzzy_rank_contents( 785 586 query: &str, 786 587 norm_field: &[String], 787 787 - tri_index: &ahash::AHashMap<u32, Vec<BookId>>, 588 588 + tri_index: &AHashMap<u32, Vec<BookId>>, 788 589 limit: usize, 789 590 score_threshold: f64, 790 591 ) -> Vec<(BookId, f64)> {

+90 -31

src/main.rs

··· 1 1 - use std::{fs, io::Cursor}; 1 1 + use std::time::{Instant, SystemTime}; 2 2 3 3 use anyhow::Context; 4 4 use clap::Parser as _; 5 5 + use nara_core::BookContainer; 6 6 + use nara_slurper_1_12_infinity::Realm; 5 7 6 8 use crate::{ 7 7 - cli::Args, 8 8 - library::{Library, Realm}, 9 9 + cli::{Cli, Command, ServeArgs}, 10 10 + library::Library, 9 11 web::start_webserver, 10 12 }; 13 13 + use nara_slurper_1_12_world::slurp_world; 11 14 12 15 pub mod cli; 13 16 pub mod library; ··· 18 21 #[tokio::main] 19 22 async fn main() -> anyhow::Result<()> { 20 23 tracing_subscriber::fmt::init(); 21 21 - let cli_args = Args::parse(); 22 22 - let library = build_library(&cli_args).context("Building library")?; 24 24 + let cli = Cli::parse(); 25 25 + 26 26 + match cli.command { 27 27 + Command::Serve(args) => { 28 28 + let library = build_library(&args).context("Building library")?; 23 29 24 24 - if cli_args.start_webserver { 25 25 - start_webserver(&cli_args, library) 26 26 - .await 27 27 - .context("Running webserver")?; 30 30 + if args.start_webserver { 31 31 + start_webserver(&args, library) 32 32 + .await 33 33 + .context("Running webserver")?; 34 34 + } 35 35 + } 36 36 + Command::SlurpWorld(args) => match args.version { 37 37 + cli::MinecraftVersion::V1_12 => { 38 38 + let num_workers = args.workers.unwrap_or_else(|| { 39 39 + std::thread::available_parallelism() 40 40 + .map(|n| n.get()) 41 41 + .unwrap_or(4) 42 42 + }); 43 43 + let mut container = 44 44 + BookContainer::open_or_new(&args.container_path) 45 45 + .context("Opening container")?; 46 46 + let start = Instant::now(); 47 47 + let books = slurp_world(&args.world_path, num_workers) 48 48 + .await 49 49 + .context("Slurping world")?; 50 50 + let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0; 51 51 + let total = books.len(); 52 52 + let dupes = books 53 53 + .into_iter() 54 54 + .filter(|b| !container.add(b.clone())) 55 55 + .count(); 56 56 + container 57 57 + .save(&args.container_path) 58 58 + .context("Saving container")?; 59 59 + tracing::info!( 60 60 + "Found {total} books, of which {dupes} were duplicates in {elapsed_ms:.3} ms" 61 61 + ); 62 62 + } 63 63 + }, 64 64 + Command::SlurpRealm(args) => match args.version { 65 65 + cli::MinecraftVersion::V1_12 => { 66 66 + let mut container = 67 67 + BookContainer::open_or_new(&args.container_path) 68 68 + .context("Opening container")?; 69 69 + let start = Instant::now(); 70 70 + let books = Realm::read(args.realm_path)?.slurp(); 71 71 + let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0; 72 72 + let total = books.len(); 73 73 + let dupes = books 74 74 + .into_iter() 75 75 + .filter(|b| !container.add(b.clone())) 76 76 + .count(); 77 77 + container 78 78 + .save(&args.container_path) 79 79 + .context("Saving container")?; 80 80 + tracing::info!( 81 81 + "Found {total} books, of which {dupes} were duplicates in {elapsed_ms:.3} ms" 82 82 + ); 83 83 + } 84 84 + }, 28 85 } 29 86 30 87 Ok(()) 31 88 } 32 89 33 33 - fn build_library(args: &Args) -> anyhow::Result<Library> { 34 34 - let realm_path = &args.realm_path; 35 35 - 36 36 - if !fs::exists(realm_path) 37 37 - .context("Checking if supplied realm path exists")? 38 38 - { 39 39 - return Err(anyhow::anyhow!("File {:?} not found", realm_path)); 40 40 - } 41 41 - 42 42 - let bytes = fs::read(realm_path).context("Reading realm")?; 43 43 - let mut cursor: Cursor<&[u8]> = Cursor::new(&bytes); 44 44 - let realm = crab_nbt::serde::de::from_cursor::<Realm>(&mut cursor) 45 45 - .context("Reading realm NBT")?; 90 90 + fn build_library(args: &ServeArgs) -> anyhow::Result<Library> { 91 91 + let start = SystemTime::now(); 92 92 + tracing::info!("Opening book container..."); 93 93 + let container = BookContainer::open_or_new(&args.container_path) 94 94 + .context("Opening container")?; 95 95 + tracing::info!( 96 96 + "Container opened, took {} ms. Building library...", 97 97 + SystemTime::now().duration_since(start)?.as_nanos() / 1_000_000 98 98 + ); 46 99 47 47 - let library = Library::new( 48 48 - realm, 100 100 + let start = SystemTime::now(); 101 101 + let mut library = Library::new( 49 102 args.content_threshold, 50 50 - args.author_threshold, 51 103 args.title_threshold, 52 52 - args.warn_duplicates, 53 53 - args.warn_empty, 54 54 - args.filter_empty_books, 55 55 - ) 56 56 - .context("Constructing library")?; 57 57 - 104 104 + args.author_threshold, 105 105 + ); 106 106 + for book in container.books() { 107 107 + library.add_book( 108 108 + book.clone(), 109 109 + args.warn_empty, 110 110 + args.filter_empty_books, 111 111 + ); 112 112 + } 113 113 + tracing::info!( 114 114 + "Built library in {}ms", 115 115 + SystemTime::now().duration_since(start)?.as_nanos() / 1_000_000 116 116 + ); 58 117 Ok(library) 59 118 }

+7 -79

src/web/api.rs

··· 7 7 response::{IntoResponse, Response}, 8 8 routing::get, 9 9 }; 10 10 + use nara_core::book::Book; 10 11 use serde::{Deserialize, Serialize}; 11 12 12 12 - use crate::library::{self, Library, item::WrittenBookTag, text::Component}; 13 13 + use crate::library::Library; 13 14 14 15 #[derive(Clone)] 15 16 pub struct AppState { ··· 23 24 .route("/health", get(health)) 24 25 .route("/books", get(list_books)) 25 26 .route("/books/by-author", get(books_by_author)) 26 26 - .route("/books/by-category", get(books_by_category)) 27 27 .route("/books/by-hash/{hash}", get(book_by_hash)) 28 28 - .route("/categories", get(list_categories)) 29 28 .route("/search", get(search_all)) 30 29 .route("/search/title", get(search_title)) 31 30 .route("/search/author", get(search_author)) ··· 36 35 #[derive(serde::Serialize)] 37 36 struct RootResponse { 38 37 message: &'static str, 39 39 - endpoints: [&'static str; 10], 38 38 + endpoints: [&'static str; 8], 40 39 } 41 40 42 41 async fn root() -> axum::Json<RootResponse> { ··· 46 45 "/api/health", 47 46 "/api/books?limit=25&offset=0", 48 47 "/api/books/by-author?author=Name&limit=25&offset=0", 49 49 - "/api/books/by-category?category=Category&limit=25&offset=0", 50 48 "/api/books/by-hash/:hash", 51 51 - "/api/categories", 52 49 "/api/search?query=term&limit=25&offset=0", 53 50 "/api/search/title?query=term&limit=25&offset=0", 54 51 "/api/search/author?query=term&limit=25&offset=0", ··· 139 136 Ok(Json(items)) 140 137 } 141 138 142 142 - #[derive(Deserialize)] 143 143 - struct CategoryQuery { 144 144 - category: String, 145 145 - limit: Option<usize>, 146 146 - offset: Option<usize>, 147 147 - } 148 148 - 149 149 - async fn books_by_category( 150 150 - State(state): State<AppState>, 151 151 - Query(query): Query<CategoryQuery>, 152 152 - ) -> Result<Json<Vec<BookDetail>>, ApiError> { 153 153 - let library = state.library.lock().expect("library mutex poisoned"); 154 154 - let category = query.category.trim(); 155 155 - if category.is_empty() { 156 156 - return Err(ApiError::bad_request("category is required")); 157 157 - } 158 158 - 159 159 - let limit = clamp_limit(query.limit); 160 160 - let offset = query.offset.unwrap_or(0); 161 161 - 162 162 - let items = library 163 163 - .books_in_category(category) 164 164 - .skip(offset) 165 165 - .take(limit) 166 166 - .map(|book| book_to_detail(book, &library)) 167 167 - .collect(); 168 168 - 169 169 - Ok(Json(items)) 170 170 - } 171 171 - 172 139 async fn book_by_hash( 173 140 State(state): State<AppState>, 174 141 Path(hash): Path<String>, ··· 182 149 Ok(Json(book_to_detail(book, &library))) 183 150 } 184 151 185 185 - #[derive(Serialize)] 186 186 - struct CategorySummary { 187 187 - name: String, 188 188 - count: usize, 189 189 - } 190 190 - 191 191 - async fn list_categories( 192 192 - State(state): State<AppState>, 193 193 - ) -> Json<Vec<CategorySummary>> { 194 194 - let library = state.library.lock().expect("library mutex poisoned"); 195 195 - let mut categories: Vec<CategorySummary> = library 196 196 - .categories() 197 197 - .into_iter() 198 198 - .map(|(name, count)| CategorySummary { 199 199 - name: name.to_string(), 200 200 - count, 201 201 - }) 202 202 - .collect(); 203 203 - categories.sort_by(|a, b| a.name.cmp(&b.name)); 204 204 - Json(categories) 205 205 - } 206 206 - 207 152 #[derive(Deserialize)] 208 153 struct SearchQuery { 209 154 query: String, ··· 252 197 fn run_search( 253 198 library: &Library, 254 199 query: SearchQuery, 255 255 - search_fn: for<'a> fn( 256 256 - &'a Library, 257 257 - &str, 258 258 - usize, 259 259 - ) -> Vec<(&'a WrittenBookTag, f64)>, 200 200 + search_fn: for<'a> fn(&'a Library, &str, usize) -> Vec<(&'a Book, f64)>, 260 201 ) -> Result<Json<Vec<SearchResult>>, ApiError> { 261 202 let query_str = query.query.trim(); 262 203 if query_str.is_empty() { ··· 281 222 282 223 #[derive(Serialize)] 283 224 struct BookDetail { 284 284 - title: String, 285 285 - author: String, 286 286 - pages: Vec<Component>, 225 225 + book: Book, 287 226 hash: String, 288 288 - location: Option<String>, 289 289 - category: Option<String>, 290 227 } 291 228 292 292 - fn book_to_detail(book: &WrittenBookTag, library: &Library) -> BookDetail { 229 229 + fn book_to_detail(book: &Book, _library: &Library) -> BookDetail { 293 230 let hash = book.hash(); 294 231 let hash_hex = hex::encode(hash); 295 295 - let location = library.location_for_hash(&hash).map(|s| s.to_string()); 296 296 - let category = location 297 297 - .as_deref() 298 298 - .and_then(library::category_from_location) 299 299 - .map(|s| s.to_string()); 300 232 301 233 BookDetail { 302 302 - title: book.title.clone(), 303 303 - author: book.author.clone(), 304 304 - pages: book.pages.clone(), 234 234 + book: book.clone(), 305 235 hash: hash_hex, 306 306 - location, 307 307 - category, 308 236 } 309 237 } 310 238

+63 -84

src/web/assets/stylesheet.css

··· 1 1 @font-face { 2 2 font-family: "Minecraft"; 3 3 - src: url("/assets/font/regular.woff2?v=__NARA_ASSET_VERSION__") format("woff2"); 3 3 + src: url("/assets/font/regular.woff2?v=__NARA_ASSET_VERSION__") 4 4 + format("woff2"); 4 5 font-weight: 400; 5 6 font-style: normal; 6 7 font-display: swap; ··· 16 17 17 18 @font-face { 18 19 font-family: "Minecraft"; 19 19 - src: url("/assets/font/italic.woff2?v=__NARA_ASSET_VERSION__") format("woff2"); 20 20 + src: url("/assets/font/italic.woff2?v=__NARA_ASSET_VERSION__") 21 21 + format("woff2"); 20 22 font-weight: 400; 21 23 font-style: italic; 22 24 font-display: swap; ··· 24 26 25 27 @font-face { 26 28 font-family: "Minecraft"; 27 27 - src: url("/assets/font/bold_italic.woff2?v=__NARA_ASSET_VERSION__") format("woff2"); 29 29 + src: url("/assets/font/bold_italic.woff2?v=__NARA_ASSET_VERSION__") 30 30 + format("woff2"); 28 31 font-weight: 700; 29 32 font-style: italic; 30 33 font-display: swap; 31 34 } 32 35 33 36 .font-minecraft { 34 34 - font-family: "Minecraft", system-ui, -apple-system, "Segoe UI", sans-serif; 37 37 + font-family: 38 38 + "Minecraft", 39 39 + system-ui, 40 40 + -apple-system, 41 41 + "Segoe UI", 42 42 + sans-serif; 35 43 font-synthesis: none; 36 44 } 37 45 ··· 44 52 } 45 53 46 54 .text-dark_blue { 47 47 - color: #0000AA; 55 55 + color: #0000aa; 48 56 } 49 57 50 58 .text-dark_green { 51 51 - color: #00AA00; 59 59 + color: #00aa00; 52 60 } 53 61 54 62 .text-dark_aqua { 55 55 - color: #00AAAA; 63 63 + color: #00aaaa; 56 64 } 57 65 58 66 .text-dark_red { 59 59 - color: #AA0000; 67 67 + color: #aa0000; 60 68 } 61 69 62 70 .text-dark_purple { 63 63 - color: #AA00AA; 71 71 + color: #aa00aa; 64 72 } 65 73 66 74 .text-gold { 67 67 - color: #FFAA00; 75 75 + color: #ffaa00; 68 76 } 69 77 70 78 .text-gray { 71 71 - color: #AAAAAA; 79 79 + color: #aaaaaa; 72 80 } 73 81 74 82 .text-dark_gray { ··· 76 84 } 77 85 78 86 .text-blue { 79 79 - color: #5555FF; 87 87 + color: #5555ff; 80 88 } 81 89 82 90 .text-green { 83 83 - color: #55FF55; 91 91 + color: #55ff55; 84 92 } 85 93 86 94 .text-aqua { 87 87 - color: #55FFFF; 95 95 + color: #55ffff; 88 96 } 89 97 90 98 .text-red { 91 91 - color: #FF5555; 99 99 + color: #ff5555; 92 100 } 93 101 94 102 .text-light_purple { 95 95 - color: #FF55FF; 103 103 + color: #ff55ff; 96 104 } 97 105 98 106 .text-yellow { 99 99 - color: #FFFF55; 107 107 + color: #ffff55; 100 108 } 101 109 102 110 .text-white { 103 103 - color: #FFFFFF; 111 111 + color: #ffffff; 104 112 } 105 113 106 114 :root { ··· 118 126 119 127 --accent: #4f9a3a; 120 128 --accent-strong: #336f26; 121 121 - --category-active-border: #275117; 122 122 - --category-active-surface: #78b65a; 123 123 - --category-active-ink: #0f2a09; 124 129 125 130 --border: #3b3b3b; 126 131 --button-border: #1f1f1f; ··· 168 173 margin: 0; 169 174 font-family: inherit; 170 175 color: var(--ink); 171 171 - background: 172 172 - linear-gradient(45deg, #7f7f7f 25%, #777777 25%, #777777 50%, #7f7f7f 50%, #7f7f7f 75%, #777777 75%, #777777 100%); 176 176 + background: linear-gradient( 177 177 + 45deg, 178 178 + #7f7f7f 25%, 179 179 + #777777 25%, 180 180 + #777777 50%, 181 181 + #7f7f7f 50%, 182 182 + #7f7f7f 75%, 183 183 + #777777 75%, 184 184 + #777777 100% 185 185 + ); 173 186 background-size: 1rem 1rem; 174 187 } 175 188 ··· 206 219 background: var(--tile-surface); 207 220 } 208 221 209 209 - :is(.book-badge, .book-icon, .category-link, .tag, .chip, .detail-link, button, .button, .link-reset, input[type="search"], select) { 222 222 + :is( 223 223 + .book-badge, 224 224 + .book-icon, 225 225 + .category-link, 226 226 + .tag, 227 227 + .chip, 228 228 + .detail-link, 229 229 + button, 230 230 + .button, 231 231 + .link-reset, 232 232 + input[type="search"], 233 233 + select 234 234 + ) { 210 235 border-radius: var(--radius-control); 211 236 } 212 237 ··· 338 363 339 364 .layout { 340 365 margin-top: 1.5rem; 341 341 - display: grid; 342 342 - grid-template-columns: 16.25rem 1fr; 343 343 - gap: 1.5rem; 344 344 - } 345 345 - 346 346 - .sidebar .panel { 347 347 - margin-bottom: 1.5rem; 348 348 - padding: 1.125rem; 349 349 - } 350 350 - 351 351 - .sidebar h2 { 352 352 - margin: 0 0 0.75rem; 353 353 - font-size: 1.125rem; 354 354 - } 355 355 - 356 356 - .all-link { 357 357 - display: inline-block; 358 358 - margin-bottom: 0.75rem; 359 359 - font-size: 0.8125rem; 360 360 - } 361 361 - 362 362 - .category-list { 363 363 - margin: 0; 364 364 - padding: 0; 365 365 - list-style: none; 366 366 - display: grid; 367 367 - gap: 0.5rem; 368 368 - } 369 369 - 370 370 - .category-link { 371 371 - display: flex; 372 372 - justify-content: space-between; 373 373 - padding: 0.5rem 0.625rem; 374 374 - border: var(--border-thick); 375 375 - color: var(--ink); 376 376 - background: #c3c3c3; 377 377 - } 378 378 - 379 379 - .category-link.active { 380 380 - border-color: var(--category-active-border); 381 381 - background: var(--category-active-surface); 382 382 - color: var(--category-active-ink); 383 383 - } 384 384 - 385 385 - .category-link .count { 386 386 - font-size: 0.75rem; 387 387 - color: var(--ink-muted); 388 366 } 389 367 390 368 .results-header { ··· 412 390 .book-tile { 413 391 text-align: center; 414 392 padding: 0.75rem 0.625rem; 415 415 - transition: border 0.15s ease, background 0.15s ease; 393 393 + transition: 394 394 + border 0.15s ease, 395 395 + background 0.15s ease; 416 396 } 417 397 418 398 .book-tile:hover { ··· 434 414 align-items: center; 435 415 justify-content: center; 436 416 box-shadow: var(--bevel-control); 437 437 - transition: transform 0.15s ease, box-shadow 0.15s ease; 417 417 + transition: 418 418 + transform 0.15s ease, 419 419 + box-shadow 0.15s ease; 438 420 } 439 421 440 422 .book-icon:hover { ··· 521 503 522 504 .pager { 523 505 margin-top: 1.125rem; 506 506 + margin-bottom: 1.125rem; 524 507 display: flex; 525 508 gap: 0.75rem; 526 509 } ··· 567 550 margin-top: 1.5rem; 568 551 margin-bottom: 1.5rem; 569 552 width: 100%; 570 570 - max-width: calc((var(--book-sprite-width) * 3) + (var(--book-grid-gap) * 2)); 553 553 + max-width: calc( 554 554 + (var(--book-sprite-width) * 3) + (var(--book-grid-gap) * 2) 555 555 + ); 571 556 margin-inline: auto; 572 557 } 573 558 ··· 659 644 mask-image: var(--mask, var(--book-mask)); 660 645 mask-repeat: no-repeat; 661 646 mask-size: 100% 100%; 662 662 - animation: glintMove 10s linear infinite, glintHue 10s linear infinite; 647 647 + animation: 648 648 + glintMove 10s linear infinite, 649 649 + glintHue 10s linear infinite; 663 650 } 664 651 665 652 @keyframes glintMove { ··· 683 670 } 684 671 685 672 @media (max-width: 61.25rem) { 686 686 - .layout { 687 687 - grid-template-columns: 1fr; 688 688 - } 689 689 - 690 690 - .sidebar .panel { 691 691 - position: static; 692 692 - } 693 693 - 694 673 .search { 695 674 grid-template-columns: 1fr; 696 675 } ··· 706 685 flex-direction: column; 707 686 align-items: flex-start; 708 687 } 709 709 - } 688 688 + }

+3 -2

src/web/assets.rs

··· 19 19 include_bytes!("assets/font/bold_italic.woff2"); 20 20 21 21 const CSS_STYLES_TEMPLATE: &str = include_str!("assets/stylesheet.css"); 22 22 - static CSS_STYLES: LazyLock<String> = 23 23 - LazyLock::new(|| CSS_STYLES_TEMPLATE.replace("__NARA_ASSET_VERSION__", crate::VERSION)); 22 22 + static CSS_STYLES: LazyLock<String> = LazyLock::new(|| { 23 23 + CSS_STYLES_TEMPLATE.replace("__NARA_ASSET_VERSION__", crate::VERSION) 24 24 + }); 24 25 25 26 const WEBP_MIME_TYPE: &str = "image/webp"; 26 27 const WOFF2_MIME_TYPE: &str = "font/woff2";

+34 -196

src/web/pages.rs

··· 11 11 extract::{Path, Query}, 12 12 response::Redirect, 13 13 }; 14 14 + use nara_core::book::{Book, BookSource}; 14 15 use serde::Deserialize; 15 16 use smol_str::SmolStr; 16 17 17 17 - use crate::{ 18 18 - library::{Library, category_from_location, item::WrittenBookTag}, 19 19 - web::TextureKind, 20 20 - }; 18 18 + use crate::{library::Library, web::TextureKind}; 21 19 22 20 #[derive(Debug, Template, WebTemplate)] 23 21 #[template(path = "index.html", whitespace = "minimize")] ··· 38 36 pub next_offset: usize, 39 37 pub pager_query: String, 40 38 pub books: Vec<BookCard>, 41 41 - pub categories: Vec<CategoryView>, 42 39 pub authors: Vec<AuthorView>, 43 40 pub git_hash: String, 44 41 } ··· 58 55 pub struct IndexQuery { 59 56 q: Option<String>, 60 57 scope: Option<String>, 61 61 - category: Option<String>, 62 58 author: Option<String>, 63 59 limit: Option<usize>, 64 60 offset: Option<usize>, ··· 73 69 pub struct QueryView { 74 70 pub q: String, 75 71 pub scope: String, 76 76 - pub category: String, 77 72 pub author: String, 78 78 - pub has_category: bool, 79 73 pub has_author: bool, 80 74 pub active: bool, 81 75 } 82 76 83 77 #[derive(Debug)] 84 84 - pub struct CategoryView { 85 85 - pub name: String, 86 86 - pub count: usize, 87 87 - pub href: String, 88 88 - pub active: bool, 89 89 - } 90 90 - 91 91 - #[derive(Debug)] 92 78 pub struct AuthorView { 93 79 pub name: String, 94 80 pub count: usize, ··· 108 94 pub title: String, 109 95 pub author: String, 110 96 pub author_href: String, 111 111 - pub location: String, 112 112 - pub has_location: bool, 113 113 - pub category: String, 114 114 - pub category_href: String, 115 115 - pub has_category: bool, 97 97 + pub source: BookSource, 116 98 pub pages: Vec<PageView>, 117 99 pub page_count: usize, 118 100 } ··· 134 116 135 117 impl HtmlSafe for HtmlText {} 136 118 137 137 - const DEFAULT_LIMIT: usize = 25; 138 138 - const MAX_LIMIT: usize = 50; 119 119 + const DEFAULT_LIMIT: usize = 100; 120 120 + const MAX_LIMIT: usize = 200; 139 121 const SEARCH_MAX_RESULTS: usize = 200; 140 122 141 123 #[derive(Debug)] 142 124 struct FilterParams { 143 125 query: String, 144 126 scope: &'static str, 145 145 - category: Option<String>, 146 127 author: Option<String>, 147 128 limit: usize, 148 129 offset: usize, 149 130 author_norm: Option<String>, 150 150 - category_norm: Option<String>, 151 131 } 152 132 153 133 pub async fn index( ··· 166 146 String, 167 147 usize, 168 148 String, 169 169 - ) = if !params.query.is_empty() 170 170 - || params.author.is_some() 171 171 - || params.category.is_some() 172 172 - { 149 149 + ) = if !params.query.is_empty() || params.author.is_some() { 173 150 let filtered = collect_candidates(&library, &params); 174 151 let total = filtered.len(); 175 152 let offset_used = params.offset.min(total); ··· 185 162 format!("Top {0} matches", total) 186 163 }; 187 164 let view_label = if params.query.is_empty() { 188 188 - filtered_view_label( 189 189 - params.author.as_deref(), 190 190 - params.category.as_deref(), 191 191 - ) 165 165 + filtered_view_label(params.author.as_deref()) 192 166 } else { 193 167 format!("Search results for \"{0}\"", params.query) 194 168 }; ··· 211 185 ) 212 186 }; 213 187 214 214 - let categories = build_categories(&library, params.category.as_deref()); 215 188 let authors = build_authors(&library); 216 189 let pager_query = build_pager_query( 217 190 &params.query, 218 191 params.scope, 219 219 - params.category.as_deref(), 220 192 params.author.as_deref(), 221 193 ); 222 222 - let has_category = params.category.is_some(); 223 194 let has_author = params.author.is_some(); 224 195 225 196 let active = !params.query.is_empty() 226 226 - || params.category.is_some() 227 197 || params.author.is_some() 228 198 || params.offset > 0; 229 199 ··· 240 210 let back_href = build_index_href( 241 211 &params.query, 242 212 params.scope, 243 243 - params.category.as_deref(), 244 213 params.author.as_deref(), 245 214 params.limit, 246 215 offset_used, ··· 257 226 query: QueryView { 258 227 q: params.query.clone(), 259 228 scope: params.scope.to_string(), 260 260 - category: params.category.clone().unwrap_or_default(), 261 229 author: params.author.clone().unwrap_or_default(), 262 262 - has_category, 263 230 has_author, 264 231 active, 265 232 }, ··· 276 243 next_offset, 277 244 pager_query, 278 245 books, 279 279 - categories, 280 246 authors, 281 247 git_hash, 282 248 } ··· 321 287 let back_href = build_index_href( 322 288 &params.query, 323 289 params.scope, 324 324 - params.category.as_deref(), 325 290 params.author.as_deref(), 326 291 params.limit, 327 292 params.offset, ··· 342 307 fn from_query(query: IndexQuery) -> Self { 343 308 let query_text = query.q.unwrap_or_default(); 344 309 let query_text = query_text.trim().to_string(); 345 345 - let category = cleaned_param(query.category); 346 310 let author = cleaned_param(query.author); 347 311 Self { 348 312 query: query_text, 349 313 scope: parse_scope(query.scope.as_deref()), 350 314 limit: clamp_limit(query.limit), 351 315 offset: query.offset.unwrap_or(0), 352 352 - category_norm: category.as_deref().map(normalize_query), 353 316 author_norm: author.as_deref().map(normalize_query), 354 354 - category, 355 317 author, 356 318 } 357 319 } ··· 360 322 fn collect_candidates<'a>( 361 323 library: &'a Library, 362 324 params: &FilterParams, 363 363 - ) -> Vec<&'a WrittenBookTag> { 325 325 + ) -> Vec<&'a Book> { 364 326 if !params.query.is_empty() { 365 365 - // Search results are narrowed by optional author/category filters. 366 327 return search_books( 367 328 library, 368 329 params.scope, ··· 370 331 SEARCH_MAX_RESULTS, 371 332 ) 372 333 .into_iter() 373 373 - .filter(|book| { 374 374 - matches_author(book, params.author_norm.as_deref()) 375 375 - && matches_category( 376 376 - book, 377 377 - library, 378 378 - params.category_norm.as_deref(), 379 379 - ) 380 380 - }) 334 334 + .filter(|book| matches_author(book, params.author_norm.as_deref())) 381 335 .collect(); 382 336 } 383 337 384 384 - if let (Some(_author_name), Some(category_name)) = 385 385 - (params.author.as_deref(), params.category.as_deref()) 386 386 - { 387 387 - return library 388 388 - .books_in_category(category_name) 389 389 - .filter(|book| matches_author(book, params.author_norm.as_deref())) 390 390 - .collect(); 391 391 - } 392 338 if let Some(author_name) = params.author.as_deref() { 393 339 return library.books_by_author(author_name).collect(); 394 340 } 395 395 - if let Some(category_name) = params.category.as_deref() { 396 396 - return library.books_in_category(category_name).collect(); 397 397 - } 398 341 library.all_books().collect() 399 342 } 400 343 401 401 - fn filtered_view_label(author: Option<&str>, category: Option<&str>) -> String { 402 402 - match (author, category) { 403 403 - (Some(author), Some(category)) => { 404 404 - format!("Author: {0} · Category: {1}", author, category) 405 405 - } 406 406 - (Some(author), None) => format!("Author: {0}", author), 407 407 - (None, Some(category)) => format!("Category: {0}", category), 408 408 - (None, None) => String::from("Filtered books"), 344 344 + fn filtered_view_label(author: Option<&str>) -> String { 345 345 + match author { 346 346 + Some(author) => format!("Author: {0}", author), 347 347 + None => String::from("Filtered books"), 409 348 } 410 410 - } 411 411 - 412 412 - fn build_categories( 413 413 - library: &Library, 414 414 - active: Option<&str>, 415 415 - ) -> Vec<CategoryView> { 416 416 - let mut categories: Vec<CategoryView> = library 417 417 - .categories() 418 418 - .into_iter() 419 419 - .map(|(name, count)| { 420 420 - let name_str = name.to_string(); 421 421 - CategoryView { 422 422 - active: active 423 423 - .map(|v| v.eq_ignore_ascii_case(&name_str)) 424 424 - .unwrap_or(false), 425 425 - href: format!( 426 426 - "/?category={0}", 427 427 - encode_query_component(&name_str) 428 428 - ), 429 429 - name: name_str, 430 430 - count, 431 431 - } 432 432 - }) 433 433 - .collect(); 434 434 - categories.sort_by(|a, b| { 435 435 - b.count.cmp(&a.count).then_with(|| a.name.cmp(&b.name)) 436 436 - }); 437 437 - categories 438 349 } 439 350 440 351 fn build_authors(library: &Library) -> Vec<AuthorView> { 441 352 let mut counts: ahash::AHashMap<SmolStr, (SmolStr, usize)> = 442 353 ahash::AHashMap::new(); 443 354 for book in library.all_books() { 444 444 - let raw = book.author.trim(); 355 355 + let raw = book.content.author.trim(); 445 356 if raw.is_empty() { 446 357 continue; 447 358 } ··· 477 388 (group, trimmed.to_lowercase()) 478 389 } 479 390 480 480 - fn build_pager_query( 481 481 - q: &str, 482 482 - scope: &str, 483 483 - category: Option<&str>, 484 484 - author: Option<&str>, 485 485 - ) -> String { 391 391 + fn build_pager_query(q: &str, scope: &str, author: Option<&str>) -> String { 486 392 let mut parts = Vec::new(); 487 393 if !q.is_empty() { 488 394 parts.push(format!("q={0}", encode_query_component(q))); 489 395 if scope != "all" { 490 396 parts.push(format!("scope={0}", encode_query_component(scope))); 491 397 } 492 492 - } 493 493 - if let Some(category) = category { 494 494 - parts.push(format!("category={0}", encode_query_component(category))); 495 398 } 496 399 if let Some(author) = author { 497 400 parts.push(format!("author={0}", encode_query_component(author))); ··· 506 409 fn build_index_href( 507 410 q: &str, 508 411 scope: &str, 509 509 - category: Option<&str>, 510 412 author: Option<&str>, 511 413 limit: usize, 512 414 offset: usize, ··· 518 420 parts.push(format!("scope={0}", encode_query_component(scope))); 519 421 } 520 422 } 521 521 - if let Some(category) = category { 522 522 - parts.push(format!("category={0}", encode_query_component(category))); 523 523 - } 524 423 if let Some(author) = author { 525 424 parts.push(format!("author={0}", encode_query_component(author))); 526 425 } ··· 551 450 } 552 451 } 553 452 554 554 - struct BookMeta { 555 555 - author_href: String, 556 556 - location: String, 557 557 - has_location: bool, 558 558 - category: String, 559 559 - has_category: bool, 560 560 - category_href: String, 561 561 - } 562 562 - 563 563 - fn book_meta(book: &WrittenBookTag, library: &Library) -> BookMeta { 564 564 - let hash = book.hash(); 565 565 - let location = library 566 566 - .location_for_hash(&hash) 567 567 - .map(|s| s.to_string()) 568 568 - .unwrap_or_default(); 569 569 - let has_location = !location.is_empty(); 570 570 - let category = if has_location { 571 571 - category_from_location(&location) 572 572 - .map(|s| s.to_string()) 573 573 - .unwrap_or_default() 574 574 - } else { 575 575 - String::new() 576 576 - }; 577 577 - let has_category = !category.is_empty(); 578 578 - let category_href = if has_category { 579 579 - format!("/?category={0}", encode_query_component(&category)) 580 580 - } else { 581 581 - String::new() 582 582 - }; 583 583 - let author_href = 584 584 - format!("/?author={0}", encode_query_component(&book.author)); 585 585 - 586 586 - BookMeta { 587 587 - author_href, 588 588 - location, 589 589 - has_location, 590 590 - category, 591 591 - has_category, 592 592 - category_href, 593 593 - } 594 594 - } 595 595 - 596 596 - fn book_card(book: &WrittenBookTag) -> BookCard { 453 453 + fn book_card(book: &Book) -> BookCard { 597 454 let hash_hex = hex::encode(book.hash()); 598 455 let author_href = 599 599 - format!("/?author={0}", encode_query_component(&book.author)); 456 456 + format!("/?author={0}", encode_query_component(&book.content.author)); 600 457 601 458 BookCard { 602 602 - title: book.title.clone(), 603 603 - author: book.author.clone(), 459 459 + title: book.content.title.clone(), 460 460 + author: book.content.author.clone(), 604 461 author_href, 605 462 hash: hash_hex.clone(), 606 463 detail_href: format!("/book/{0}", hash_hex), 607 464 } 608 465 } 609 466 610 610 - fn book_detail(book: &WrittenBookTag, library: &Library) -> BookDetail { 611 611 - let meta = book_meta(book, library); 467 467 + fn book_detail(book: &Book, _library: &Library) -> BookDetail { 468 468 + let author_href = 469 469 + format!("/?author={0}", encode_query_component(&book.content.author)); 612 470 let pages = book 471 471 + .content 613 472 .pages 614 473 .iter() 615 474 .enumerate() 616 475 .map(|(idx, page)| PageView { 617 476 index: idx + 1, 618 618 - html: HtmlText(page.to_html()), 477 477 + html: HtmlText(page.to_plain_text()), // TODO(kokiriglade): pass to_html or similar here 619 478 }) 620 479 .collect(); 621 480 622 481 BookDetail { 623 623 - title: book.title.clone(), 624 624 - author: book.author.clone(), 625 625 - author_href: meta.author_href, 626 626 - location: meta.location, 627 627 - has_location: meta.has_location, 628 628 - category: meta.category, 629 629 - category_href: meta.category_href, 630 630 - has_category: meta.has_category, 482 482 + title: book.content.title.clone(), 483 483 + author: book.content.author.clone(), 484 484 + author_href, 485 485 + source: book.metadata.source.clone(), 631 486 pages, 632 632 - page_count: book.pages.len(), 487 487 + page_count: book.content.pages.len(), 633 488 } 634 489 } 635 490 ··· 661 516 scope: &str, 662 517 query: &str, 663 518 fetch: usize, 664 664 - ) -> Vec<&'a WrittenBookTag> { 519 519 + ) -> Vec<&'a Book> { 665 520 match scope { 666 521 "title" => search_title_relaxed(library, query, fetch), 667 522 "author" => library ··· 686 541 library: &'a Library, 687 542 query: &str, 688 543 fetch: usize, 689 689 - ) -> Vec<&'a WrittenBookTag> { 544 544 + ) -> Vec<&'a Book> { 690 545 let needle = normalize_query(query); 691 546 if needle.is_empty() || fetch == 0 { 692 547 return Vec::new(); ··· 696 551 let mut seen: AHashSet<[u8; 20]> = AHashSet::new(); 697 552 698 553 for book in library.all_books() { 699 699 - let title_norm = normalize_query(&book.title); 554 554 + let title_norm = normalize_query(&book.content.title); 700 555 if title_norm.contains(&needle) { 701 556 let hash = book.hash(); 702 557 if seen.insert(hash) { ··· 721 576 out 722 577 } 723 578 724 724 - fn matches_author(book: &WrittenBookTag, author_norm: Option<&str>) -> bool { 579 579 + fn matches_author(book: &Book, author_norm: Option<&str>) -> bool { 725 580 let Some(author_norm) = author_norm else { 726 581 return true; 727 582 }; 728 728 - book.author.trim().eq_ignore_ascii_case(author_norm) 729 729 - } 730 730 - 731 731 - fn matches_category( 732 732 - book: &WrittenBookTag, 733 733 - library: &Library, 734 734 - category_norm: Option<&str>, 735 735 - ) -> bool { 736 736 - let Some(category_norm) = category_norm else { 737 737 - return true; 738 738 - }; 739 739 - let Some(location) = library.location_for_hash(&book.hash()) else { 740 740 - return false; 741 741 - }; 742 742 - let Some(category) = category_from_location(location) else { 743 743 - return false; 744 744 - }; 745 745 - category.trim().eq_ignore_ascii_case(category_norm) 583 583 + book.content.author.trim().eq_ignore_ascii_case(author_norm) 746 584 } 747 585 748 586 fn parse_hash(hex_str: &str) -> Option<[u8; 20]> {

+2 -2

src/web.rs

··· 8 8 use tokio::net::TcpListener; 9 9 use tower_http::compression::CompressionLayer; 10 10 11 11 - use crate::{cli::Args, library::Library}; 11 11 + use crate::{cli::ServeArgs, library::Library}; 12 12 13 13 pub mod api; 14 14 pub mod assets; ··· 32 32 } 33 33 34 34 pub async fn start_webserver( 35 35 - args: &Args, 35 35 + args: &ServeArgs, 36 36 library: Library, 37 37 ) -> anyhow::Result<()> { 38 38 let library = Arc::new(Mutex::new(library));

+50 -43

templates/book.html

··· 1 1 - {% extends "base.html" %} 2 2 - 3 3 - {% block title %}{{ book.title }} - nara{% endblock %} 1 1 + {% extends "base.html" %} {% block title %}{{ book.title }} - nara{% endblock %} 4 2 {% block head %} 5 5 - <link rel="icon" type="image/webp" href="/assets/image/{{ texture_kind }}/written_book.webp?v={{ crate::VERSION }}" /> 3 3 + <link 4 4 + rel="icon" 5 5 + type="image/webp" 6 6 + href="/assets/image/{{ texture_kind }}/written_book.webp?v={{ crate::VERSION }}" 7 7 + /> 6 8 <meta property="og:site_name" content="nara" /> 7 9 <meta property="og:type" content="article" /> 8 10 <meta property="og:title" content="{{ book.title }} - nara" /> 9 9 - <meta property="og:description" content="By {{ book.author }}. {{ book.page_count }} pages." /> 11 11 + <meta 12 12 + property="og:description" 13 13 + content="By {{ book.author }}. {{ book.page_count }} pages." 14 14 + /> 10 15 <meta name="twitter:card" content="summary_large_image" /> 11 16 <meta name="twitter:title" content="{{ book.title }} - nara" /> 12 12 - <meta name="twitter:description" content="By {{ book.author }}. {{ book.page_count }} pages." /> 13 13 - {% endblock %} 14 14 - 15 15 - {% block page_class %}page detail{% endblock %} 16 16 - {% block page_attrs %} style="--book-mask: url('/assets/image/{{ texture_kind }}/written_book.webp?v={{ crate::VERSION }}')"{% endblock %} 17 17 - 18 18 - {% block body %} 17 17 + <meta 18 18 + name="twitter:description" 19 19 + content="By {{ book.author }}. {{ book.page_count }} pages." 20 20 + /> 21 21 + {% endblock %} {% block page_class %}page detail{% endblock %} {% block 22 22 + page_attrs %} style="--book-mask: url('/assets/image/{{ texture_kind 23 23 + }}/written_book.webp?v={{ crate::VERSION }}')"{% endblock %} {% block body %} 19 24 <header class="hero detail-hero"> 20 20 - <div class="brand"> 21 21 - <span class="enchanted book-badge"> 22 22 - <img class="item" src="/assets/image/{{ texture_kind }}/written_book.webp?v={{ crate::VERSION }}" alt=""> 23 23 - </span> 24 24 - <div> 25 25 - <p class="eyebrow">Book Detail</p> 26 26 - <h1 class="font-minecraft">{{ book.title }}</h1> 27 27 - <p class="meta">by <a href="{{ book.author_href }}">{{ book.author }}</a></p> 28 28 - <div class="meta-row"> 29 29 - {% if book.has_category %} 30 30 - <a class="tag-link" href="{{ book.category_href }}"><span class="tag">{{ book.category }}</span></a> 31 31 - {% endif %} 32 32 - {% if book.has_location %} 33 33 - <span class="tag subtle">{{ book.location }}</span> 34 34 - {% endif %} 35 35 - <span class="tag subtle">{{ book.page_count }} pages</span> 36 36 - </div> 25 25 + <div class="brand"> 26 26 + <span class="enchanted book-badge"> 27 27 + <img 28 28 + class="item" 29 29 + src="/assets/image/{{ texture_kind }}/written_book.webp?v={{ crate::VERSION }}" 30 30 + alt="" 31 31 + /> 32 32 + </span> 33 33 + <div> 34 34 + <p class="eyebrow">Book Detail</p> 35 35 + <h1 class="font-minecraft">{{ book.title }}</h1> 36 36 + <p class="meta"> 37 37 + by <a href="{{ book.author_href }}">{{ book.author }}</a> 38 38 + </p> 39 39 + <div class="meta-row"> 40 40 + <span class="tag subtle">{{ book.page_count }} pages</span> 41 41 + </div> 42 42 + </div> 37 43 </div> 38 38 - </div> 39 39 - <div class="detail-actions"> 40 40 - <a class="button ghost" href="{{ back_href }}">Back to list</a> 41 41 - </div> 44 44 + <div class="detail-actions"> 45 45 + <a class="button ghost" href="{{ back_href }}">Back to list</a> 46 46 + </div> 42 47 </header> 43 48 44 49 <section class="detail-body"> 45 45 - <div class="pages"> 46 46 - {% for page in book.pages %} 47 47 - <article class="book-page"> 48 48 - <div class="book-page-sprite"> 49 49 - <p class="book-page-header font-minecraft">Page {{ page.index }} of {{ book.page_count }}</p> 50 50 - <div class="book-page-text font-minecraft">{{ page.html }}</div> 51 51 - </div> 52 52 - </article> 53 53 - {% endfor %} 54 54 - </div> 50 50 + <div class="pages"> 51 51 + {% for page in book.pages %} 52 52 + <article class="book-page"> 53 53 + <div class="book-page-sprite"> 54 54 + <p class="book-page-header font-minecraft"> 55 55 + Page {{ page.index }} of {{ book.page_count }} 56 56 + </p> 57 57 + <div class="book-page-text font-minecraft">{{ page.html }}</div> 58 58 + </div> 59 59 + </article> 60 60 + {% endfor %} 61 61 + </div> 55 62 </section> 56 63 {% endblock %}

+1 -34

templates/index.html

··· 53 53 {% endfor %} 54 54 </select> 55 55 </label> 56 56 - <label class="field"> 57 57 - <span>Category filter</span> 58 58 - <select name="category"> 59 59 - <option value="" {% if !query.has_category %}selected{% endif %}>All categories</option> 60 60 - {% for c in categories %} 61 61 - <option value="{{ c.name }}" {% if query.category==c.name %}selected{% endif %}>{{ c.name }} 62 62 - </option> 63 63 - {% endfor %} 64 64 - </select> 65 65 - </label> 66 56 <div class="actions"> 67 57 <button type="submit">Search</button> 68 58 {% if query.active %} ··· 72 62 </div> 73 63 </form> 74 64 75 75 - {% if query.has_category || query.has_author %} 65 65 + {% if query.has_author %} 76 66 <div class="active-filters"> 77 77 - {% if query.has_category %} 78 78 - <span class="chip">Category: {{ query.category }}</span> 79 79 - {% endif %} 80 80 - {% if query.has_author %} 81 67 <span class="chip">Author: {{ query.author }}</span> 82 82 - {% endif %} 83 68 </div> 84 69 {% endif %} 85 70 </header> 86 71 87 72 <section class="layout"> 88 88 - <aside class="sidebar"> 89 89 - <div class="panel"> 90 90 - <h2>Browse Categories</h2> 91 91 - <a class="all-link" href="/">All books</a> 92 92 - <ul class="category-list"> 93 93 - {% for c in categories %} 94 94 - <li> 95 95 - <a class="category-link {% if c.active %}active{% endif %}" href="{{ c.href }}"> 96 96 - <span>{{ c.name }}</span> 97 97 - <span class="count">{{ c.count }}</span> 98 98 - </a> 99 99 - </li> 100 100 - {% endfor %} 101 101 - </ul> 102 102 - </div> 103 103 - </aside> 104 104 - 105 73 <section class="results"> 106 74 <div class="results-header"> 107 75 <div> ··· 158 126 {% endif %} 159 127 </nav> 160 128 {% endif %} 161 161 - </section> 162 129 </section> 163 130 {% endblock %}