mirror/freebsd-ports
1
0
Fork 0
mirror of https://git.FreeBSD.org/ports.git synced 2025-01-19 08:13:21 +00:00
Code Issues Releases Activity
1af270ecae
freebsd-ports/games/anki/Makefile

595 lines
19 KiB
Makefile
Raw Normal View History

- Update to 2.0.4. - Trim header. PR: ports/172506 Submitted by: KATO Tsuguru <tkato432@yahoo.com>
2013-01-16 07:44:59 +00:00
# Created by: Andrew Pantyukhin <infofarmer@FreeBSD.org>
PORTNAME= anki
games/anki: Update to 2.1.48 Changelog: https://github.com/ankitects/anki/releases/tag/2.1.48 MFH: 2021Q3
2021-09-22 17:31:04 +00:00
DISTVERSION= 2.1.48
lang/rust: Relink consumers PR: 261449 Security: ee26f513-826e-11ec-8be6-d4c9ef517024
2022-02-03 14:02:32 +00:00
PORTREVISION= 4
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Don't forget to update ${_MY_BUILDHASH} if DISTVERSION changes
Add education virtual category PR: 248402 Submitted by: PauAmma
2020-11-20 07:16:06 +00:00
CATEGORIES= games education python
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
MASTER_SITES= LOCAL/kai/:yarncache
DISTFILES= anki-yarn-cache-${DISTVERSION}${EXTRACT_SUFX}:yarncache
Add ports games/anki and games/py-anki: Anki is a program designed to help you remember facts (such as words and phrases in a foreign language) as easily, quickly and efficiently as possible. To do this, it tracks how well you remember each fact, and uses that information to optimally schedule review times. With a minimal amount of effort, you can greatly increase the amount of material you remember, making study more productive, and more fun. While Anki can be used for studying anything, it also ships with special features designed to make studying Japanese and English easier: integrated dictionary lookups, missing kanji reports, and more. Sample decks are also provided for Russian. py-anki is a library based on a theory called spaced repetition. In simple terms, it means that each time you review some material, you should wait longer than last time before reviewing it again. WWW: http://ichi2.net/anki/ Author: Damien Elmes <anki@ichi2.net>
2008-02-12 17:38:25 +00:00
Change my maintainer email address to my new one at the FreeBSD project. Reviewed by: miwi (mentor) Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19050
2019-02-01 18:55:18 +00:00
MAINTAINER= kai@FreeBSD.org
Add ports games/anki and games/py-anki: Anki is a program designed to help you remember facts (such as words and phrases in a foreign language) as easily, quickly and efficiently as possible. To do this, it tracks how well you remember each fact, and uses that information to optimally schedule review times. With a minimal amount of effort, you can greatly increase the amount of material you remember, making study more productive, and more fun. While Anki can be used for studying anything, it also ships with special features designed to make studying Japanese and English easier: integrated dictionary lookups, missing kanji reports, and more. Sample decks are also provided for Russian. py-anki is a library based on a theory called spaced repetition. In simple terms, it means that each time you review some material, you should wait longer than last time before reviewing it again. WWW: http://ichi2.net/anki/ Author: Damien Elmes <anki@ichi2.net>
2008-02-12 17:38:25 +00:00
COMMENT= Flashcard trainer with spaced repetition
- Update to 2.0.36 - While here, fix LICENSE and unhardcode PREFIX PR: 211972 Submitted by: yuri@rawbw.com Approved by: trebbu@googlemail.com (maintainer)
2016-08-23 15:08:24 +00:00
LICENSE= AGPLv3+
- Drop @dirrm* from plist - Convert to USES=python - Add LICENSE_FILE
2014-10-09 14:00:40 +00:00
LICENSE_FILE= ${WRKSRC}/LICENSE
- Update to 2.0.4. - Trim header. PR: ports/172506 Submitted by: KATO Tsuguru <tkato432@yahoo.com>
2013-01-16 07:44:59 +00:00
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
NOT_FOR_ARCHS= armv6 armv7 i386 mips powerpc
NOT_FOR_ARCHS_REASON= the bazel build framework supports only 64-bit systems.
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
BUILD_DEPENDS= bash:shells/bash \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
bazel:devel/bazel \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
esbuild:devel/esbuild \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
protoc:devel/protobuf \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
yarn:www/yarn \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
${PYTHON_PKGNAMEPREFIX}mypy-protobuf>=1.21:devel/py-mypy-protobuf@${PY_FLAVOR} \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${PYTHON_PKGNAMEPREFIX}stringcase>0:devel/py-stringcase@${PY_FLAVOR} \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
${PYTHON_PKGNAMEPREFIX}black>0:devel/py-black@${PY_FLAVOR} \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${PYTHON_PKGNAMEPREFIX}fluent>0:devel/py-fluent@${PY_FLAVOR} \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
${RUN_DEPENDS}
# For x64 architectures there's also a Python package "orjson" that still needs
# to be ported once the required features (= "untagged unions",
# "specialication" and "const_generics") of the "smallvec" crate are available
# in the Rust release channel.
#
# Although the "orjson" package is required via the setup.py of Anki's Python
# library it's (still) optional in the code.
Remove ${PORTSDIR}/ from dependencies, categories d, e, f, and g. With hat: portmgr Sponsored by: Absolight
2016-04-01 14:00:51 +00:00
RUN_DEPENDS= lame:audio/lame \
Convert Python ports to FLAVORS. Ports using USE_PYTHON=distutils are now flavored. They will automatically get flavors (py27, py34, py35, py36) depending on what versions they support. There is also a USE_PYTHON=flavors for ports that do not use distutils but need FLAVORS to be set. A USE_PYTHON=noflavors can be set if using distutils but flavors are not wanted. A new USE_PYTHON=optsuffix that will add PYTHON_PKGNAMESUFFIX has been added to cope with Python ports that did not have the Python PKGNAMEPREFIX but are flavored. USES=python now also exports a PY_FLAVOR variable that contains the current python flavor. It can be used in dependency lines when the port itself is not python flavored. For example, deskutils/calibre. By default, all the flavors are generated. To only generate flavors for the versions in PYTHON2_DEFAULT and PYTHON3_DEFAULT, define BUILD_DEFAULT_PYTHON_FLAVORS in your make.conf. In all the ports with Python dependencies, the *_DEPENDS entries MUST end with the flavor so that the framework knows which to build/use. This is done by appending '@${PY_FLAVOR}' after the origin (or @${FLAVOR} if in a Python module with Python flavors, as the content will be the same). For example: RUN_DEPENDS= ${PYTHON_PKGNAMEPREFIX}six>0:devel/py-six@${PY_FLAVOR} PR: 223071 Reviewed by: portmgr, python Sponsored by: Absolight Differential Revision: https://reviews.freebsd.org/D12464
2017-11-30 15:50:30 +00:00
${PYTHON_PKGNAMEPREFIX}pyaudio>0:audio/py-pyaudio@${PY_FLAVOR} \
${PYTHON_PKGNAMEPREFIX}sqlite3>0:databases/py-sqlite3@${PY_FLAVOR} \
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
${PYTHON_PKGNAMEPREFIX}decorator>0:devel/py-decorator@${PY_FLAVOR} \
games/anki: Update to 2.1.13 Changelog: * Fix formatting getting lost when copying&pasting between fields on macOS. * Fix some issues that cause the main window to get stuck. * Fix an empty deck list sometimes appearing when restoring from a backup. * Fix Anki hanging after an error occurs during startup. * Fix error message when syncing with an unconfirmed email address. * Use jsonschema for add-on manifests * Warn in DB check when high due numbers are encountered. * Improve error messages on full disk and failed add-on deletion. * Fix relearning cards being given learning step count in V2 scheduler. * Fix preview window failing to appear when show both sides enabled. * Removing trailing BR tag when pasting into an empty field. * Don’t throw an error when non-Latin text in the Javascript console can’t be shown. * Double click on add-ons to edit their configuration. * Fix the window icon in a few screens. * Improve the default type in the answer note type. https://apps.ankiweb.net/docs/changes.html#changes-in-2.1.13-(3ba55990)
2019-05-22 06:45:00 +00:00
${PYTHON_PKGNAMEPREFIX}jsonschema>0:devel/py-jsonschema@${PY_FLAVOR} \
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
${PYTHON_PKGNAMEPREFIX}send2trash>0:deskutils/py-send2trash@${PY_FLAVOR} \
games/anki: Update to 2.1.13 Changelog: * Fix formatting getting lost when copying&pasting between fields on macOS. * Fix some issues that cause the main window to get stuck. * Fix an empty deck list sometimes appearing when restoring from a backup. * Fix Anki hanging after an error occurs during startup. * Fix error message when syncing with an unconfirmed email address. * Use jsonschema for add-on manifests * Warn in DB check when high due numbers are encountered. * Improve error messages on full disk and failed add-on deletion. * Fix relearning cards being given learning step count in V2 scheduler. * Fix preview window failing to appear when show both sides enabled. * Removing trailing BR tag when pasting into an empty field. * Don’t throw an error when non-Latin text in the Javascript console can’t be shown. * Double click on add-ons to edit their configuration. * Fix the window icon in a few screens. * Improve the default type in the answer note type. https://apps.ankiweb.net/docs/changes.html#changes-in-2.1.13-(3ba55990)
2019-05-22 06:45:00 +00:00
${PYTHON_PKGNAMEPREFIX}distro>0:sysutils/py-distro@${PY_FLAVOR} \
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
${PYTHON_PKGNAMEPREFIX}markdown>0:textproc/py-markdown@${PY_FLAVOR} \
${PYTHON_PKGNAMEPREFIX}beautifulsoup>0:www/py-beautifulsoup@${PY_FLAVOR} \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
${PYTHON_PKGNAMEPREFIX}requests>0:www/py-requests@${PY_FLAVOR} \
${PYTHON_PKGNAMEPREFIX}Flask>0:www/py-flask@${PY_FLAVOR} \
${PYTHON_PKGNAMEPREFIX}Flask-Cors>0:www/py-flask-cors@${PY_FLAVOR} \
${PYTHON_PKGNAMEPREFIX}protobuf>0:devel/py-protobuf@${PY_FLAVOR} \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${PYTHON_PKGNAMEPREFIX}stringcase>0:devel/py-stringcase@${PY_FLAVOR} \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
${PYTHON_PKGNAMEPREFIX}waitress>0:www/py-waitress@${PY_FLAVOR}
# USES=ssl is required for the compilation of the Rust code
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
USES= cargo desktop-file-utils pyqt:5 python:3.8+ shebangfix ssl
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
USE_GITHUB= yes
GH_ACCOUNT= ankitects
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Translation files
games/anki: Update to 2.1.48 Changelog: https://github.com/ankitects/anki/releases/tag/2.1.48 MFH: 2021Q3
2021-09-22 17:31:04 +00:00
GH_TUPLE= ankitects:anki-core-i18n:56d46d6:ftlrslib \
ankitects:anki-desktop-ftl:5359f84:ftlextra
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Bazel Skylib framework and sets of bazel rules
GH_TUPLE+= bazelbuild:bazel-skylib:e59b620:bzlskylib \
bazelbuild:rules_cc:40548a2:bzlrcc \
bazelbuild:rules_java:c13e3ea:bzlrjava \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
bazelbuild:rules_nodejs:2d02e82:bzlrnodejs \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
bazelbuild:rules_proto:f7a30f6:bzlrproto \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
ankitects:esbuild_toolchain:f942aa9:esbuildtc \
ankitects:rules_pip:fb02cb7:bzlrpip \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
ankitects:rules_python:3927c9b:bzlrpython \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
ankitects:rules_rust:f66001a:bzlrrust \
ankitects:rules_sass:275ace7:bzlrsass
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
PyQt: Update sip to 6.5.0, reintroduce sip4 and simplify PyQt framework. SIP: As mentioned in the update from sip to sip5, this is a transitional version to remove what is deprecated in sip4. Sip6 completely removes the deprecated parts. Unfortunately, some ports — mostly cura things — can not use sip6, so we reintroduce sip4. PyQt: At the same time, we took the opportunity to simplify PyQT and propose only one package as for devel/pyside2. */py-qt5-* have been merged — excepted chart, networkauth and webengine — into devel/py-qt5-pyqt. This allows us to be in adequacy with the packages that the author of these libraries proposes, namely: PyQt - devel/py-qt5-pyqt PyQt-Charts - x11-toolkits/py-qt5-chart PyQt-NetworkAuth – net/py-qt5-networkauth PyQt-WebEngine – www/py-qt5-webengine SIP – devel/py-sip py-sip - devel/py-qt5-sip PyQt-builder - devel/py-qtbuilder Qscintilla - devel/py-qt5-qscintilla2 Reviewed by: diizzy, kde Tested by: kai, rhurlin, arrowd, madpilot Approved by: makc, tcberner, kde Differential Revision: https://reviews.freebsd.org/D33237 Exp-run by: antoine
2021-10-24 18:51:36 +00:00
USE_PYQT= pyqt5 sip webengine
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
SHEBANG_FILES= qt/tools/runanki.system.in
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
CARGO_CRATES= Inflector-0.11.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
adler-1.0.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
ahash-0.7.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
aho-corasick-0.7.18 \
ammonia-3.1.2 \
anyhow-1.0.42 \
arc-swap-1.3.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
arrayref-0.3.6 \
arrayvec-0.4.12 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
arrayvec-0.5.2 \
askama-0.10.5 \
askama_derive-0.10.5 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
askama_escape-0.10.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
askama_shared-0.11.1 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
async-trait-0.1.51 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
atty-0.2.14 \
autocfg-1.0.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
base64-0.13.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
bitflags-1.2.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
bitvec-0.19.5 \
blake3-0.3.8 \
bumpalo-3.7.0 \
byteorder-1.4.3 \
bytes-1.0.1 \
cc-1.0.69 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
cfg-if-0.1.10 \
cfg-if-1.0.0 \
chrono-0.4.19 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
coarsetime-0.1.19 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
codespan-0.11.1 \
codespan-reporting-0.11.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
constant_time_eq-0.1.5 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
convert_case-0.4.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
core-foundation-0.9.1 \
core-foundation-sys-0.8.2 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
crc32fast-1.2.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
crossbeam-channel-0.5.1 \
crossbeam-utils-0.8.5 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
crypto-mac-0.8.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
cssparser-0.27.2 \
cssparser-macros-0.6.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
ctor-0.1.20 \
derivative-2.2.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
derive_more-0.99.16 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
digest-0.9.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
dirs-2.0.2 \
dirs-sys-0.3.6 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
dtoa-0.4.8 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
dtoa-short-0.3.3 \
dunce-1.0.2 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
either-1.6.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
encoding_rs-0.8.28 \
env_logger-0.8.4 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
fallible-iterator-0.2.0 \
fallible-streaming-iterator-0.1.9 \
fixedbitset-0.2.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
flate2-1.0.20 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
fluent-0.15.0 \
fluent-bundle-0.15.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
fluent-langneg-0.13.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
fluent-syntax-0.11.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
fnv-1.0.7 \
foreign-types-0.3.2 \
foreign-types-shared-0.1.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
form_urlencoded-1.0.1 \
funty-1.1.0 \
futf-0.1.4 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
futures-0.3.16 \
futures-channel-0.3.16 \
futures-core-0.3.16 \
futures-executor-0.3.16 \
futures-io-0.3.16 \
futures-macro-0.3.16 \
futures-sink-0.3.16 \
futures-task-0.3.16 \
futures-util-0.3.16 \
fxhash-0.2.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
generic-array-0.14.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
getopts-0.2.21 \
getrandom-0.1.16 \
getrandom-0.2.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
ghost-0.1.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
h2-0.3.3 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
hashbrown-0.11.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
hashlink-0.7.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
heck-0.3.3 \
hermit-abi-0.1.19 \
hex-0.4.3 \
html5ever-0.25.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
htmlescape-0.3.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
http-0.2.4 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
http-body-0.4.2 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
httparse-1.4.1 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
httpdate-1.0.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
humansize-1.1.1 \
humantime-2.1.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
hyper-0.14.11 \
hyper-rustls-0.22.1 \
hyper-tls-0.5.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
idna-0.2.3 \
indexmap-1.7.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
indoc-0.3.6 \
indoc-impl-0.3.6 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
inflections-1.1.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
instant-0.1.10 \
intl-memoizer-0.5.1 \
intl_pluralrules-7.0.1 \
inventory-0.1.10 \
inventory-impl-0.1.10 \
ipnet-2.3.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
itertools-0.9.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
itertools-0.10.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
itoa-0.4.7 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
js-sys-0.3.52 \
kuchiki-0.8.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
lazy_static-1.4.0 \
games/anki: Unbreak with Rust 1.53.0 error[E0308]: mismatched types --> cargo-crates/lexical-core-0.7.4/src/atof/algorithm/bhcomp.rs:62:24 | 62 | let bytes = bits / Limb::BITS; | ^^^^^^^^^^ expected `usize`, found `u32` error[E0277]: cannot divide `usize` by `u32` PR: 256653
2021-06-19 18:59:39 +00:00
lexical-core-0.7.6 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
libc-0.2.98 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
libsqlite3-sys-0.22.2 \
linkify-0.5.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
lock_api-0.4.4 \
log-0.4.14 \
mac-0.1.1 \
maplit-1.0.2 \
markup5ever-0.10.1 \
markup5ever_rcdom-0.1.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
matches-0.1.8 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
memchr-2.4.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
mime-0.3.16 \
mime_guess-2.0.3 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
miniz_oxide-0.4.4 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
mio-0.7.13 \
miow-0.3.7 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
multimap-0.8.3 \
native-tls-0.2.7 \
new_debug_unreachable-1.0.4 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
nodrop-0.1.14 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
nom-6.1.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
nom-7.0.0-alpha1 \
ntapi-0.3.6 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
num-format-0.4.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
num-integer-0.1.44 \
num-traits-0.2.14 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
num_cpus-1.13.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
num_enum-0.5.2 \
num_enum_derive-0.5.2 \
once_cell-1.8.0 \
openssl-0.10.35 \
openssl-probe-0.1.4 \
openssl-sys-0.9.65 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
ouroboros-0.9.5 \
ouroboros_macro-0.9.5 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
parking_lot-0.11.1 \
parking_lot_core-0.8.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
paste-0.1.18 \
paste-impl-0.1.18 \
percent-encoding-2.1.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
pest-2.1.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
petgraph-0.5.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
phf-0.8.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
phf-0.9.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
phf_codegen-0.8.0 \
phf_generator-0.8.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
phf_generator-0.9.0 \
phf_macros-0.8.0 \
phf_macros-0.9.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
phf_shared-0.8.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
phf_shared-0.9.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
pin-project-1.0.8 \
pin-project-internal-1.0.8 \
pin-project-lite-0.2.7 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
pin-utils-0.1.0 \
pkg-config-0.3.19 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
ppv-lite86-0.2.10 \
precomputed-hash-0.1.1 \
proc-macro-crate-1.0.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
proc-macro-error-1.0.4 \
proc-macro-error-attr-1.0.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
proc-macro-hack-0.5.19 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
proc-macro-nested-0.1.6 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
proc-macro2-1.0.28 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
prost-0.7.0 \
prost-build-0.7.0 \
prost-derive-0.7.0 \
prost-types-0.7.0 \
pulldown-cmark-0.8.0 \
pyo3-0.13.2 \
pyo3-macros-0.13.2 \
pyo3-macros-backend-0.13.2 \
quote-1.0.9 \
radium-0.5.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
rand-0.7.3 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
rand-0.8.4 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
rand_chacha-0.2.2 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
rand_chacha-0.3.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
rand_core-0.5.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
rand_core-0.6.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
rand_hc-0.2.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
rand_hc-0.3.1 \
rand_pcg-0.2.1 \
redox_syscall-0.2.9 \
redox_users-0.4.0 \
regex-1.5.4 \
regex-syntax-0.6.25 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
remove_dir_all-0.5.3 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
reqwest-0.11.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
ring-0.16.20 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
rusqlite-0.25.3 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
rustc-hash-1.1.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
rustc_version-0.3.3 \
rustls-0.19.1 \
rustls-native-certs-0.5.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
ryu-1.0.5 \
schannel-0.1.19 \
scopeguard-1.1.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
sct-0.6.1 \
security-framework-2.3.1 \
security-framework-sys-2.3.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
selectors-0.22.0 \
semver-0.11.0 \
semver-parser-0.10.2 \
serde-1.0.127 \
serde-aux-2.2.0 \
serde_derive-1.0.127 \
serde_json-1.0.66 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
serde_repr-0.1.7 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
serde_tuple-0.5.0 \
serde_tuple_macros-0.5.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
serde_urlencoded-0.7.0 \
servo_arc-0.1.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
sha1-0.6.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
siphasher-0.3.6 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
slab-0.4.3 \
slog-2.7.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
slog-async-2.7.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
slog-envlogger-2.2.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
slog-scope-4.4.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
slog-stdlog-4.1.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
slog-term-2.6.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
smallvec-1.6.1 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
socket2-0.4.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
spin-0.5.2 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
stable_deref_trait-1.2.0 \
static_assertions-1.1.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
string_cache-0.8.1 \
string_cache_codegen-0.5.1 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
strum-0.21.0 \
strum_macros-0.21.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
subtle-2.4.1 \
syn-1.0.74 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
take_mut-0.2.2 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
tap-1.0.1 \
tempfile-3.2.0 \
tendril-0.4.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
term-0.6.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
termcolor-1.1.2 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
thin-slice-0.1.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
thiserror-1.0.26 \
thiserror-impl-1.0.26 \
thread_local-1.1.3 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
time-0.1.44 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
tinystr-0.3.4 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
tinyvec-1.3.1 \
tinyvec_macros-0.1.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
tokio-1.9.0 \
tokio-macros-1.3.0 \
tokio-native-tls-0.3.0 \
tokio-rustls-0.22.0 \
tokio-socks-0.5.1 \
tokio-util-0.6.7 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
toml-0.5.8 \
tower-service-0.3.1 \
tracing-0.1.26 \
tracing-core-0.1.18 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
try-lock-0.2.3 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
type-map-0.4.0 \
typenum-1.13.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
ucd-trie-0.1.3 \
unic-char-property-0.9.0 \
unic-char-range-0.9.0 \
unic-common-0.9.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
unic-langid-0.9.0 \
unic-langid-impl-0.9.0 \
unic-langid-macros-0.9.0 \
unic-langid-macros-impl-0.9.0 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
unic-ucd-category-0.9.0 \
unic-ucd-version-0.9.0 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
unicase-2.6.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
unicode-bidi-0.3.5 \
unicode-normalization-0.1.19 \
unicode-segmentation-1.8.0 \
unicode-width-0.1.8 \
unicode-xid-0.2.2 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
unindent-0.1.7 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
untrusted-0.7.1 \
url-2.2.2 \
utf-8-0.7.6 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
utf8-decode-1.0.1 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
utime-0.3.1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
vcpkg-0.2.15 \
version_check-0.9.3 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
want-0.3.0 \
wasi-0.9.0+wasi-snapshot-preview1 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
wasi-0.10.0+wasi-snapshot-preview1 \
wasm-bindgen-0.2.75 \
wasm-bindgen-backend-0.2.75 \
wasm-bindgen-futures-0.4.25 \
wasm-bindgen-macro-0.2.75 \
wasm-bindgen-macro-support-0.2.75 \
wasm-bindgen-shared-0.2.75 \
web-sys-0.3.52 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
webpki-0.21.4 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
webpki-roots-0.21.1 \
which-4.2.2 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
winapi-0.3.9 \
winapi-i686-pc-windows-gnu-0.4.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
winapi-util-0.1.5 \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
winapi-x86_64-pc-windows-gnu-0.4.0 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
winreg-0.7.0 \
wyz-0.2.0 \
xml5ever-0.16.1 \
games/anki: Chase USES=cargo's new git source support PR: 256581
2021-10-07 14:47:18 +00:00
zip-0.5.13 \
reqwest@git+https://github.com/ankitects/reqwest.git?rev=7591444614de02b658ddab125efba7b2bb4e2335\#7591444614de02b658ddab125efba7b2bb4e2335 \
hyper-timeout@git+https://github.com/ankitects/hyper-timeout.git?rev=0cb6f7d14c62819e37cd221736f8b0555e823712\#0cb6f7d14c62819e37cd221736f8b0555e823712 \
linkcheck@git+https://github.com/ankitects/linkcheck.git?rev=2f20798ce521cc594d510d4e417e76d5eac04d4b\#2f20798ce521cc594d510d4e417e76d5eac04d4b \
tokio-io-timeout@git+https://github.com/ankitects/tokio-io-timeout.git?rev=1ee0892217e9a76bba4bb369ec5fab8854935a3c\#1ee0892217e9a76bba4bb369ec5fab8854935a3c \
pct-str@git+https://github.com/timothee-haudebourg/pct-str.git?rev=4adccd8d4a222ab2672350a102f06ae832a0572d\#4adccd8d4a222ab2672350a102f06ae832a0572d
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
CARGO_CARGOTOML= ${WRKSRC}/pylib/rsbridge/Cargo.toml
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
CARGO_BUILD= no
games/anki: Fix packaging with Python 3.8 * Add a workaround to make the transition from Python 3.7 to Python 3.8 possible because the name of the .so file is slightly different between the two releases. * Also add CARGO_INSTALL to avoid warnings about ignored duplicate scripts for the target "do-install". PR: 253815
2021-03-20 08:39:27 +00:00
CARGO_INSTALL= no
games/anki: Update to 2.0.47 Maintainer's timeout expired: trebbu@googlemail.com freebsd_ports@k-worx.org takes maintainership. Port changes: * Updated MASTER_SITES/added DISTNAME * Added to SHEBANG_FILES * Updated patches PR: 225487 Submitted by: owk <freebsd_ports@k-worx.org> Approved by: tcberner (mentor, implicit)
2018-03-05 09:10:37 +00:00
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# BAZEL=1 is required otherwise ${WRKSRC}/rslib/build/main.rs produces a dummy
# buildinfo.txt that doesn't contain the actual build hash.
CARGO_ENV= BAZEL=1 \
BUILDINFO=${_MY_LOCALREPO}/rust_output/buildinfo.txt \
PYO3_PYTHON=${PYTHON_CMD} \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
PROTO_TOP=${WRKSRC}/proto/.top_level \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
PROTOC=${LOCALBASE}/bin/protoc \
BACKEND_PROTO=${WRKSRC}/rslib/backend.proto \
RSLIB_FTL_ROOT=${_MY_LOCALREPO}/ftlrslib/l10n.toml \
EXTRA_FTL_ROOT=${_MY_LOCALREPO}/ftlextra/l10n.toml
- Update to 2.0.19 - Fix NLS, add Option - Break lines around 80 characters Reviewed by: Horia Racoviceanu <horia@racoviceanu.com> Approved by: pawel / wg (mentors, implicit)
2013-12-12 11:44:25 +00:00
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
OPTIONS_DEFAULT= MPV
OPTIONS_GROUP= PLAYER
OPTIONS_GROUP_PLAYER= MPLAYER MPV
OPTIONS_SUB= yes
MPV_DESC= mpv media player support
MPLAYER_RUN_DEPENDS= mplayer:multimedia/mplayer
MPV_RUN_DEPENDS= mpv:multimedia/mpv
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
# Should contain the most recent commit that reflects ${DISTVERSION} and must
# be exactly 8 digits otherwise the check for newer versions won't work as
# expected.
games/anki: Update to 2.1.48 Changelog: https://github.com/ankitects/anki/releases/tag/2.1.48 MFH: 2021Q3
2021-09-22 17:31:04 +00:00
_MY_BUILDHASH= fb07bad3
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Path of the local bazel repositories
_MY_LOCALREPO= ${WRKSRC}/local_repos
# Path of cache that is used by www/yarn
_MY_YARNCACHE= ${WRKDIR}/.yarn
games/anki: Fix packaging with Python 3.8 * Add a workaround to make the transition from Python 3.7 to Python 3.8 possible because the name of the .so file is slightly different between the two releases. * Also add CARGO_INSTALL to avoid warnings about ignored duplicate scripts for the target "do-install". PR: 253815
2021-03-20 08:39:27 +00:00
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
post-extract:
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Create a configuration file for bazel
@${ECHO_CMD} "startup --batch" > ${WRKSRC}/user.bazelrc
# Create local repositories which are used by bazel
@${MKDIR} ${_MY_LOCALREPO} \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${_MY_LOCALREPO}/local_esbuild/bin \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${_MY_LOCALREPO}/local_node/node/bin \
${_MY_LOCALREPO}/local_node/node/lib \
${_MY_LOCALREPO}/local_node/yarn/bin \
${_MY_LOCALREPO}/protoc_bin_freebsd/bin \
${_MY_LOCALREPO}/pyqt5 \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${_MY_LOCALREPO}/rust_output/librsbridge \
${_MY_LOCALREPO}/rust_output/strings_json
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Create empty WORKSPACE files in the top directory of each local
# repository
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
@${TOUCH} ${_MY_LOCALREPO}/local_esbuild/WORKSPACE \
${_MY_LOCALREPO}/local_node/WORKSPACE \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${_MY_LOCALREPO}/protoc_bin_freebsd/WORKSPACE \
${_MY_LOCALREPO}/pyqt5/WORKSPACE \
${_MY_LOCALREPO}/rust_output/WORKSPACE
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
# Copy the bazel rules for NodeJS and esbuild to the custom local repository
# as they need some patching
@${CP} -r ${WRKSRC_esbuildtc} ${_MY_LOCALREPO}/esbuild_toolchain
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${CP} -r ${WRKSRC_bzlrnodejs} ${_MY_LOCALREPO}/rules_nodejs
# Link the remaining bazel rules into the custom local repository as
# they don't need to be patched
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
.for _dir in bzlskylib bzlrcc bzlrjava bzlrpip bzlrproto bzlrpython bzlrrust bzlrsass ftlextra ftlrslib
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${RLN} ${WRKSRC_${_dir}} ${_MY_LOCALREPO}/${_dir:S/bzlr/rules_/}
.endfor
# Copy custom BUILD.bazel files to the local repositories
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
@${CP} ${FILESDIR}/bazel/BUILD.bazel-local_esbuild \
${_MY_LOCALREPO}/local_esbuild/BUILD.bazel
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${CP} ${FILESDIR}/bazel/BUILD.bazel-local_node \
${_MY_LOCALREPO}/local_node/BUILD.bazel
@${CP} ${FILESDIR}/bazel/BUILD.bazel-protoc_bin_freebsd \
${_MY_LOCALREPO}/protoc_bin_freebsd/BUILD.bazel
@${CP} ${FILESDIR}/bazel/BUILD.bazel-pyqt5 \
${_MY_LOCALREPO}/pyqt5/BUILD.bazel
@${CP} ${FILESDIR}/bazel/BUILD.bazel-rust_output-librsbridge \
${_MY_LOCALREPO}/rust_output/librsbridge/BUILD.bazel
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
@${CP} ${FILESDIR}/bazel/BUILD.bazel-rust_output-strings_json \
${_MY_LOCALREPO}/rust_output/strings_json/BUILD.bazel
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${CP} ${FILESDIR}/bazel/BUILD.bazel-i18n ${WRKSRC_ftlrslib}/BUILD.bazel
@${CP} ${FILESDIR}/bazel/BUILD.bazel-i18n ${WRKSRC_ftlextra}/BUILD.bazel
# Move some files out of the way as they will be replaced by custom copies.
@${MV} ${WRKSRC}/repos.bzl ${WRKSRC}/repos.bzl.dist
@${MV} ${WRKSRC}/pip/pyqt5/defs.bzl ${WRKSRC}/pip/pyqt5/defs.bzl.dist
@${MV} ${WRKSRC}/pylib/rsbridge/BUILD.bazel ${WRKSRC}/pylib/rsbridge/BUILD.bazel.dist
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
@${MV} ${WRKSRC}/rslib/i18n/BUILD.bazel ${WRKSRC}/rslib/i18n/BUILD.bazel.dist
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Copy the replacement files
@${CP} ${FILESDIR}/bazel/repos.bzl ${WRKSRC}/
@${CP} ${FILESDIR}/bazel/pyqt5.bzl ${WRKSRC}/pip/pyqt5/defs.bzl
@${CP} ${FILESDIR}/bazel/BUILD.bazel-pylib-rsbridge \
${WRKSRC}/pylib/rsbridge/BUILD.bazel
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
@${CP} ${FILESDIR}/bazel/BUILD.bazel-rslib-i18n \
${WRKSRC}/rslib/i18n/BUILD.bazel
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
- Update to 2.0.4. - Trim header. PR: ports/172506 Submitted by: KATO Tsuguru <tkato432@yahoo.com>
2013-01-16 07:44:59 +00:00
post-patch:
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${REINPLACE_CMD} -e 's|%%LOCALBASE%%|${LOCALBASE}|' \
${_MY_LOCALREPO}/rules_nodejs/internal/node/node_patches.js
@${REINPLACE_CMD} -e 's|\@PREFIX\@|${PREFIX}|' \
${WRKSRC}/qt/tools/runanki.system.in
@${REINPLACE_CMD} -e 's|%%_MY_BUILDHASH%%|${_MY_BUILDHASH}|' \
${WRKSRC}/scripts/status.sh
@${REINPLACE_CMD} -e 's|%%_MY_LOCALREPO%%|${_MY_LOCALREPO}|g' \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${WRKSRC}/repos.bzl ${WRKSRC}/proto/protobuf.bzl \
${_MY_LOCALREPO}/esbuild_toolchain/esbuild_repo.bzl
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${REINPLACE_CMD} -e 's|%%_MY_YARNCACHE%%|${_MY_YARNCACHE}|' \
${_MY_LOCALREPO}/rules_nodejs/internal/npm_install/npm_install.bzl
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
pre-configure:
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Link the binaries of Node, Protobuf and Yarn into the local bazel
# repositories to provide them during build.
${LN} -s ${LOCALBASE}/bin/protoc-gen-mypy ${WRKSRC}/pylib/tools/protoc-gen-mypy
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${LN} -s ${LOCALBASE}/bin/esbuild ${_MY_LOCALREPO}/local_esbuild/bin/esbuild
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${LN} -s ${LOCALBASE}/bin/node ${_MY_LOCALREPO}/local_node/node/bin/node
${LN} -s ${LOCALBASE}/bin/yarn.js ${_MY_LOCALREPO}/local_node/yarn/bin/yarn.js
${LN} -s ${LOCALBASE}/bin/protoc ${_MY_LOCALREPO}/protoc_bin_freebsd/bin/protoc
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
# Overview of the build process
#
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Steps 1 and 2 are built separately from the bazel build process.
#
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
# 1. rslib (Rust library, implictly built by step 2)
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
# `-> produces ${_MY_LOCALREPO}/rust_output/strings_json/strings.json
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# 2. pylib/rsbridge (Rust/Python bridge)
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
# `-> produces ${_MY_LOCALREPO}/rust_output/librsbridge/librsbridge.so
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# 3. The remaining components (Python, Qt5 and JS) are built by bazel
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
pre-build:
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Generate buildinfo.txt which is used via BUILDINFO in ${CARGO_ENV} during
# compilation.
${ECHO_CMD} -e "STABLE_VERSION ${DISTVERSION}\nSTABLE_BUILDHASH ${_MY_BUILDHASH}" >> ${_MY_LOCALREPO}/rust_output/buildinfo.txt
${CARGO_CARGO_RUN} build \
--manifest-path ${CARGO_CARGOTOML} \
--verbose \
${CARGO_BUILD_ARGS}
# These files are required for the remaining build process via bazel so copy
# them the local repository.
${CP} `${FIND} ${CARGO_TARGET_DIR} -name "librsbridge.so"` ${_MY_LOCALREPO}/rust_output/librsbridge/
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
${CP} `${FIND} ${CARGO_TARGET_DIR} -name "strings.json"` ${_MY_LOCALREPO}/rust_output/strings_json/
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
do-build:
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
# Limit bazel jobs to 1 due random build failures while compiling TS files
# via "tsc".
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
cd ${WRKSRC} && \
bazel --output_user_root="${WRKDIR}/.bazel" build \
--action_env=PYTHON_SITE_PACKAGES="${PYTHON_SITELIBDIR}" \
--action_env=PYTHON_SYS_EXECUTABLE="${PYTHON_CMD}" \
--compilation_mode opt \
games/anki: Update to 2.1.46 * Remove DIST_SUBDIR, which once made sense when Anki was still a pure Python port. Anki now needs a lot of Rust crates that are also used by other ports. Therefore, these crates should be placed in the usual place and not in an additional subdirectory to save bandwidth and disk space. [1] Reported by: se [1] MFH: 2021Q3
2021-08-13 12:25:55 +00:00
--jobs 1 \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
--subcommands \
dist
- Bump PORTREVISION - Use patches instead of REINPLACE_CMD, for upstream - Cleanup Makefile, add patches, use Port Makefile - Change pkg-plist, adjust NLS Approved by: pawel / wg (mentors, implicit)
2013-12-12 21:10:36 +00:00
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
post-build:
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${TAR} -xf `${FIND} ${WRKDIR}/.bazel -name "dist.tar"` -C ${WRKSRC}
cd ${WRKSRC}/bazel-dist && \
${UNZIP_NATIVE_CMD} anki-${DISTVERSION}-*.whl && \
${UNZIP_NATIVE_CMD} aqt-${DISTVERSION}-*.whl
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
# Compile Anki's Python libary (pylib) and Qt5 library (aqt) to prepare
# them for installation
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
${PYTHON_CMD} -m compileall ${WRKSRC}/bazel-dist/anki
${PYTHON_CMD} -O -m compileall ${WRKSRC}/bazel-dist/anki
${PYTHON_CMD} -m compileall ${WRKSRC}/bazel-dist/aqt
${PYTHON_CMD} -O -m compileall ${WRKSRC}/bazel-dist/aqt
- Update to 2.0.4. - Trim header. PR: ports/172506 Submitted by: KATO Tsuguru <tkato432@yahoo.com>
2013-01-16 07:44:59 +00:00
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
do-install:
${MKDIR} ${STAGEDIR}${DATADIR}/anki \
${STAGEDIR}${DATADIR}/aqt \
${STAGEDIR}${PREFIX}/share/pixmaps \
${STAGEDIR}${PREFIX}/share/applications
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
cd ${WRKSRC}/bazel-dist/ \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
&& ${COPYTREE_SHARE} anki ${STAGEDIR}${DATADIR} "! -name .gitignore" \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
&& ${COPYTREE_SHARE} aqt ${STAGEDIR}${DATADIR} "! -name .gitignore"
cd ${WRKSRC}/qt/linux \
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
&& ${INSTALL_DATA} anki.xpm anki.png ${STAGEDIR}${PREFIX}/share/pixmaps \
&& ${INSTALL_DATA} anki.desktop ${STAGEDIR}${PREFIX}/share/applications \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
&& ${INSTALL_MAN} anki.1 ${STAGEDIR}${MANPREFIX}/man/man1
cd ${WRKSRC}/qt/tools \
&& ${INSTALL_SCRIPT} runanki.system.in ${STAGEDIR}${PREFIX}/bin/anki
${STRIP_CMD} ${STAGEDIR}${DATADIR}/anki/_backend/rsbridge.so
Add LICENSE data. PR: ports/149564 (based on) Submitted by: Ullrich Franke <uf@raindogs.org> Approved by: [no objections from maintainers in four weeks]
2011-12-14 21:29:16 +00:00
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
# Helper target to make the generation of the yarn cache easier
make-yarn-cache:
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
# Run "make extract" before executing this target
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
@${RM} -r ${_MY_YARNCACHE}
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
@cd ${WRKSRC}/ts \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
&& ${LOCALBASE}/bin/yarn --cache-folder ${_MY_YARNCACHE} install
@cd ${WRKSRC_bzlrnodejs}/packages/labs/grpc_web/ \
&& ${LOCALBASE}/bin/yarn --cache-folder ${_MY_YARNCACHE} install
@cd ${WRKSRC_bzlrsass}/sass \
&& ${LOCALBASE}/bin/yarn --cache-folder ${_MY_YARNCACHE} install
games/anki: Update to 2.1.35 Since the 2.1.17 release the build system has been significantly revised and contains many changes (e.g. a Rust library with Python bindings) that had to be adapted to the Ports framework. Kudos to David Schlachter for the additional testing and feedback! Changelog since 2.1.16 (too many changes to list them separately): https://changes.ankiweb.net/ PR: 247666 Reported by: David Schlachter Reviewed by: tcberner (earlier revision) Differential Revision: https://reviews.freebsd.org/D26961
2020-11-10 13:01:04 +00:00
@cd ${WRKDIR} \
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
&& ${TAR} -czf ${PORTNAME}-yarn-cache-${DISTVERSION}${EXTRACT_SUFX} .yarn \
&& ${ECHO} "Please upload the file ${WRKDIR}/${PORTNAME}-yarn-cache-${DISTVERSION}${EXTRACT_SUFX}"
games/anki: Update to 2.1.11, undeprecate and set to BROKEN Undeprecate and save the port from the big Qt4 wipeout by switching from Qt4 to Qt5. Also set games/anki temporarily as BROKEN because www/py-qt5-webengine is still in a defunct state. This will change when www/qt5-webengine gets updated to a more recent version soon (hopefully to the end of Q1). At last but not least: Add options to switch between multimedia/mpv (new default by upstream) and multimedia/mplayer (previous default) or choose both of them. Changelog: Notable changes since 2.0.52: - Anki 2.1.x uses the same scheduling, syncing and file format as Anki 2.0.x, so one can upgrade and downgrade at will. - Switched from Python 2.7 to Python 3.6+ and from Qt 4 to Qt 5 - Add-ons will need to be updated to work with 2.1. - Built in MathJax support - A "restore backup" option in the profiles screen - SVG rendering support for LaTeX - Improved add-on configuration, management and updating - Night mode for reviewing - Improved pasting, with less unnecessary formatting included, and better handling of media links. https://apps.ankiweb.net/docs/changes.html PR: 233192 Approved by: miwi (mentor) Differential Revision: https://reviews.freebsd.org/D19564
2019-03-13 17:08:06 +00:00
games/anki: Update to 2.1.44 Since the 2.1.36 release the build system has changed significantly again and devel/bazel is now used by upstream for the entire build process. With this change, a lot of bazel rules and also some translation files needs to be downloaded from various repositories during the buildtime. In order to still make Anki compatible with the Ports framework, the following approach is used: 1. Prefetch all the required files before buildtime. 2. Create and setup a few local bazel repositories along with a set of custom bazel rules and to provide Node, Protobuf and Yarn from the Ports tree. 3. Compile the Rust library and place the output files to the respective local bazel repository for further processing. 4. Build the rest via devel/bazel From a technical point of view, Anki should also be able to be built on other 64-bit architectures (but requires further patching of a few bazel rules), as soon as devel/bazel can also be built for those platforms. The option NLS is gone because the translations are now compiled directly into the Rust library and they only generate a small overhead. Changelog since 2.1.35 (too many changes/fixes to list them separately): https://changes.ankiweb.net/ Reviewed by: tcberner MFH: 2021Q3 Differential Revision: https://reviews.freebsd.org/D31358
2021-08-02 06:10:10 +00:00
.include <bsd.port.mk>
Reference in New Issue Copy Permalink