.cargo/config

-[target.x86_64-unknown-redox]
-linker = "x86_64-unknown-redox-gcc"
-rustflags = []

.cargo/config.toml

+[target.aarch64-unknown-redox]
+linker = "aarch64-unknown-redox-gcc"
+rustflags = []
+
+[target.i686-unknown-redox]
+linker = "i686-unknown-redox-gcc"
+rustflags = []
+
+[target.x86_64-unknown-redox]
+linker = "x86_64-unknown-redox-gcc"
+rustflags = []
+
+[target.riscv64gc-unknown-redox]
+linker = "riscv64-unknown-redox-gcc"
+rustflags = []
+
+[env]
+CFLAGS_riscv64gc_unknown_redox="-march=rv64gc -mabi=lp64d"

.gitignore

-build
-repo
+/build
+/repo
 source
+source.tmp
+source-new
 source.tar
-stage
-stage.sig
-stage.tar
-stage.tar.gz
-stage.toml
-sysroot
-xargo
+source.tar.tmp
+target

.gitmodules

-[submodule "libc-artifacts"]
-	path = libc-artifacts
-	url = https://github.com/redox-os/libc-artifacts.git
-	branch = master
-[submodule "pkgutils"]
-	path = pkgutils
-	url = https://github.com/redox-os/pkgutils.git
+[submodule "pkgar"]
+	path = pkgar
+	url = https://gitlab.redox-os.org/redox-os/pkgar.git
 	branch = master

.travis.yml

-language: generic
-sudo: required
-install:
-  - curl https://sh.rustup.rs -sSf > rustup; chmod +x rustup; ./rustup --default-toolchain nightly -y
-  - export PATH="$HOME/.cargo/bin:$PATH"; ./setup.sh
-script: export PATH="$HOME/.cargo/bin:$PATH"; ./ci.sh
-notifications:
-  email: false

Cargo.toml

+[package]
+name = "redox_cookbook"
+version = "0.1.0"
+authors = ["Jeremy Soller <jackpot51@gmail.com>"]
+edition = "2018"
+default-run = "cook"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[[bin]]
+name = "cook"
+path = "src/bin/cook.rs"
+
+[[bin]]
+name = "cookbook_redoxer"
+path = "src/bin/cookbook_redoxer.rs"
+
+[lib]
+name = "cookbook"
+path = "src/lib.rs"
+
+[dependencies]
+blake3 = "=1.5.3" # 1.5.4 is incompatible with blake3 0.3 dependency from pkgar
+object = { version = "0.36", features = ["build_core"] }
+pbr = "1.0.2"
+pkgar = { path = "pkgar/pkgar" }
+pkgar-core = { path = "pkgar/pkgar-core" }
+pkgar-keys = { path = "pkgar/pkgar-keys" }
+redoxer = "0.2"
+serde = { version = "=1.0.197", features = ["derive"] }
+termion = "4"
+toml = "0.8"
+walkdir = "2.3.1"

README.md

