Debian 12-compatible minimum openssl crates

Crate `openssl-sys = 0.9.55` seems to look for OpenSSL v1.x, which is
not available to Debian 12. Pinning it up to 0.9.64 makes it match with
OpenSSL 3.x which *is* available.

HOWEVER! Building the crate on Debian 11 works just fine. Pinning the
dependencies this way is an error as I neither use them directly, nor
have any reason to depend on this specific version.

Cargo can't know about the distro version. Maybe I can use crate
features to select different openssl-sys crates? Further work required.

.gitea/workflows/release.yml

@@ -8,11 +8,6 @@ jobs:
     name: Compile and upload a release build
     steps:
       - uses: actions/checkout@v4
-      - name: Get Cargo version
-        run: echo "cargo_version=v$(grep "^version" Cargo.toml | cut -d \" -f2)" >> $GITHUB_ENV
-      - name: Abort if Cargo.toml & Git Tag versions don't match
-        if: ${{ env.cargo_version != github.ref_name }}
-        run: exit 1
       - name: Install Rust Stable
         uses: dtolnay/rust-toolchain@stable
       - name: Build binary crate

Cargo.toml

@@ -1,16 +1,28 @@
 [package]
 name = "gt-tool"
-version = "2.2.0"
+version = "1.0.0"
 edition = "2024"
 
 [dependencies]
 clap = { version = "4.0.7", features = ["derive", "env"] }
-colored = "2.0.0"
-itertools = "0.10.0"
 reqwest = { version = "0.11.13", features = ["json", "stream", "multipart"] }
 serde = { version = "1.0.152", features = ["derive"] }
 tokio = { version = "1.24.2", features = ["macros", "rt-multi-thread"] }
-toml = "0.5"
+
+# Grand-dependency Pins 	----
+# Fixes: Reqwest uses too-old version of crate `log`
+log = "0.4.6"
+
+# Debian 12 uses OpenSSL 3.x and older libssl-sys crates are angry about that
+
+# Fixes: native lib lookup.
+# Causes: missing item in crate `ffi`
+openssl-sys = "0.9.64" 
+
+# Fixes: missing item in crate `ffi` (from openssl-sys)
+openssl = "0.10.35"
+
+# End Grand-dependency Pins	----
 
 # Packages available in Debian (Sid)
 # clap = "4.5.23"

README.md

@@ -1,4 +1,4 @@
-# gt-tool
+# gt-tools
 
 CLI tools for interacting with the Gitea API. Use interactively to talk to your Gitea instance, or automatically via a CI/CD pipeline.
 

src/api/release.rs

@@ -1,9 +1,12 @@
+
 use crate::{
     Result,
-    structs::release::{CreateReleaseOption, Release},
+    structs::{
+        release::{CreateReleaseOption, Release},
+    },
 };
 
