"windows-targets",

]

[[package]]

name = "bindgen"

version = "0.69.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"

[[package]]

name = "byteorder"

version = "1.5.0"

"wasm-bindgen",

]

[[package]]

name = "kstring"

version = "2.0.2"

"uuid",

]

[[package]]

name = "nom"

version = "7.1.3"

"unarray",

]

[[package]]

name = "quanta"

version = "0.12.3"

"proc-macro2",

]

[[package]]

name = "rand"

version = "0.8.5"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"

[[package]]

name = "rgit"

version = "0.1.3"

"arc-swap",

"askama",

"axum",

"bytes",

"clap",

"comrak",

"httparse",

"humantime",

"itertools 0.13.0",

"md5",

"moka",

"path-clean",

"rand",

"rocksdb",

"rsass",

"rust-ini",

"yoke",

]

[[package]]

name = "rocksdb"

version = "0.22.0"

"tokio",

"http1",

] }

bytes = "1.5"

clap = { version = "4.4.10", default-features = false, features = [

"std",

httparse = "1.7"

humantime = "2.1"

itertools = "0.13.0"

md5 = "0.7"

moka = { version = "0.12.0", features = ["future"] }

path-clean = "1.0.1"

rand = "0.8.5"

rocksdb = { version = "0.22", default-features = false, features = ["snappy"] }

rust-ini = "0.21.1"

serde = { version = "1.0", features = ["derive", "rc"] }

use crate::database::schema::{

commit::Commit,

tag::{Tag, TagTree},

};

};

let id = match Repository::open(db, relative) {

Err(error) => {

// maybe we could nuke it ourselves, but we need to instantly trigger

// a reindex and we could enter into an infinite loop if there's a bug

}

};

continue;

};

let description = std::fs::read(repository.join("description")).unwrap_or_default();

let repository_path = scan_path.join(relative);

let res = Repository {

id,

description,

owner: find_gitweb_owner(repository_path.as_path()),

}

.insert(db, relative);

fn branch_index_update(

reference: &mut Reference<'_>,

relative_path: &str,

db: Arc<rocksdb::DB>,

git_repository: &gix::Repository,

force_reindex: bool,

let commit = reference.peel_to_commit()?;

let latest_indexed = if let Some(latest_indexed) = commit_tree.fetch_latest_one()? {

info!("No commits since last index");

return Ok(());

}

let rev = rev?;

if let (false, Some(latest_indexed)) = (seen, &latest_indexed) {

seen = true;

}

#[instrument(skip(db_repository, db, git_repository))]

fn tag_index_scan(

relative_path: &str,

db: Arc<rocksdb::DB>,

git_repository: &gix::Repository,

) -> Result<(), anyhow::Error> {

fn open_repo<P: AsRef<Path> + Debug>(

scan_path: &Path,

relative_path: P,

db: &rocksdb::DB,

) -> Option<gix::Repository> {

match gix::open(scan_path.join(relative_path.as_ref())) {

}

}

// Load the Git config file and attempt to extract the owner from the "gitweb" section.

// If the owner is not found, an empty string is returned.

Ini::load_from_file(repository_path.join("config"))

.ok()?

}

use anyhow::Context;

use rocksdb::{IteratorMode, ReadOptions, WriteBatch};

use time::{OffsetDateTime, UtcOffset};

use tracing::debug;

use yoke::{Yoke, Yokeable};

Yoked,

};

}

pub fn new(

commit: &gix::Commit<'_>,

) -> Result<Self, anyhow::Error> {

let message = commit.message()?;

Ok(Self {

committer: committer.try_into()?,

author: author.try_into()?,

})

}

}

}

}

}

}

type Error = anyhow::Error;

Ok(Self {

})

}

}

pub prefix: Box<[u8]>,

}

impl CommitTree {

pub(super) fn new(db: Arc<rocksdb::DB>, repository: RepositoryId, reference: &str) -> Self {

return Ok(0);

};

Ok(u64::from_be_bytes(out))

}

