fix(rename): modify to use my forgejo instance.

Checks for ignored files that have been tracked by git.

.forgejo/workflows/build-image.yml

@@ -0,0 +1,44 @@
+on:
+  schedule:
+    - cron: '30 1 * * *'
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: docker
+    container:
+      image: ubuntu:latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: login to docker registry
+        uses: docker/login-action@v3
+        with:
+          registry: git.ragarock.moe
+          username: silvana
+          password: ${{ secrets.REGISTRY_TOKEN }}
+
+      - name: setup buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: build and push
+        uses: docker/build-push-action@v6
+        with:
+          push: true
+          tags: git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest
+
+      # - name: Clear image from cache
+      #   run: |
+      #     docker images git.ragarock.moe/${{ env.GITHUB_REPOSITORY }} -q | sort -u | xargs -r docker rmi --force
+      #     docker system prune --force --all
+
+      # - name: Build
+      #   run: docker build . -t git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest
+
+      # - name: Login
+      #   run: docker login git.ragarock.moe --username silvana --password ${{ secrets.FORGEJO_TOKEN_WRITE_PACKAGE }}
+
+      # - name: Publish
+      #   run: docker push git.ragarock.moe/${{ env.GITHUB_REPOSITORY }}:latest

.forgejo/workflows/push-next.yml

@@ -0,0 +1,45 @@
+on:
+  push:
+    branches:
+      - next
+jobs:
+  test:
+    runs-on: docker
+    container:
+      image: git.ragarock.moe/silvana/rust:latest
+    strategy:
+      matrix:
+        toolchain:
+          - name: stable
+          - name: nightly
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Ignored Files
+        run: check-for-ignored
+        # run: |
+        #   IGNORED=$(git ls-files --cached -i --exclude-standard)
+        #   if [ -n "$IGNORED" ]
+        #   then
+        #     echo "Ignored files present:\n$IGNORED"
+        #     exit 1
+        #   fi
+
+      - name: Machete
+        run: cargo machete
+
+      - name: Format
+        run: cargo +${{ matrix.toolchain.name }} fmt --check
+
+      - name: Clippy
+        run: cargo +${{ matrix.toolchain.name }} clippy
+
+      - name: Test
+        run: cargo +${{ matrix.toolchain.name }} test
+
+      - name: Build
+        run: cargo +${{ matrix.toolchain.name }} build
+
+      - name: Run
+        run: cargo +${{ matrix.toolchain.name }} run

.forgejo/workflows/test.yml

@@ -1,9 +0,0 @@
-on: [push]
-jobs:
-  test:
-    runs-on: docker
-    steps:
-      - name: Test Rust image
-        uses: https://git.kemitix.net/kemitix/rust@v0.1.0
-        with:
-          args: test

.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "rust"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+kxio = "5.1"
+tokio = { version = "1.43", features = ["full"] }

Dockerfile

@@ -1,26 +1,56 @@
-FROM docker.io/rust:1.78.0-slim-bookworm
+FROM docker.io/rust:1.84.0-alpine3.21
 