-pub fn get_release(_id: u64) -> Result<Release> {
+pub fn get_release(id: u64) -> Result<Release> {
     todo!();
 }
 pub fn get_latest_release() -> Result<Release> {
@@ -17,7 +20,7 @@ pub async fn list_releases(
 ) -> Result<Vec<Release>> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/");
     let req = client.get(request_url).send().await;
-    let response = req.map_err(crate::Error::WrappedReqwestErr)?;
+    let response = req.map_err(|reqwest_err| crate::Error::WrappedReqwestErr(reqwest_err))?;
     if response.status().is_success() {
         let release_list = response
             .json::<Vec<Release>>()
@@ -47,22 +50,22 @@ pub async fn create_release(
         .json(&submission)
         .send()
         .await
-        .map_err(crate::Error::from)?;
+        .map_err(|e| crate::Error::from(e))?;
     if response.status().is_success() {
         let new_release = response
             .json::<Release>()
             .await
-            .map_err(crate::Error::from)?;
+            .map_err(|e| crate::Error::from(e))?;
         return Ok(new_release);
     } else if response.status().is_client_error() {
         let mesg = crate::decode_client_error(response).await?;
-        return Err(crate::Error::ApiErrorMessage(mesg));
+        return Err(crate::Error::ApiErrorMessage(mesg))
     }
     panic!("Reached end of create_release without matching a return path");
 }
-pub fn edit_release(_id: u64) -> Result<Release> {
+pub fn edit_release(id: u64) -> Result<Release> {
     todo!();
 }
-pub fn delete_release(_id: u64) -> Result<()> {
+pub fn delete_release(id: u64) -> Result<()> {
     todo!();
 }

src/api/release_attachment.rs

@@ -22,10 +22,8 @@ pub async fn create_release_attachment(
         Ok(false) => return Err(crate::Error::NoSuchFile),
         Err(e) => {
             eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
-            panic!(
+            panic!("TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)");
-                "TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
+        },
-            );
-        }
     }
 
     println!("Uploading file {}", &file);
@@ -46,7 +44,7 @@ pub async fn create_release_attachment(
         let attachment_desc = response
             .json::<Attachment>()
             .await
-            .map_err(crate::Error::from)?;
+            .map_err(|e| crate::Error::from(e))?;
         return Ok(attachment_desc);
     } else if response.status().is_client_error() {
         let mesg = crate::decode_client_error(response).await?;

src/config.rs

@@ -1,424 +0,0 @@
-use std::path::PathBuf;
-
-use toml::{Value, value::Table};
-
-pub type Result<T> = core::result::Result<T, Error>;
-
-#[derive(Debug)]
-#[cfg_attr(test, derive(PartialEq))]
-pub enum Error {
-    BadFormat,
-    NoSuchProperty,
-    NoSuchTable,
-    CouldntReadFile,
-    TomlWrap(toml::de::Error),
-}
-
-impl From<toml::de::Error> for Error {
-    fn from(value: toml::de::Error) -> Self {
-        Error::TomlWrap(value)
-    }
-}
-
-impl core::fmt::Display for Error{
-	fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-		// FIXME: Print a nice output, don't just reuse the Debug impl
-		write!(fmt, "{self:?}")
-	}
-}
-
-impl std::error::Error for Error {}
-
-/// Creates an iterator of default (Linux) search paths. The iterator output
-/// is a list of files named "gt-tool.toml" found in decreasingly specific
-/// configuration folders.
-///
-/// - any dirs listed in env var `$XDG_CONFIG_DIRS` 
-/// - and the `/etc` dir
-///
-/// This is so that user-specific configs are used first, then machine-wide
-/// ones.
-pub fn default_paths() -> impl Iterator<Item = PathBuf> {
-    // Read env var `XDG_CONFIG_DIRS` and split on ":" to get highest-priority list
-    // TODO: Emit warning when paths aren't unicode
-    std::env::var("XDG_CONFIG_DIRS")
-        .unwrap_or(String::from(""))
-        .split(":")
-        // Set up the "/etc" list
-        //      Which is pretty silly, in this case.
-        //      Maybe a future version will scan nested folders and this will make
-        //      more sense.
-        // glue on the "/etc" path
-        .chain(["/etc"])
-        .map(|path_str| {
-            let mut path = PathBuf::from(path_str);
-            path.push("gt-tool.toml");
-            path
-        })
-        .collect::<Vec<_>>()
-        .into_iter()
-}
-
-/// Searches through the files, `search_files`, for configuration related to a
-/// project, `project`.
-/// 
-/// The project string is used as a map key and should match the real path of a
-/// project on disk. These are the table names for each config section.
-/// 
-/// The search files iterator must produce *files* not *folders.* For now,
-/// there is no mechanism to ensure correct usage. Files that can't be opened
-/// will quietly be skipped, so there will be no warning when one gives a
-/// folder.
-///
-/// Use `fn default_paths()` to get a reasonable (Linux) default.
-///
-/// TODO: Check for, and warn or error when given a dir.
-pub fn get_config (
-    project: &str,
-    search_files: impl Iterator<Item=PathBuf>
-) -> Result<PartialConfig> {
-    /*
-     1. Get conf search (from fn input)
-     2. Iterate config dirs
-     3. Try load toml::Value from file
-     4. Try-get proj-specific table
-     5. Try-get "[all]" table
-     6. (merge) Update `Option::None`s in proj-spec with `Some(_)`s from "[all]"
-     7. (merge, again) Fold the PartialConfigs into a finished one
-     */
-
-
-    let file_iter = search_files;
-
-    let toml_iter = file_iter
-        .map(std::fs::read_to_string)   // read text from file
-        .filter_map(|res| res.ok()) // remove any error messages
-        // TODO: Log warnings when files couldn't be read.
-        .map(|toml_text| toml_text.parse::<Value>())    // try convert to `toml::Value`
-        .filter_map(|res| res.ok()); // remove any failed parses
-    let config_iter = toml_iter
-        .map(|val| -> Result<PartialConfig> {
-            // Like `fn read_conf_str(...)`, but doesn't produce a `WholeFile`
-
-            // 1. Get the top-level table that is the config file
-            let cfg_table = val.as_table().ok_or(Error::BadFormat)?;
-
-            // 2. Get table
-            let maybe_proj = get_table(cfg_table, project)
-                // 3. convert to PartialConfig
-                .and_then(PartialConfig::try_from)
-                // 4. assemble a 2-tuple of PartialConfigs by...
-                .and_then(|proj| {
-                    Ok((
-                        // 4-1. Passing in the project-specific PartialConfig
-                        proj.project_path(project),
-                        // 4-2. Getting and converting to PartialConfig, or returning any Err() if one appears.
-                        get_table(cfg_table, "all").and_then(PartialConfig::try_from)?,
-                    ))
-                })
-                // 5. Merge the PartialConfigs together, project-specific has higher priority
-                .and_then(|pair| {
-                    Ok(pair.0.merge(pair.1))
-                });
-            maybe_proj
-        })
-        .filter_map(|res| res.ok())
-        .fold(PartialConfig::default(), |acc, inc|{
-            acc.merge(inc)
-        });
-    return Ok(config_iter);
-}
-
-#[derive(Debug, Default)]
-#[cfg_attr(test, derive(PartialEq))]
-pub struct PartialConfig {
-    project_path: Option<String>,
-    gitea_url: Option<String>,
-    owner: Option<String>,
-    repo: Option<String>,
-    token: Option<String>,
-}
-
-impl PartialConfig {
-    // One lonely builder-pattern function to set the project path.
-    // This is so I can do continuation style calls instead of a bunch of
-    // successive `let conf = ...` temporaries.
-    fn project_path(self, path: impl ToString) -> Self{
-        PartialConfig {
-            project_path: Some(path.to_string()),
-            ..self
-        }
-    }
-
-    // Merges two `PartialConfig`'s together, producing a new one.
-    // Non-None values on the right-hand side are used to replace values
-    // in the left-hand side, even if they are Some(_).
-    fn merge(self, other: Self) -> Self {
-        Self {
-            project_path: other.project_path.or(self.project_path),
-            gitea_url: other.gitea_url.or(self.gitea_url),
-            owner: other.owner.or(self.owner),
-            repo: other.repo.or(self.repo),
-            token: other.token.or(self.token),
-        }
-    }
-}
-
-impl TryFrom<&Table> for PartialConfig {
-    type Error = crate::config::Error;
-
-    fn try_from(value: &Table) -> Result<Self> {
-        Ok(Self {
-            // can't get table name because that key is gone by this point.
-            project_path: None,
-            gitea_url: get_maybe_property(&value, "gitea_url")?.cloned(),
-            owner: get_maybe_property(&value, "owner")?.cloned(),
-            repo: get_maybe_property(&value, "repo")?.cloned(),
-            token: get_maybe_property(&value, "token")?.cloned(),
-        })
-    }
-
-}
-
-#[derive(Debug, Default)]
-#[cfg_attr(test, derive(PartialEq))]
-struct WholeFile {
-    all: PartialConfig,
-    project_overrides: Vec<PartialConfig>,
-}
-
-fn load_from_file(path: &str) -> Result<WholeFile> {
-    let res = std::fs::read_to_string(path);
-    match res {
-        Ok(s) => read_conf_str(s.as_str()),
-        Err(e) => {
-            eprintln!("->> file io err: {:?}", e);
-            Err(Error::CouldntReadFile)
-        }
-    }
-}
-
-fn read_conf_str(text: &str) -> Result<WholeFile> {
-    let mut whole = WholeFile::default();
-
-    let toml_val = text.parse::<Value>()?;
-
-    // The config file is one big table. If the string we decoded is
-    // some other toml::Value variant, it's not correct.
-    // Try getting it as a table, return Err(BadFormat) otherwise.
-    let cfg_table = toml_val.as_table().ok_or(Error::BadFormat)?;
-
-    // Get the global config out of the file
-    let table_all = get_table(cfg_table, "all")?;
-    whole.all = PartialConfig::try_from(table_all)?;
-
-    // Loop over the per-project configs, if any.
-    let per_project_keys = cfg_table
-        .keys()
-        .filter(|s| { // Discard the "[all]" table
-            *s != "all"
-        });
-
-    for path in per_project_keys {
-        let tab = get_table(cfg_table, path)?;
-        let part_cfg = PartialConfig::try_from(tab)?
-            .project_path(path.clone());
-        whole.project_overrides.push(part_cfg);
-    }
-    Ok(whole)
-}
-
-/// The outer value must be a Table so we can get the sub-table from it.
-fn get_table<'outer>(outer: &'outer Table, table_name: impl ToString) -> Result<&'outer Table> {
-    Ok(outer
-        .get(&table_name.to_string())
-        .ok_or(Error::NoSuchTable)?
-        .as_table()
-        .ok_or(Error::BadFormat)?)
-}
-
-
-/// Similar to `get_property()` but maps the "Error::NoSuchProperty" result to
-/// Option::None. Some properties aren't specified, and that's okay... sometimes.
-fn get_maybe_property<'outer> (outer: &'outer Table, property: impl ToString) -> Result<Option<&'outer String>> {
-    let maybe_prop = get_property(outer, property);
-    match maybe_prop {
-        Ok(value) => Ok(Some(value)),
-        Err(e) => {
-            if let Error::NoSuchProperty = e {
-                return Ok(None);
-            } else {
-                return Err(e);
-            }
-        }
-    }
-}
-
-/// The config properties are individual strings. This gets the named property,
-/// or an error explaining why it couldn't be fetched.
-fn get_property<'outer>(outer: &'outer Table, property: impl ToString) -> Result<&'outer String> {
-    let maybe_prop = outer.get(&property.to_string()).ok_or(Error::NoSuchProperty)?;
-    if let Value::String(text) = maybe_prop {
-        Ok(text)
-    } else {
-        Err(Error::BadFormat)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use toml::map::Map;
-
-    use super::*;
-
-    // Util for generating a reference struct
-    fn gen_expected_struct() -> WholeFile {
-        WholeFile {
-            all: PartialConfig {
-                project_path: None,
-                gitea_url: Some(String::from("http://localhost:3000")),
-                owner: None,
-                repo: None,
-                token: Some(String::from("fake-token"))
-            },
-            project_overrides: vec![
-                PartialConfig {
-                    project_path: Some(String::from("/home/robert/projects/gt-tool")),
-                    gitea_url: None,
-                    owner: Some(String::from("robert")),
-                    repo: Some(String::from("gt-tool")),
-                    token: None,
-                },
-                PartialConfig {
-                    project_path: Some(String::from("/home/robert/projects/rcalc")),
-                    gitea_url: None,
-                    owner: Some(String::from("jamis")),
-                    repo: Some(String::from("rcalc")),
-                    token: None,
-                },
-                PartialConfig {
-                    project_path: Some(String::from("/home/robert/projects/rcalc-builders")),
-                    gitea_url: None,
-                    owner: Some(String::from("jamis")),
-                    repo: Some(String::from("rcalc")),
-                    token: None,
-                },
-            
-            ],
-        }
-    }
-
-    #[test]
-    fn read_single_prop() -> Result<()> {
-        let fx_input_str = "owner = \"dingus\"";
-        let fx_value = fx_input_str.parse::<Value>()?;
-        let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
-        let expected = "dingus";
-
-        let res = get_property(&fx_value, String::from("owner"))?;
-        assert_eq!(res, expected);
-        Ok(())
-    }
-
-    // The property is given the value of empty-string `""`
-    #[test]
-    fn read_single_prop_empty_quotes() -> Result<()> {
-        let fx_input_str = "owner = \"\"";
-        let fx_value = fx_input_str.parse::<Value>()?;
-        let fx_value = fx_value.as_table().ok_or(Error::NoSuchTable)?;
-        let expected = "";
-
-        let res = get_property(&fx_value, String::from("owner"))?;
-        assert_eq!(res, expected);
-        Ok(())
-    }
-
-    #[test]
-    fn read_table() -> Result<()> {
-        let fx_input_str = "[tab]\nwith_a_garbage = \"value\"";
-        let fx_value = fx_input_str.parse::<Value>()?;
-        let fx_value = fx_value.as_table().ok_or(Error::BadFormat)?;
-        let mut expected: Map<String, Value> = Map::new();
-        expected.insert(String::from("with_a_garbage"), Value::String(String::from("value")));
-
-        let res = get_table(&fx_value, String::from("tab"))?;
-        assert_eq!(res, &expected);
-        Ok(())
-    }
-
-    #[test]
-    fn read_config_string_ok() -> Result<()> {
-        let fx_sample_config_string = include_str!("../test_data/sample_config.toml");
-        let fx_expected_struct = gen_expected_struct();
-        let conf = read_conf_str(fx_sample_config_string)?;
-        
-        assert_eq!(conf, fx_expected_struct);
-        Ok(())
-    }
-
-    /* TODO: Improve semantics around reading an empty string
-    An empty config string will result in Error::NoSuchTable when "[all]"
-    is retrieved. But this will *also* happen when other configs are present,
-    but "[all]" isn't. Do I treat these as valid configurations, using some
-    hard-coded default as the fallback? Or do I reject configs that don't have
-    an all-table?
-     */
-    #[test]
-    fn read_config_string_empty() {
-        let fx_sample_cfg = "";
-        let conf = read_conf_str(fx_sample_cfg);
-        assert!(conf.is_err());
-    }
-
-    #[test]
-    // File exists and has valid configuration.
-    fn load_from_file_ok() -> Result<()> {
-        let conf = load_from_file("test_data/sample_config.toml")?;
-        assert_eq!(conf, gen_expected_struct());
-        Ok(())
-    }
-
-    #[test]
-    // File does not exist.
-    fn load_from_file_missing() -> Result<()> {
-        let res = load_from_file("test_data/doesnt_exist.toml");
-        let err = res.unwrap_err();
-        assert_eq!(err, Error::CouldntReadFile);
-        Ok(())
-    }
-
-    #[test]
-    // File exists but has garbage inside.
-    // TODO: This bumps against the same semantic issue as the todo note on
-    // the 'read_config_string_empty' test
-    fn load_from_file_bad() {
-        let res = load_from_file("test_data/missing_all_table.toml");
-        assert!(res.is_err());
-    }
-
-    #[test]
-    // FIXME: Allow user-specified search paths, then update test to use them.
-    // This test can only work if there's a config file the program can find.
-    // Right now, that means a file called "gt-tool.toml" in
-    // 1. `/etc`
-    // 2. anything inside `$XDG_CONFIG_DIRS`
-    fn check_get_config() -> Result<()>{
-        let search_paths = ["./test_data/sample_config.toml"]
-            .into_iter()
-            .map(PathBuf::from);
-        let load_result = get_config(
-            "/home/robert/projects/gt-tool",
-            search_paths
-        )?;
-        let expected = PartialConfig {
-            project_path: Some(String::from("/home/robert/projects/gt-tool")),
-            owner: Some(String::from("robert")),
-            repo: Some(String::from("gt-tool")),
-            gitea_url: Some(String::from("http://localhost:3000")),
-            token: Some(String::from("fake-token")),
-        };
-
-        assert_eq!(load_result, expected);
-        Ok(())
-    }
-}