-# cookbook
-A collection of package recipes for Redox.
+# Cookbook
+
+Package system of Redox.
+
+This repository contains the system source code and packages inside the `recipes` folder.
+
+- A recipe can be a software port or system package (they use `pkgar` or `tar.gz` formats).
+
+**Read [this](https://doc.redox-os.org/book/porting-applications.html) page before porting programs to Redox**
+
+In order for this repository to be useful, it must be set up with an environment
+from the [redox](https://gitlab.redox-os.org/redox-os/redox) repository.
 
-[![Travis Build Status](https://travis-ci.org/redox-os/cookbook.svg?branch=master)](https://travis-ci.org/redox-os/cookbook)
 [![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
 
-## Setup
+- [Recipe Categories](#recipe-categories)
+- [Search Recipes](#search-recipes)
+- [Package Policy](#package-policy)
+    - [Cross-Compilation](#cross-compilation)
+    - [Library Linking](#library-linking)
+    - [ABI stability](#abi-stability)
+    - [Checksum](#checksum)
+    - [License](#license)
+- [Testing Area](#testing-area)
+    - [Suggestions for TODOs](#suggestions-for-todos)
+- [Repository Layout](#repository-layout)
+- [TODO](#todo)
+
+### Recipe Categories
+
+The categories inside the `recipes` folder.
+
+- `core` - System components
+- `demos` - Programs with demos and examples
+- `dev` - Programs used for development and programming languages, like compilers and dependency managers
+- `doc` - Programs used for documentation
+- `emulators` - Console emulators or compatibility layers
+- `fonts` - Fonts and programs for fonts
+- `games` - Any kind of game
+- `graphics` - Programs used for graphics processing or production
+- `gui` - Orbital
+- `icons` - Icon packs
+- `libs` - Software with functions for other softwares, like OpenSSL
+- `math` - Programs used for calculations
+- `net` - Networking tools
+- `other` - Software that can't fit on other categories
+- `shells` - Terminal interpreters and extensions
+- `sound` - Software used for sound processing or production
+- `tests` - Software used to test other softwares
+- `tools` - Text editors, terminal tools and any other kind of tools
+- `tui` - Programs with a [terminal user interface](https://en.wikipedia.org/wiki/Text-based_user_interface)
+- `video` - Programs used for video playback, processing and production
+- `web` - World Wide Web browsers and tools
+- `wip` - Software that needs porting or incomplete recipes
+
+### Search Recipes
+
+Click in the button named "Find file" on the top of this repository to search for recipe names.
+
+### Package Policy
+
+Before sending your recipe to upstream (to become a public package), you must follow these rules:
+
+#### Cross-Compilation
+
+- All recipes must use our cross-compilers, a Cookbook [template](https://doc.redox-os.org/book/porting-applications.html#templates) does this automatically but it's not always possible, study the build system of your program or library to find these options or patch the configuration files.
+- Don't hardcode the CPU architecture on the recipe script (this would break the multi-arch support).
+
+#### Tarballs
+
+- Don't use the auto-generated tarballs from GitHub, they aren't static and don't verify the archive integrity.
+
+#### Library Linking
+
+- Keep the static linking of libraries to reduce the launch time and improve security.
+- If your package is bigger than 50MB, dynamic link big libraries until your package is equal or less than 50MB (to reduce the RAM usage).
+
+#### ABI stability
+
+- Respect the ABI separation of the libraries, for example, if `openssl1` is available and some program need `openssl3`, you will create a recipe for `openssl3` and not rename the `openssl1`, as it will break the dependent packages.
+
+#### Checksum
+
+- If your recipe download a tarball, you will need to create a BLAKE3 hash for it. You can learn how to do it [here](https://doc.redox-os.org/book/porting-applications.html#create-a-blake3-hash-for-your-recipe).
+
+#### License
+
+- Don't package programs or libraries lacking a license.
+- Verify if the program has some license violation, in case of doubt ask us on the [chat](https://doc.redox-os.org/book/chat.html).
+- Non-free programs and assets should go to a subcategory of the `nonfree` category and be approved per license.
+
+### Testing Area
+
+Work-in-progress software ports goes to the `wip` category, be aware of these items during your packaging process:
+
+- A recipe is considered ready if it's mostly working inside of Redox.
+- All WIP recipes must have a `#TODO` on the beginning of the `recipe.toml` and explain what is missing.
+- BLAKE3 hashes for tarballs are optional (quick testing workflow)
+- Try to keep the recipe with the latest stable version of the program (the porting process can take months).
+- Once the recipe is ready, add the BLAKE3 hash if needed and move the folder to the appropriate category.
+
+#### Suggestions for TODOs
+
+These TODOs improve the packagers cooperation and understanding.
+
+- `not compiled or tested` - It means that your recipe is fully configured and don't lack necessary dependencies.
+- `missing script for x, see insert-the-link-for-build-instructions-here` - It means that your recipe is lacking the cross-compilation script for some build system, where `x` is the build system name. After `see` you will insert the link for the build instructions of the program or library, it will help other packagers to insert the script for you.
+- `missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that the `dependencies = []` section is incomplete.
+- `probably wrong script, see insert-the-link-for-build-instructions-here` - It means that you don't know if your script will work.
+- `probably wrong template, see insert-the-link-for-build-instructions-here` - It means that you don't know if the Cookbook template will work.
+- `probably missing dependencies, see insert-the-link-for-required-dependencies-here` - It means that you don't know if the required dependencies are satisfied.
+- `promote` - It means that the recipe is working and should be moved to the equivalent category at `cookbook/recipes`
 
-### Ubuntu and other Debian based systems
+Other TODOs are specific and won't be covered on this list.
 
-To install the toolchain, run the following commands:
-```bash
-# Get the Redox OS APT key
-sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys AA12E97F0881517F
+### Repository Layout
 
-# Install the APT repository
-sudo add-apt-repository 'deb https://static.redox-os.org/toolchain/apt /'
+- `.cargo` - Cargo configuration.
+- `bin` - LLVM and pkg-config CPU targets.
+- `recipes` - Package configuration files.
+- `src` - Package system source code.
 
-# Update your package lists
-sudo apt update
+### TODO
 
-# Install the cross compiler
-sudo apt install x86-64-unknown-redox-gcc
-```
+- Convert old recipes to TOML, see [this](https://gitlab.redox-os.org/redox-os/cookbook/-/issues/174) tracking issue.
+- Remove the scripts after full TOML conversion.

Xargo.toml

-[dependencies.std]
-features = ["panic_unwind", "backtrace"]
-
-#[dependencies.test]
-#stage = 1
-

bin/aarch64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+if [ -n "${COOKBOOK_DYNAMIC}" ]
+then
+    exec pkg-config "$@"
+else
+    exec pkg-config --static "$@"
+fi

bin/i686-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+if [ -n "${COOKBOOK_DYNAMIC}" ]
+then
+    exec pkg-config "$@"
+else
+    exec pkg-config --static "$@"
+fi

bin/riscv64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+if [ -n "${COOKBOOK_DYNAMIC}" ]
+then
+    exec pkg-config "$@"
+else
+    exec pkg-config --static "$@"
+fi

bin/x86_64-unknown-redox-pkg-config

+#!/usr/bin/env bash
+
+export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+export PKG_CONFIG_LIBDIR="${PKG_CONFIG_SYSROOT_DIR}/lib/pkgconfig"
+export PKG_CONFIG_PATH="${PKG_CONFIG_SYSROOT_DIR}/share/pkgconfig"
+
+if [ -n "${COOKBOOK_DYNAMIC}" ]
+then
+    exec pkg-config "$@"
+else
+    exec pkg-config --static "$@"
+fi

clean.sh

@@ -5,14 +5,12 @@ source config.sh
 
 if [ $# = 0 ]
 then
-    recipes="$(ls -1 recipes)"
+    recipes="$(target/release/list_recipes)"
 else
     recipes="$@"
 fi
 
-for recipe in $recipes
+for recipe_path in $recipes
 do
-    ./cook.sh "$recipe" distclean
+    ./cook.sh "$recipe_path" distclean
 done
-
-rm -rf xargo

config.sh

@@ -2,17 +2,39 @@
 set -e
 
 # Configuration
-ARCH=x86_64
-export TARGET=$ARCH-unknown-redox
-HOST=$TARGET
+if [ -z "${TARGET}" ]
+then
+    export TARGET=x86_64-unknown-redox
+fi
+ARCH="${TARGET%%-*}"
+HOST="$TARGET"
+if [ x"${HOST}" == x"riscv64gc-unknown-redox" ] ; then
+	HOST="riscv64-unknown-redox"
+fi
 
 # Automatic variables
 ROOT="$(cd `dirname "$0"` && pwd)"
 REPO="$ROOT/repo/$TARGET"
-export CC="$HOST-gcc"
-export XARGO_HOME="$ROOT/xargo"
+export PATH="${ROOT}/bin:$PATH"
+
+export AR="${HOST}-gcc-ar"
+export AS="${HOST}-as"
+export CC="${HOST}-gcc"
+export CXX="${HOST}-g++"
+export LD="${HOST}-ld"
+export NM="${HOST}-gcc-nm"
+export OBJCOPY="${HOST}-objcopy"
+export OBJDUMP="${HOST}-objdump"
+export PKG_CONFIG="${HOST}-pkg-config"
+export RANLIB="${HOST}-gcc-ranlib"
+export READELF="${HOST}-readelf"
+export STRIP="${HOST}-strip"
+
+BUILD="$(cc -dumpmachine)"
 
-if [[ "$OSTYPE" == "darwin"* ]]; then
+export PKG_CONFIG_FOR_BUILD="pkg-config"
+
+if [[ "$OSTYPE" == "darwin"* ]] || [[ "$OSTYPE" == "FreeBSD" ]]; then
     # GNU find
     FIND="gfind";
 
@@ -22,6 +44,8 @@ if [[ "$OSTYPE" == "darwin"* ]]; then
     elif [ ! -z "$(which port)" ]; then
         # TODO: find a programatic way of asking MacPorts for it's root dir.
         STAT="/opt/local/opt/coreutils/libexec/gnubin/stat";
+    elif [ ! -z "$(which pkg)" ]; then
+        STAT="gnustat"
     else
         echo "Please install either Homebrew or MacPorts and run the boostrap script."
         exit 1
@@ -30,3 +54,13 @@ else
     FIND="find"
     STAT="stat";
 fi
+
+export FIND
+export STAT
+
+if [ ! "$(uname -s)" = "Redox" ]
+then
+function pkgar {
+    "$ROOT/pkgar/target/release/pkgar" "$@"
+}
+fi

cook.sh

@@ -6,14 +6,18 @@ source config.sh
 
 # Variables to be overriden by recipes
 export BINDIR=bin
+export CARGO=(env RUSTFLAGS="$PREFIX_RUSTFLAGS -C link-arg=-zmuldefs" cargo)
+export CARGOBUILD=rustc
 export CARGOFLAGS=
 export DEBUG=
+export EXAMPLES=
+export PREPARE_COPY=1
 
-if [ ! "$(uname -s)" = "Redox" ]
+if hash sha256sum 2>/dev/null
 then
-function pkg {
-    CC=cc cargo run --release --manifest-path "$ROOT/pkgutils/Cargo.toml" --bin pkg -- $@
-}
+    SHASUM="sha256sum"
+else
+    SHASUM="shasum -a 256"
 fi
 
 function usage {
@@ -22,26 +26,14 @@ function usage {
     echo "  distclean" >&2
     echo "  build" >&2
     echo "  clean" >&2
-    echo "  diff" >&2
-    echo "  diff_origin" >&2
-    echo "  diff_upstream" >&2
-    echo "  difftool" >&2
-    echo "  difftool_origin" >&2
-    echo "  difftool_upstream" >&2
     echo "  fetch" >&2
     echo "  unfetch" >&2
+    echo "  pkg" >&2
+    echo "  unpkg" >&2
     echo "  prepare" >&2
     echo "  unprepare" >&2
-    echo "  publish" >&2
-    echo "  unpublish" >&2
     echo "  stage" >&2
     echo "  unstage" >&2
-    echo "  status" >&2
-    echo "  status_origin" >&2
-    echo "  status_upstream" >&2
-    echo "  tar" >&2
-    echo "  untar" >&2
-    echo "  update" >&2
     echo "  version" >&2
 }
 
@@ -56,10 +48,10 @@ function op {
             op $1 prepare
             op $1 build
             op $1 stage
-            op $1 tar
+            op $1 pkg
             ;;
         distclean)
-            op $1 untar
+            op $1 unpkg
             op $1 unstage
             op $1 unprepare
             ;;
@@ -75,7 +67,13 @@ function op {
                 then
                     if [ ! -f source.tar ]
                     then
-                        wget "$TAR" -O source.tar
+                        wget "$TAR" --continue -O source.tar.tmp
+                        mv source.tar.tmp source.tar
+                    fi
+
+                    if [ -n "$TAR_SHA256" ]
+                    then
+                        $SHASUM -c <<< "${TAR_SHA256} source.tar"
                     fi
 
                     if [ ! -d source ]
@@ -104,7 +102,17 @@ function op {
                         git remote add upstream "$GIT_UPSTREAM"
                         git fetch upstream
                     fi
-                    git pull
+
+                    ORIGIN_BRANCH="$(git branch --remotes | grep '^  origin/HEAD -> ' | cut -d ' ' -f 5-)"
+                    if [ -n "$BRANCH" ]
+                    then
+                        ORIGIN_BRANCH="origin/$BRANCH"
+                    fi
+
+                    if [ "$(git rev-parse HEAD)" != "$(git rev-parse $ORIGIN_BRANCH)" ]
+                    then
+                        git checkout -B "$(echo "$ORIGIN_BRANCH" | cut -d / -f 2-)" "$ORIGIN_BRANCH"
+                    fi
                     git submodule sync --recursive
                     git submodule update --init --recursive
                     popd > /dev/null
@@ -112,144 +120,63 @@ function op {
             fi
             ;;
         unfetch)
-            rm -rfv source
-            if [ -n "$TAR" ]
-            then
-                rm -f source.tar
-            fi
-            ;;
-        status)
-            if [ -n "$TAR" ]
-            then
-                tar --compare --file="source.tar" -C "source" --strip-components=1 2>&1 |
-                grep -v "tar: :" | grep -v '\(Mod time\|Mode\|Gid\|Uid\) differs' ||
-                true
-            elif [ -n "$GIT" ]
-            then
-                git -C source diff --stat --color
-            fi
-            ;;
-        status_origin)
-            if [ -n "$GIT" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff --stat --color "origin/$BRANCH"
-                else
-                    git -C source diff --stat --color "origin/master"
-                fi
-            fi
-            ;;
-        status_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff --stat --color "upstream/$BRANCH"
-                else
-                    git -C source diff --stat --color "upstream/master"
-                fi
-            fi
-            ;;
-        diff)
-            if [ -n "$GIT" ]
-            then
-                git -C source diff
-            fi
-            ;;
-        diff_origin)
-            if [ -n "$GIT" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff "origin/$BRANCH"
-                else
-                    git -C source diff "origin/master"
-                fi
-            fi
+            rm -rfv source source.tar
             ;;
-        diff_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
-                then
-                    git -C source diff "upstream/$BRANCH"
-                else
-                    git -C source diff "upstream/master"
-                fi
-            fi
-            ;;
-        difftool)
-            if [ -n "$GIT" ]
+        prepare)
+            skip=0
+            if [ "$(type -t recipe_prepare)" = "function" ]
             then
-                git -C source difftool -d
+                recipe_prepare
             fi
-            ;;
-        difftool_origin)
-            if [ -n "$GIT" ]
+            if [ "$skip" -eq "0" ]
             then
-                if [ -n "$BRANCH" ]
+                rm -rf "${COOKBOOK_SYSROOT}"
+                mkdir "${COOKBOOK_SYSROOT}"
+
+                # usrmerge
+                mkdir "${COOKBOOK_SYSROOT}/usr"
+                for folder in bin include lib share
+                do
+                    mkdir "${COOKBOOK_SYSROOT}/usr/${folder}"
+                    ln -s "usr/${folder}" "${COOKBOOK_SYSROOT}/${folder}"
+                done
+
+                if [ ${#BUILD_DEPENDS} -gt 0 ]
                 then
-                    git -C source difftool -d "origin/$BRANCH"
-                else
-                    git -C source difftool -d "origin/master"
+                    pushd $ROOT
+                        ./repo.sh "${BUILD_DEPENDS[@]}"
+                    popd
+
+                    for i in "${BUILD_DEPENDS[@]}"
+                    do
+                        pkgar \
+                            extract \
+                            "${COOKBOOK_SYSROOT}" \
+                            --archive "$REPO/$i.pkgar" \
+                            --pkey "${ROOT}/build/id_ed25519.pub.toml"
+                    done
                 fi
-            fi
-            ;;
-        difftool_upstream)
-            if [ -n "$GIT_UPSTREAM" ]
-            then
-                if [ -n "$BRANCH" ]
+
+                rm -rf "${COOKBOOK_BUILD}"
+                if [ "$PREPARE_COPY" -eq "0" ]
                 then
-                    git -C source difftool -d "upstream/$BRANCH"
+                    mkdir "${COOKBOOK_BUILD}"
                 else
-                    git -C source difftool -d "upstream/master"
+                    cp -Rp source "${COOKBOOK_BUILD}"
                 fi
-            fi
-            ;;
-        update)
-            pushd source > /dev/null
-            skip=0
-            if [ "$(type -t recipe_update)" = "function" ]
-            then
-                recipe_update
-            fi
-            if [ "$skip" -eq "0" ]
-            then
-                xargo update
-            fi
-            popd > /dev/null
-            ;;
-        prepare)
-            rm -rf sysroot
-            mkdir sysroot
 
-            if [ ${#BUILD_DEPENDS} -gt 0 ]
-            then
-                pushd $ROOT
-                    ./repo.sh "${BUILD_DEPENDS[@]}"
-                popd
-
-                for i in "${BUILD_DEPENDS[@]}"
+                for patch in *.patch
                 do
-                    pkg --target=$TARGET install --root sysroot "$REPO/$i.tar.gz"
+                    patch -p1 -d "${COOKBOOK_BUILD}" < "$patch"
                 done
             fi
-
-            rm -rf build
-            cp -rp source build
-
-            for patch in *.patch
-            do
-                patch -p1 -d build < "$patch"
-            done
             ;;
         unprepare)
-            rm -rf build
-            rm -rf sysroot
+            rm -rf "${COOKBOOK_BUILD}"
+            rm -rf "${COOKBOOK_SYSROOT}"
             ;;
         version)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_version)" = "function" ]
             then
@@ -257,20 +184,21 @@ function op {
             fi
             if [ "$skip" -eq "0" ]
             then
-                cargo config package.version | tr -d '"'
+                # there's an unstable built-in cargo config command, so hack around it
+                cargo-config config package.version | tr -d '"'
             fi
             popd > /dev/null
             ;;
         gitversion)
-            if [ -d build/.git ]
+            if [ -d "${COOKBOOK_BUILD}"/.git ]
             then
-                echo "$(op $1 version)-$(git -C build rev-parse --short HEAD)"
+                echo "$(op $1 version)-$(git -C "${COOKBOOK_BUILD}" rev-parse --short HEAD)"
             else
                 op $1 version
             fi
             ;;
         build)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_build)" = "function" ]
             then
@@ -283,36 +211,20 @@ function op {
                 release_flag=
             fi
 
-            if [ "$skip" -eq "0" ]
-            then
-                cp -r "$ROOT/Xargo.toml" .
-                xargo build --target "$TARGET" $release_flag $CARGOFLAGS
-            fi
-            popd > /dev/null
-            ;;
-        test)
-            pushd build > /dev/null
-            skip=0
-            if [ "$(type -t recipe_test)" = "function" ]
-            then
-                recipe_test
-            fi
-
-            release_flag="--release"
-            if [ "$DEBUG" == 1 ]
-            then
-                release_flag=
+            if [ -n "$CARGO_PACKAGE" ]; then
+                package_flag="--package=$CARGO_PACKAGE"
+            else
+                package_flag=
             fi
 
             if [ "$skip" -eq "0" ]
             then
-                cp -r "$ROOT/Xargo.toml" .
-                xargo test --no-run --target "$TARGET" $release_flag $CARGOFLAGS
+                "${CARGO[@]}" "$CARGOBUILD" --target "$TARGET" $release_flag $package_flag $CARGOFLAGS
             fi
             popd > /dev/null
             ;;
         clean)
-            pushd build > /dev/null
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_clean)" = "function" ]
             then
@@ -320,52 +232,74 @@ function op {
             fi
             if [ "$skip" -eq "0" ]
             then
-                xargo clean
+                "${CARGO[@]}" clean
             fi
             popd > /dev/null
             ;;
         stage)
             op $1 unstage
-            mkdir -p stage
-            pushd build > /dev/null
+            mkdir -p "${COOKBOOK_STAGE}"
+            stage="$(realpath "${COOKBOOK_STAGE}")"
+            source="$(realpath source)"
+            pushd "${COOKBOOK_BUILD}" > /dev/null
             skip=0
             if [ "$(type -t recipe_stage)" = "function" ]
             then
-                recipe_stage ../stage
+                recipe_stage "$stage"
             fi
             if [ "$skip" -eq "0" ]
             then
-                #TODO xargo install --root "../stage" $CARGOFLAGS
+                #TODO "${CARGO[@]}" install --root "$stage" $CARGOFLAGS
                 if [ "$DEBUG" == 1 ]
                 then
                     build=debug
                 else
                     build=release
                 fi
+
                 bins="$(find target/$TARGET/$build/ -maxdepth 1 -type f ! -name '*.*')"
+                if [ -z "$bins" ] || [ "$EXAMPLES" == 1 ]
+                then
+                    example=true
+                    bins="$bins $(find target/$TARGET/$build/examples/ -maxdepth 1 -type f ! -name '*.*' ! -name '*-*' \
+                            2> /dev/null || true)"
+                fi
                 if [ -n "$bins" ]
                 then
-                    mkdir -p "../stage/$BINDIR"
+                    if [ -n "$example" ] && [ "$EXAMPLES" != 1 ]
+                    then
+                        echo "$(tput bold)Note$(tput sgr0): No binaries detected, using example binaries"
+                    fi
+                    mkdir -p "$stage/$BINDIR"
                     for bin in $bins
                     do
                         if [ "$DEBUG" == 1 ]
                         then
-                            cp -v "$bin" "../stage/$BINDIR/$(basename $bin)"
+                            cp -v "$bin" "$stage/$BINDIR/$(basename $bin)"
                         else
-                            strip -v "$bin" -o "../stage/$BINDIR/$(basename $bin)"
+                            "${STRIP}" -v "$bin" -o "$stage/$BINDIR/$(basename $bin)"
                         fi
                     done
+                else
+                    echo "$(tput bold)Warning$(tput sgr0): Recipe does not have any binaries" >&2
                 fi
             fi
             popd > /dev/null
             ;;
         unstage)
-            rm -rfv stage
+            rm -rfv "${COOKBOOK_STAGE}"
             ;;
-        tar)
-            echo "name = \"$1\"" > "stage.toml"
-            echo "version = \"$(op $1 version)\"" >> "stage.toml"
-            echo "target = \"$TARGET\"" >> "stage.toml"
+        pkg)
+            pkgar \
+                create \
+                --archive "${COOKBOOK_STAGE}.pkgar" \
+                --skey "${ROOT}/build/id_ed25519.toml" \
+                "${COOKBOOK_STAGE}"
+
+            # Generate stage.toml
+            echo "name = \"$1\"" > "${COOKBOOK_STAGE}.toml"
+            echo "version = \"$(op $1 version)\"" >> "${COOKBOOK_STAGE}.toml"
+            echo "target = \"$TARGET\"" >> "${COOKBOOK_STAGE}.toml"
 
             # Add runtime dependencies to package if they exist
             if [ -n "$DEPENDS" ]
@@ -373,26 +307,13 @@ function op {
                 # Remove leading and trailing whitespace, replace whitespace between
                 # package names with commas, and surround package names with quotes
                 dependencies=$(echo -e "$DEPENDS" | sed -E 's/^[[:space:]]*//;s/[[:space:]]*$//;s/[[:space:]]+/,/g;s/[^, ][^, ]*/"&"/g')
-                echo "depends = [$dependencies]" >> "stage.toml"
-			else
-				echo "depends = []" >> "stage.toml"
+                echo "depends = [$dependencies]" >> "${COOKBOOK_STAGE}.toml"
+            else
+                echo "depends = []" >> "${COOKBOOK_STAGE}.toml"
             fi
-
-            mkdir -p stage/pkg
-            cp -v stage.toml "stage/pkg/$1.toml"
-            pkg --target=$TARGET create stage
-            ;;
-        untar)
-            rm -rfv stage.tar.gz stage.sig stage.toml
             ;;
-        publish)
-            mkdir -p "$REPO"
-            cp -v stage.tar.gz "$REPO/$1.tar.gz"
-            cp -v stage.sig "$REPO/$1.sig"
-            cp -v stage.toml "$REPO/$1.toml"
-            ;;
-        unpublish)
-            rm -rfv "$REPO/$1.tar.gz" "$REPO/$1.sig" "$REPO/$1.toml"
+        unpkg)
+            rm -fv "${COOKBOOK_STAGE}.pkgar" "${COOKBOOK_STAGE}.toml"
             ;;
         *)
             usage $1
@@ -402,10 +323,36 @@ function op {
 
 if [ -n "$1" ]
 then
-    if [ -d "$ROOT/recipes/$1" ]
+    if (echo "$1" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$1")
+        recipe_path="recipes/$1"
+    else
+        recipe_name="$1"
+        recipe_path=`target/release/find_recipe $recipe_name`
+    fi
+
+    if [ -d "$ROOT/$recipe_path" ]
     then
-        cd "$ROOT/recipes/$1"
-        source recipe.sh
+        export COOKBOOK_RECIPE="${ROOT}/$recipe_path"
+
+        TARGET_DIR="${COOKBOOK_RECIPE}/target/${TARGET}"
+        mkdir -p "${TARGET_DIR}"
+
+        export COOKBOOK_BUILD="${TARGET_DIR}/build"
+        export COOKBOOK_STAGE="${TARGET_DIR}/stage"
+        export COOKBOOK_SOURCE="${COOKBOOK_RECIPE}/source"
+        export COOKBOOK_SYSROOT="${TARGET_DIR}/sysroot"
+
+        export PKG_CONFIG_ALLOW_CROSS=1
+        export PKG_CONFIG_PATH=
+        export PKG_CONFIG_LIBDIR="${COOKBOOK_SYSROOT}/lib/pkgconfig"
+        export PKG_CONFIG_SYSROOT_DIR="${COOKBOOK_SYSROOT}"
+
+        cd "${COOKBOOK_RECIPE}"
+
+        if [ -e recipe.sh ]; then
+            source recipe.sh
+        fi
 
         ops=()
         for arg in "${@:2}"
@@ -420,10 +367,10 @@ then
 
         for i in "${ops[@]}"
         do
-            op "$1" "$i"
+            op "$recipe_name" "$i"
         done
     else
-        echo "cook.sh: recipe '$1' not found" >&2
+        echo "cook.sh: recipe '$recipe_name' at not found" >&2
         exit 1
     fi
 else

fetch.sh

@@ -5,12 +5,25 @@ source config.sh
 
 if [ $# = 0 ]
 then
-    recipes="$(ls -1 recipes)"
+    recipes="$(target/release/list_recipes)"
 else
     recipes="$@"
 fi
 
-for recipe in $recipes
+for recipe_path in $recipes
 do
-    ./cook.sh "$recipe" fetch
+    if (echo "$recipe_path" | grep '.*/.*' >/dev/null); then
+        recipe_name=$(basename "$recipe_path")
+        recipe_path="recipes/$recipe_path"
+    else
+        recipe_name="$recipe_path"
+        recipe_path=`target/release/find_recipe $recipe_name`
+    fi
+
+    if [ -e "$recipe_path/recipe.toml" ]
+    then
+        target/release/cook --fetch-only "$recipe_name"
+    else
+        ./cook.sh "$recipe_name" fetch
+    fi
 done

libc-artifacts @ c67b055a

-Subproject commit c67b055af98c5f9d3afbe62479e8201f01f941cc

pkgar @ 0ccbc991

+Subproject commit 0ccbc9914b1ec655e23d4babc5afed87e42e9a0f