let cf = self

.db

.cf_handle(COMMIT_FAMILY)

let mut key = self.prefix.to_vec();

key.extend_from_slice(&id.to_be_bytes());

Ok(())

}

return Ok(None);

};

}

pub fn fetch_latest(

.iterator_cf_opt(cf, opts, IteratorMode::End)

.map(|v| {

Yoke::try_attach_to_cart(v.context("failed to read commit")?.1, |data| {

})

})

.collect::<Result<Vec<_>, anyhow::Error>>()

pub type Yoked<T> = Yoke<T, Box<[u8]>>;

use anyhow::{Context, Result};

use rand::random;

use rocksdb::IteratorMode;

use yoke::{Yoke, Yokeable};

use crate::database::schema::{

Yoked,

};

/// The ID of the repository, as stored in `RocksDB`

pub id: RepositoryId,

/// The "clean name" of the repository (ie. `hello-world.git`)

/// The description of the repository, as it is stored in the `description` file in the

/// bare repo root

/// The owner of the repository (`gitweb.owner` in the repository configuration)

/// The last time this repository was updated, currently read from the directory mtime

/// The default branch for Git operations

}

pub fn exists<P: AsRef<Path>>(database: &rocksdb::DB, path: P) -> Result<bool> {

let cf = database

.cf_handle(REPOSITORY_FAMILY)

.context("repository column family missing")?;

database

.filter_map(Result::ok)

.map(|(key, value)| {

let key = String::from_utf8(key.into_vec()).context("invalid repo name")?;

Ok((key, value))

})

.context("repository column family missing")?;

let path = path.as_ref().to_str().context("invalid path")?;

Ok(())

}

pub fn delete<P: AsRef<Path>>(&self, database: &rocksdb::DB, path: P) -> Result<()> {

*end_id.last_mut().unwrap() += 1;

// delete commits

Ok(())

}

pub fn commit_tree(&self, database: Arc<rocksdb::DB>, reference: &str) -> CommitTree {

}

pub fn tag_tree(&self, database: Arc<rocksdb::DB>) -> TagTree {

}

let cf = database

.cf_handle(REFERENCE_FAMILY)

.context("missing reference column family")?;

Ok(())

}

let cf = database

.cf_handle(REFERENCE_FAMILY)

.context("missing reference column family")?;

};

}

}

impl RepositoryId {

pub fn new() -> Self {

use anyhow::Context;

use gix::actor::SignatureRef;

use yoke::{Yoke, Yokeable};

use crate::database::schema::{

};

}

Ok(Self {

tagger: tagger.map(TryFrom::try_from).transpose()?,

})

prefix: RepositoryId,

}

impl TagTree {

pub(super) fn new(db: Arc<rocksdb::DB>, prefix: RepositoryId) -> Self {

Self { db, prefix }

}

let cf = self

.db

.cf_handle(TAG_FAMILY)

let mut db_name = self.prefix.to_be_bytes().to_vec();

db_name.extend_from_slice(name.as_ref());

Ok(())

}

Some((name, value))

})

.map(|(name, value)| {

Ok((name, value))

})

.collect::<anyhow::Result<Vec<(String, YokedTag)>>>()?;

res.sort_unstable_by(|a, b| {

b_tagger.cmp(&a_tagger)

});

pub struct CommitUser {

name: String,

email: String,

}

impl TryFrom<SignatureRef<'_>> for CommitUser {

Ok(CommitUser {

name: v.name.to_string(),

email: v.email.to_string(),

})

}

}

}

pub fn time(&self) -> OffsetDateTime {

}

}

use tower_http::{cors::CorsLayer, timeout::TimeoutLayer};

use tower_layer::layer_fn;

use tracing::{error, info, instrument, warn};

use xxhash_rust::const_xxh3;

use crate::{

std::env::set_var("RUST_LOG", "info");

}

let env_filter = EnvFilter::from_default_env();