src/lib.rs

@@ -2,7 +2,6 @@ use serde::{Deserialize, Serialize};
 
 pub mod api;
 pub mod cli;
-pub mod config;
 pub mod structs;
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -11,11 +10,13 @@ pub struct ApiError {
     url: String,
 }
 
-pub(crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
+pub (crate) async fn decode_client_error(response: reqwest::Response) -> Result<ApiError> {
     response
         .json::<ApiError>()
         .await
-        .map_err(crate::Error::WrappedReqwestErr)
+        .map_err(|reqwest_err| {
+            crate::Error::WrappedReqwestErr(reqwest_err)
+        })
 }
 
 #[derive(Debug)]

src/main.rs

@@ -1,3 +1,4 @@
+
 use std::path;
 
 use gt_tool::cli::Args;
@@ -21,7 +22,10 @@ async fn main() -> Result<(), gt_tool::Error> {
         headers.append("Authorization", token.parse().unwrap());
     }
     let client = reqwest::Client::builder()
-        .user_agent(format!("gt-tools-agent-{}", env!("CARGO_PKG_VERSION")))
+        .user_agent(format!(
+            "gt-tools-agent-{}",
+            env!("CARGO_PKG_VERSION")
+        ))
         .default_headers(headers)
         .build()?;
 
@@ -29,15 +33,9 @@ async fn main() -> Result<(), gt_tool::Error> {
         gt_tool::cli::Commands::ListReleases => {
             let releases =
                 gt_tool::api::release::list_releases(&client, &args.gitea_url, &args.repo).await?;
-            // Print in reverse order so the newest items are closest to the
+            for release in releases {
-            // user's command prompt. Otherwise the newest item scrolls off the
+                println!("{:?}", release);
-            // screen and can't be seen.
+            }
-            itertools::Itertools::intersperse(
-                releases.iter().rev().map(|release| release.colorized()),
-                String::from(""),
-            )
-            .map(|release| println!("{}", release))
-            .fold((), |_, _| ());
         }
         gt_tool::cli::Commands::CreateRelease {
             name,
@@ -54,7 +52,12 @@ async fn main() -> Result<(), gt_tool::Error> {
                 tag_name,
                 target_commitish,
             };
-            gt_tool::api::release::create_release(&client, &args.gitea_url, &args.repo, submission)
+            gt_tool::api::release::create_release(
+                &client,
+                &args.gitea_url,
+                &args.repo,
+                submission,
+            )
             .await?;
         }
         gt_tool::cli::Commands::UploadRelease {
@@ -85,10 +88,8 @@ async fn main() -> Result<(), gt_tool::Error> {
                         Ok(false) => return Err(gt_tool::Error::NoSuchFile),
                         Err(e) => {
                             eprintln!("Uh oh! The file-exists check couldn't be done: {e}");
-                            panic!(
+                            panic!("TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)");
-                                "TODO: Deal with scenario where the file's existence cannot be checked (e.g.: no permission)"
+                        },
-                            );
-                        }
                     }
                 }
                 for file in files {
@@ -142,5 +143,5 @@ fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release>
             }
         }
     }