-# nodejs - runtime used by forgejo/github actions
+LABEL org.opencontainers.image.source=https://git.ragarock.moe/silvana/rust
-# curl - to download cargo-binstall
-# clang-16 & mold - faster linkers for rust
-RUN apt-get update && \
-  apt-get install -y \
-  --no-install-recommends \
-  nodejs \
-  curl=7.88.1-10+deb12u5 \
-  clang-16=1:16.0.6-15~deb12u1 \
-  mold=1.10.1+dfsg-1 && \
-  rm -r /var/lib/apt/lists/*
 
-RUN curl -L https://github.com/cargo-bins/cargo-binstall/releases/latest/download/cargo-binstall-x86_64-unknown-linux-musl.tgz -o cargo-binstall.tgz && \
+RUN apk add --no-cache curl=8.11.1-r0
+RUN curl -L https://github.com/cargo-bins/cargo-binstall/releases/download/v1.10.19/cargo-binstall-x86_64-unknown-linux-musl.tgz -o cargo-binstall.tgz && \
   tar -xzf cargo-binstall.tgz && \
   rm cargo-binstall.tgz && \
   mv cargo-binstall /usr/local/bin/
 
-RUN cargo binstall -y cargo-chef
+RUN cargo binstall -y \
+  cargo-chef@0.1 \
+  cargo-hack@0.6 \
+  cargo-machete@0.7 \
+  cargo-mutants@25.0 \
+  release-plz@0.3
 
-RUN rustup component add rustfmt clippy
+# should be a no-op if the FROM line is up-to-date
+RUN rustup update stable 
 
-COPY entrypoint.sh /
+RUN rustup component add --toolchain stable-x86_64-unknown-linux-musl rustfmt clippy
 
-ENTRYPOINT [ "/entrypoint.sh" ]
+# install nightly
+RUN rustup install nightly && rustup component add --toolchain nightly rustfmt clippy
+
+# nodejs - runtime used by forgejo/github actions
+# curl - to download cargo-binstall
+# clang & mold - faster linkers for rust
+# pkgconfig - required to compile some rust `-sys` packages
+# openssl-dev - build dependency for git-next
+# dbus-dev - linux os interop (e.g. desktop notifications)
+# perl - native-tls(vendored)
+# git - git
+RUN apk add --no-cache \
+  bash \
+  nodejs \
+  build-base \
+  pkgconfig \
+  libssl3 \
+  openssl-dev \
+  perl \
+  dbus-dev \
+  git
+
+  # clang \
+
+  # mold \
+
+  # dbus-dev \
+
+RUN git config --global user.email "holo@ragarock.moe" && \
+  git config --global user.name "ForgeJo Action. See: https://git.ragarock.moe/silvana/rust"
+
+COPY scripts/ /usr/local/bin/
+
+WORKDIR /app

README.md

@@ -11,41 +11,84 @@ on: [push]
 jobs:
   test:
     runs-on: docker
+    container:
+      image:
+        git.kemitix.net/kemitix/rust:v3.0.0
     steps:
-      - uses: https://git.kemitix.net/kemitix/rust@main
+      - name: test with nightly
-        with:
+        run: cargo +nightly test
-          args: test
+      - name: build with v1.74.1
-      - uses: https://git.kemitix.net/kemitix/rust@main
+        run: cargo +1.74.1 cargo build
-        with:
+      - name: test with stable
-          args: build
+        run: cargo test
-
 ```
 
+## Toolchains
+
+The available toolchain in the image are:
+
+- `nightly` 
+- stable
+- 1.74.1
+
 ## Contents
 
 - nodejs
-- clang-16
-- mold
 - rust
+- git
 - cargo
 - cargo-binstall
+- cargo-mutants
+- cargo-chef
+- cargo-hack
+- release-plz
+- dbus-dev
+- perl
 
-## Linking
+### Scripts
 
-To take advantage of the clang and mold packages, add the following to the `.cargo/config.toml` file in your project.
+- `check-for-ignored`
 
-```toml
+Checks for files that are being tracked by Git but should be ignored according
-[target.x86_64-unknown-linux-gnu]                                                
+to the `.gitignore` file.
-linker = "/usr/bin/clang-16"                                                     
+
-rustflags = ["-C", "link-arg=--ld-path=/usr/bin/mold"]
+#### Usage
+
+```yaml
+steps:
+  - name: Check for Ignored Files
+    run: check-for-ignored
 ```
 
-## Binary size
+## Caveats
 
-To reduce the size of the debug binary, add the following to the `.cargo/config.toml` file in you project.
+### openssl
+
+The alpine linux install doesn't build with this dependency. You can either compile `native-tls` with the `vendored` feature, or not use `openssl`.
+
+#### vendoered native-tls
+
+This crate *must* use the `vendored` feature in order to compile in the Alpine Linux image.
 
 ```toml
-[profile.dev]      
+native-tls = { version = "0.2", features = ["vendored"] }
-debug = 0          
+```
-strip = "debuginfo"
+
+#### Don't use `openssl`
+
+Check that none of your dependencies require `openssl`:
+
+```bash
+cargo tree --edges normal -i openssl
+```
+
+This will list the tree of dependencies that are bringing in `openssl`.
+
+If you do need ssl/tls, try using `rustls`.  e.g.
+
+```toml
+reqwest = { version = "0.12", default-features = false, features = [
+  "json",
+  "rustls-tls",
+] }
 ```

entrypoint.sh

@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-# set
-ls -l
-echo cargo ${INPUT_ARGS}

justfile

@@ -0,0 +1,19 @@
+image := "git.ragarock.moe/silvana/rust:test"
+
+build:
+  docker build . -t {{ image }}
+
+test: build
+  docker run --rm -v $PWD:/app/ {{ image }} cargo test
+
+clippy: build
+  docker run --rm -v $PWD:/app/ {{ image }} cargo clippy
+
+run: build
+  docker run --rm -v $PWD:/app/ {{ image }} cargo run
+
+fmt: build
+  docker run --rm -v $PWD:/app/ {{ image }} cargo fmt
+
+shell: build
+  docker run --rm -it -v $PWD:/app/ {{ image }} bash

mise.toml

@@ -0,0 +1,10 @@
+[tasks.test]
+description = "Test the image"
+run = [
+  "cargo machete",
+  "cargo fmt --check",
+  "cargo clippy",
+  "cargo test",
+  "cargo build",
+  "cargo run"
+]

renovate.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ]
+}

scripts/check-for-ignored

@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+
+# Exit on error
+set -e
+
+# Check if git is installed
+if ! command -v git &> /dev/null; then
+    echo "Error: git is not installed"
+    exit 1
+fi
+
+# Check if we're in a git repository
+if ! git rev-parse --is-inside-work-tree &> /dev/null; then
+    echo "Error: not in a git repository"
+    exit 1
+fi
+
+echo "Checking for tracked files that should be ignored..."
+
+# Find files that are both tracked and ignored
+ignored_files=$(git ls-files --cached -i --exclude-standard)
+
+if [[ -z "$ignored_files" ]]; then
+    echo "No tracked files are marked as ignored"
+    exit 0
+else
+    echo "The following tracked files are marked as ignored:"
+    echo "$ignored_files"
+    exit 1
+fi

src/kxio.rs

@@ -0,0 +1,105 @@
+/// This is an example to show fetching a file from a webiste and saving to a file
+///
+/// The example consts of:
+///
+/// - The main program, in `main()` - demonstrates how to setup `kxio` for use in prod
+/// - A test module - demonstrates how to use `kxio` in tests
+/// - sample functions - showing how to use `kxio` the body of your program, and be testable
+///
+/// NOTE: running this program with `cargo run --example get` will create and delete the file
+/// `example-readme.md` in the current directory.
+use std::path::Path;
+
+use kxio::fs::FileHandle;
+
+// #[tokio::main]
+pub async fn main() -> kxio::Result<()> {
+    // Create a `Net` object for making real network requests.
+    let net: kxio::net::Net = kxio::net::new();
+
+    // Create a `FileSystem` object for accessing files within the current directory.
+    // The object created will return a `PathTraveral` error result if there is an attempt to\
+    // access a file outside of this directory.
+    let current_dir = std::env::current_dir().map_err(kxio::fs::Error::Io)?;
+    let fs: kxio::fs::FileSystem = kxio::fs::new(current_dir);
+
+    // The URL we will fetch - the readme for this library.
+    let url = "https://git.kemitix.net/kemitix/kxio/raw/branch/main/README.md";
+
+    // Create a PathBuf to a file within the directory that the `fs` object has access to.
+    let file_path = fs.base().join("example-readme.md");
+
+    // Create a generic handle for the file. This doesn't open the file, and always succeeds.
+    let path = fs.path(&file_path);
+
+    // Other options are;
+    // `fs.file(&file_path)` - for a file
+    // `fs.dir(&dir_path)` - for a directory
+
+    // Checks if the path exists (whether a file, directory, etc)
+    if path.exists()? {
+        eprintln!("The file {path} already exists. Aborting!");
+        return Ok(());
+    }
+
+    // Passes a reference to the `fs` and `net` objects for use by your program.
+    // Your programs should not know whether they are handling a mock or the real thing.
+    // Any file or network access should be made using these handlers to be properly testable.
+    let file = download_and_save_to_file(url, &file_path, &fs, &net).await?;
+    read_file(&file)?;
+    delete_file(file)?;
+
+    Ok(())
+}
+
+/// An function that uses a `FileSystem` and a `Net` object to interact with the outside world.
+async fn download_and_save_to_file(
+    url: &str,
+    file_path: &Path,
+    // The filesystem abstraction
+    fs: &kxio::fs::FileSystem,
+    // The network abstraction
+    net: &kxio::net::Net,
+) -> kxio::Result<FileHandle> {
+    println!("fetching: {url}");
+
+    // Makes a GET request that can be mocked in a test
+    let response = net.get(url).header("key", "value").send().await?;
+
+    // As you can see, we use [reqwest] under the hood.
+    //
+    // If you need to create a more complex request than the [kxio] fluent API allows, you
+    // can create a request using [reqwest] and pass it to [net.send(request)].
+
+    let body = response.text().await?;
+    println!("fetched {} bytes", body.bytes().len());
+
+    // Uses the file system abstraction to create a handle for a file.
+    let file: kxio::fs::PathReal<kxio::fs::FileMarker> = fs.file(file_path);
+    println!("writing file: {file}");
+    // Writes the body to the file.
+    file.write(body)?;
+
+    Ok(file)
+}
+
+/// A function that reads the file contents
+fn read_file(file: &FileHandle) -> kxio::Result<()> {
+    println!("reading file: {file}");
+
+    // Creates a `Reader` which loaded the file into memory.
+    let reader: kxio::fs::Reader = file.reader()?;
+    let contents: &str = reader.as_str()?;
+    println!("{contents}");
+
+    Ok(())
+}
+
+/// A function that deletes the file
+fn delete_file(file: FileHandle) -> kxio::Result<()> {
+    println!("deleting file: {file}");
+
+    file.remove()?;
+
+    Ok(())
+}

src/main.rs

@@ -0,0 +1,17 @@
+//
+mod kxio;
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Hello, world!");
+
+    let rt = tokio::runtime::Runtime::new()?;
+    Ok(rt.block_on(crate::kxio::main())?)
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn passes() {
+        println!("passes okay");
+    }
+}