tracing_subscriber::registry()

};

use arc_swap::ArcSwap;

(*s.borrow())

.format(&Rfc3339)

.map_err(Box::from)

.map_err(askama::Error::Custom)

}

Ok(timeago::Formatter::new()

}

pub fn file_perms(s: &u16) -> Result<String, askama::Error> {

Ok(url)

}

let fetched = tokio::task::spawn_blocking(move || Repository::fetch_all(&db))

.await

.context("Failed to join Tokio task")??;

for (k, v) in fetched {

// TODO: fixme

let mut split: Vec<_> = k.split('/').collect();

use anyhow::Context;

use askama::Template;

use axum::{response::IntoResponse, Extension};

use crate::{

into_response,

.context("Repository does not exist")?;

let mut heads = BTreeMap::new();

}

}

use anyhow::Context;

use askama::Template;

use axum::{response::IntoResponse, Extension};

use crate::{

database::schema::{commit::YokedCommit, repository::YokedRepository},

let commits = get_default_branch_commits(&repository, &db)?;

let mut heads = BTreeMap::new();

}

}

</td>

<td>

<a href="/{% if let Some(path) = path %}{{ path }}/{% endif %}{{ repository.name }}">

{{- description -}}

{%- else -%}

Unnamed repository; edit this file 'description' to name the repository.

</td>

<td>

<a href="/{% if let Some(path) = path %}{{ path }}/{% endif %}{{ repository.name }}">

{{- owner -}}

{%- endif -%}

</a>

<td>

<a href="/{% if let Some(path) = path %}{{ path }}/{% endif %}{{ repository.name }}">

<time datetime="{{ repository.last_modified|format_time }}" title="{{ repository.last_modified|format_time }}">

</time>

</a>

</td>

<td><a href="/{{ repo.display() }}/tag/?h={{ name }}">{{- name -}}</a></td>

<td><a href="/{{ repo.display() }}/snapshot?h={{ name }}">{{- name -}}.tar.gz</a></td>

<td>

<img src="{{ tagger.email|gravatar }}" width="13" height="13">

{{ tagger.name }}

{%- endif %}

</td>

<td>

<time datetime="{{ tagger.time|format_time }}" title="{{ tagger.time|format_time }}">

{{- tagger.time|timeago -}}

</time>

<tr>

<td>

<time datetime="{{ commit.committer.time|format_time }}" title="{{ commit.committer.time|format_time }}">

</time>

</td>

<td><a href="/{{ repo.display() }}/commit/?id={{ commit.hash|hex }}">{{ commit.summary }}</a></td>

}

}

fs::write(

prettyplease::unparse(

&syn::parse2(quote!(#(#grammar_defs)*)).context("failed to parse grammar defs")?,

),

let registry = build_grammar_registry(config.grammar.iter().map(|v| v.name.clone()));

fs::write(

prettyplease::unparse(&syn::parse2(registry).context("failed to parse grammar registry")?),

)

.context("failed to write grammar registry")?;

let language = build_language_registry(config.language)?;

fs::write(

prettyplease::unparse(&syn::parse2(language)?),

)?;

thread_local! {

static REGEX: ::std::cell::LazyCell<::regex::RegexSet> = ::std::cell::LazyCell::new(|| {

#(#injection_regex),*

])

.unwrap()

fn fetch_git_repository(url: &str, ref_: &str, destination: &Path) -> anyhow::Result<()> {

if !destination.exists() {

if !res.success() {

bail!("git init failed with exit code {res}");

}

let res = Command::new("git")

.status()?;

if !res.success() {

bail!("git remote failed with exit code {res}");

}

let res = Command::new("git")

.output()?

.stdout;

if res == ref_.as_bytes() {

}

let res = Command::new("git")

.status()?;

if !res.success() {

bail!("git fetch failed with exit code {res}");

}

let res = Command::new("git")

.status()?;

if !res.success() {

bail!("git fetch failed with exit code {res}");