-    release
+    return release;
 }

src/structs/release.rs

@@ -1,4 +1,3 @@
-use colored::Colorize;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -20,36 +19,6 @@ pub struct Release {
     author: Author,
 }
 
-impl Release {
-    pub fn colorized(&self) -> String {
-        let tag = "Tag:".green().bold();
-        let name = "Name:".green();
-        let published = "Published:".bright_green();
-        let created = "Created:".green().dimmed();
-        let author = "Author:".blue();
-        let body = if !self.body.is_empty() {
-            &self.body.white()
-        } else {
-            &String::from("(empty body)").dimmed()
-        };
-
-        format!(
-            "{tag} {}
-{name} {}
-  {}
-{published} {} ({created} {})
-{author} {} ({})",
-            self.tag_name.bold(),
-            self.name,
-            body,
-            self.published_at,
-            self.created_at.dimmed(),
-            self.author.login,
-            self.author.email,
-        )
-    }
-}
-
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Author {
     id: usize,

test_data/missing_all_table.toml

@@ -1,5 +0,0 @@
-# There must be an "[all]" table or the loader will reject the config file.
-
-["/some/other/path"]
-gitea_url = "fake-url"
-

test_data/sample_config.toml

@@ -1,15 +0,0 @@
-[all]
-gitea_url = "http://localhost:3000"
-token = "fake-token"
-
-["/home/robert/projects/gt-tool"]
-owner = "robert"
-repo = "gt-tool"
-
-["/home/robert/projects/rcalc"]
-owner = "jamis"
-repo = "rcalc"
-
-["/home/robert/projects/rcalc-builders"]
-owner = "jamis"
-repo = "rcalc"