mirror of
https://github.com/dexoron/dcr.git
synced 2026-10-21 17:19:37 +00:00
Added:
- Full Git dependency support in `dcr.toml`
- Support for `git`, `branch`, `tag`, and `rev` fields
- Automatic cloning and checkout via `git2`
- Dependencies are stored in `target/<profile>/deps/git/`
- New `dcr add` command for easy dependency management
- Short syntax: `github:user/repo`, `gitlab:user/repo`, `path:/to/lib`
- Automatic GitHub resolution for `git:user/repo`
- Visual feedback for dependency fetching with in-place status updates ("Fetching" → "Fetched")
- Modular dependency management architecture in `src/core/deps/`
This commit is contained in:
199
src/cli/add.rs
Normal file
199
src/cli/add.rs
Normal file
@@ -0,0 +1,199 @@
|
||||
use crate::core::config::Config;
|
||||
use crate::utils::fs::find_project_root;
|
||||
use crate::utils::log::error;
|
||||
use crate::utils::text::{BOLD_GREEN, colored};
|
||||
use toml::Value;
|
||||
use toml::map::Map;
|
||||
|
||||
pub struct AddArgs {
|
||||
pub name: String,
|
||||
pub path: Option<String>,
|
||||
pub git: Option<String>,
|
||||
pub branch: Option<String>,
|
||||
pub tag: Option<String>,
|
||||
pub rev: Option<String>,
|
||||
}
|
||||
|
||||
pub fn add(args: &[String]) -> i32 {
|
||||
let add_args = match parse_add_args(args) {
|
||||
Ok(a) => a,
|
||||
Err(code) => return code,
|
||||
};
|
||||
|
||||
let start_dir = match std::env::current_dir() {
|
||||
Ok(dir) => dir,
|
||||
Err(_) => {
|
||||
error("Failed to determine current directory");
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
let root = match find_project_root(&start_dir) {
|
||||
Ok(Some(dir)) => dir,
|
||||
Ok(None) => {
|
||||
error("dcr.toml file not found");
|
||||
return 1;
|
||||
}
|
||||
Err(_) => {
|
||||
error("Failed to find project root");
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
let mut config = match Config::open(&root.join("dcr.toml").to_string_lossy()) {
|
||||
Ok(cfg) => cfg,
|
||||
Err(err) => {
|
||||
error(&err.to_string());
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
let dep_value = if let Some(git_url) = add_args.git {
|
||||
if add_args.branch.is_none() && add_args.tag.is_none() && add_args.rev.is_none() {
|
||||
let mut table = Map::new();
|
||||
table.insert("git".to_string(), Value::String(git_url));
|
||||
Value::Table(table)
|
||||
} else {
|
||||
let mut table = Map::new();
|
||||
table.insert("git".to_string(), Value::String(git_url));
|
||||
if let Some(b) = add_args.branch {
|
||||
table.insert("branch".to_string(), Value::String(b));
|
||||
}
|
||||
if let Some(t) = add_args.tag {
|
||||
table.insert("tag".to_string(), Value::String(t));
|
||||
}
|
||||
if let Some(r) = add_args.rev {
|
||||
table.insert("rev".to_string(), Value::String(r));
|
||||
}
|
||||
Value::Table(table)
|
||||
}
|
||||
} else if let Some(path) = add_args.path {
|
||||
Value::String(path)
|
||||
} else {
|
||||
error("Dependency source (path or git) must be provided");
|
||||
return 1;
|
||||
};
|
||||
|
||||
let key = format!("dependencies.{}", add_args.name);
|
||||
if let Err(err) = config.edit(&key, dep_value) {
|
||||
error(&format!("Failed to update dcr.toml: {}", err));
|
||||
return 1;
|
||||
}
|
||||
|
||||
println!(
|
||||
" {} dependency `{}` to dcr.toml",
|
||||
colored("Added", BOLD_GREEN),
|
||||
add_args.name
|
||||
);
|
||||
0
|
||||
}
|
||||
|
||||
fn parse_add_args(args: &[String]) -> Result<AddArgs, i32> {
|
||||
if args.is_empty() {
|
||||
error("Usage: dcr add <name> <source> [--branch <branch> | --tag <tag> | --rev <rev>]");
|
||||
error("Sources:");
|
||||
error(" user/repo -> github.com/user/repo");
|
||||
error(" github:user/repo -> github.com/user/repo");
|
||||
error(" gitlab:user/repo -> gitlab.com/user/repo");
|
||||
error(" git:host.com/user/repo -> host.com/user/repo");
|
||||
error(" path:./path/to/lib -> local path");
|
||||
return Err(1);
|
||||
}
|
||||
|
||||
let mut name = String::new();
|
||||
let source_spec: String;
|
||||
let mut branch = None;
|
||||
let mut tag = None;
|
||||
let mut rev = None;
|
||||
|
||||
let mut iter = args.iter();
|
||||
if let Some(n) = iter.next() {
|
||||
if n.starts_with("--") {
|
||||
error("First argument must be the dependency name");
|
||||
return Err(1);
|
||||
}
|
||||
name = n.clone();
|
||||
}
|
||||
|
||||
if let Some(s) = iter.next() {
|
||||
if s.starts_with("--") {
|
||||
error("Second argument must be the dependency source");
|
||||
return Err(1);
|
||||
}
|
||||
source_spec = s.clone();
|
||||
} else {
|
||||
error("Dependency source is required");
|
||||
return Err(1);
|
||||
}
|
||||
|
||||
while let Some(arg) = iter.next() {
|
||||
match arg.as_str() {
|
||||
"--branch" => {
|
||||
branch = iter.next().cloned();
|
||||
if branch.is_none() {
|
||||
error("--branch requires a value");
|
||||
return Err(1);
|
||||
}
|
||||
}
|
||||
"--tag" => {
|
||||
tag = iter.next().cloned();
|
||||
if tag.is_none() {
|
||||
error("--tag requires a value");
|
||||
return Err(1);
|
||||
}
|
||||
}
|
||||
"--rev" => {
|
||||
rev = iter.next().cloned();
|
||||
if rev.is_none() {
|
||||
error("--rev requires a value");
|
||||
return Err(1);
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
error(&format!("Unknown argument: {}", arg));
|
||||
return Err(1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut path = None;
|
||||
let mut git = None;
|
||||
|
||||
if let Some(p) = source_spec.strip_prefix("path:") {
|
||||
path = Some(p.to_string());
|
||||
} else if let Some(g) = source_spec.strip_prefix("github:") {
|
||||
git = Some(format!("https://github.com/{}", g));
|
||||
} else if let Some(g) = source_spec.strip_prefix("gitlab:") {
|
||||
git = Some(format!("https://gitlab.com/{}", g));
|
||||
} else if let Some(g) = source_spec.strip_prefix("git:") {
|
||||
if g.contains('/') && !g.contains('.') {
|
||||
// git:user/repo -> default to github
|
||||
git = Some(format!("https://github.com/{}", g));
|
||||
} else {
|
||||
// git:host.com/user/repo
|
||||
let url = if g.starts_with("http") || g.starts_with("git@") {
|
||||
g.to_string()
|
||||
} else {
|
||||
format!("https://{}", g)
|
||||
};
|
||||
git = Some(url);
|
||||
}
|
||||
} else if source_spec.starts_with("http://")
|
||||
|| source_spec.starts_with("https://")
|
||||
|| source_spec.starts_with("git@")
|
||||
{
|
||||
git = Some(source_spec);
|
||||
} else {
|
||||
error("Source must have a prefix (path:, git:, github:, gitlab:) or be a full URL");
|
||||
return Err(1);
|
||||
}
|
||||
|
||||
Ok(AddArgs {
|
||||
name,
|
||||
path,
|
||||
git,
|
||||
branch,
|
||||
tag,
|
||||
rev,
|
||||
})
|
||||
}
|
||||
@@ -1,3 +1,4 @@
|
||||
pub mod add;
|
||||
pub mod build;
|
||||
pub mod clean;
|
||||
pub mod flag_update;
|
||||
|
||||
@@ -525,6 +525,18 @@ fn format_dep_value(value: &Value) -> String {
|
||||
if let Some(v) = tbl.get("path").and_then(|v| v.as_str()) {
|
||||
parts.push(format!("path = \"{v}\""));
|
||||
}
|
||||
if let Some(v) = tbl.get("git").and_then(|v| v.as_str()) {
|
||||
parts.push(format!("git = \"{v}\""));
|
||||
}
|
||||
if let Some(v) = tbl.get("branch").and_then(|v| v.as_str()) {
|
||||
parts.push(format!("branch = \"{v}\""));
|
||||
}
|
||||
if let Some(v) = tbl.get("tag").and_then(|v| v.as_str()) {
|
||||
parts.push(format!("tag = \"{v}\""));
|
||||
}
|
||||
if let Some(v) = tbl.get("rev").and_then(|v| v.as_str()) {
|
||||
parts.push(format!("rev = \"{v}\""));
|
||||
}
|
||||
if let Some(v) = tbl.get("system").and_then(|v| v.as_bool()) {
|
||||
parts.push(format!("system = {}", if v { "true" } else { "false" }));
|
||||
}
|
||||
|
||||
390
src/core/deps.rs
390
src/core/deps.rs
@@ -1,390 +0,0 @@
|
||||
use crate::core::config::Config;
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
use toml::Value;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DepSpec {
|
||||
pub name: String,
|
||||
pub path_raw: String,
|
||||
pub include_raw: Option<Vec<String>>,
|
||||
pub lib_raw: Option<Vec<String>>,
|
||||
pub libs_raw: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ResolvedDeps {
|
||||
pub include_dirs: Vec<String>,
|
||||
pub lib_dirs: Vec<String>,
|
||||
pub libs: Vec<String>,
|
||||
}
|
||||
|
||||
pub fn resolve_deps(
|
||||
config: &Config,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
project_root: &Path,
|
||||
) -> Result<ResolvedDeps, String> {
|
||||
let project_name = config
|
||||
.get("package.name")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let project_version = config
|
||||
.get("package.version")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let deps = parse_dependencies(config, profile, target)?;
|
||||
if deps.is_empty() {
|
||||
return Ok(ResolvedDeps {
|
||||
include_dirs: Vec::new(),
|
||||
lib_dirs: Vec::new(),
|
||||
libs: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
||||
let mut include_dirs = Vec::new();
|
||||
let mut lib_dirs = Vec::new();
|
||||
let mut libs = Vec::new();
|
||||
let mut lock_packages = Vec::new();
|
||||
|
||||
for dep in deps {
|
||||
let dep_path_raw = expand_profile(&dep.path_raw, profile);
|
||||
let dep_path = resolve_path(project_root, &dep_path_raw)?;
|
||||
if !dep_path.is_dir() {
|
||||
return Err(format!(
|
||||
"Dependency '{}' path is not a directory: {}",
|
||||
dep.name,
|
||||
dep_path.display()
|
||||
));
|
||||
}
|
||||
|
||||
let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"], profile)?;
|
||||
let lib = resolve_paths(
|
||||
&dep_path,
|
||||
dep.lib_raw.as_deref(),
|
||||
&["lib", "lib64"],
|
||||
profile,
|
||||
)?;
|
||||
let libs_list = dep
|
||||
.libs_raw
|
||||
.clone()
|
||||
.unwrap_or_else(|| vec![dep.name.clone()]);
|
||||
|
||||
if include.is_empty() || lib.is_empty() {
|
||||
return Err(format!(
|
||||
"Dependency '{}' missing include/lib dirs. Add include/lib in dcr.toml.",
|
||||
dep.name
|
||||
));
|
||||
}
|
||||
|
||||
include_dirs.extend(include.iter().map(|p| p.to_string_lossy().to_string()));
|
||||
lib_dirs.extend(lib.iter().map(|p| p.to_string_lossy().to_string()));
|
||||
libs.extend(libs_list.iter().cloned());
|
||||
|
||||
let dep_cache = project_root
|
||||
.join("target")
|
||||
.join(profile)
|
||||
.join("deps")
|
||||
.join(&dep.name);
|
||||
sync_dep_dir(&dep_path, &dep_cache)
|
||||
.map_err(|err| format!("Failed to sync dep {}: {err}", dep.name))?;
|
||||
|
||||
let dep_version = read_dep_version(&dep_path).unwrap_or_else(|| "0.0.0".to_string());
|
||||
let dep_checksum = compute_checksum(&dep_path)
|
||||
.map_err(|err| format!("Failed to hash dep {}: {err}", dep.name))?;
|
||||
lock_packages.push(DepLock {
|
||||
name: dep.name.clone(),
|
||||
version: dep_version,
|
||||
checksum: dep_checksum,
|
||||
source: format!("path+{}", dep.path_raw),
|
||||
});
|
||||
}
|
||||
|
||||
write_lock(
|
||||
project_root,
|
||||
&project_name,
|
||||
&project_version,
|
||||
&lock_packages,
|
||||
)?;
|
||||
|
||||
Ok(ResolvedDeps {
|
||||
include_dirs,
|
||||
lib_dirs,
|
||||
libs,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
struct DepLock {
|
||||
name: String,
|
||||
version: String,
|
||||
checksum: String,
|
||||
source: String,
|
||||
}
|
||||
|
||||
fn parse_dependencies(
|
||||
config: &Config,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Result<Vec<DepSpec>, String> {
|
||||
let mut deps_table = None;
|
||||
// Order: dependencies.target.profile, dependencies.profile.target, dependencies.target, dependencies.profile, dependencies
|
||||
let combinations = if let Some(t) = target {
|
||||
let normalized_t = crate::cli::build::normalize_target_os(t);
|
||||
vec![
|
||||
format!("dependencies.{}.{}", normalized_t, profile),
|
||||
format!("dependencies.{}.{}", profile, normalized_t),
|
||||
format!("dependencies.{}", normalized_t),
|
||||
format!("dependencies.{}", profile),
|
||||
"dependencies".to_string(),
|
||||
]
|
||||
} else {
|
||||
vec![
|
||||
format!("dependencies.{}", profile),
|
||||
"dependencies".to_string(),
|
||||
]
|
||||
};
|
||||
for key in combinations {
|
||||
if let Some(val) = config.get(&key).and_then(|v| v.as_table()) {
|
||||
deps_table = Some(val);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let deps_table = match deps_table {
|
||||
Some(t) => t,
|
||||
None => return Ok(Vec::new()),
|
||||
};
|
||||
let mut deps = Vec::new();
|
||||
for (name, value) in deps_table {
|
||||
match value {
|
||||
Value::Table(tbl) => {
|
||||
if tbl.get("system").and_then(|v| v.as_bool()).unwrap_or(false) {
|
||||
return Err(format!(
|
||||
"Dependency '{}' uses system=true, which is not supported yet",
|
||||
name
|
||||
));
|
||||
}
|
||||
let path = tbl
|
||||
.get("path")
|
||||
.and_then(|v| v.as_str())
|
||||
.ok_or_else(|| format!("Dependency '{}' missing path", name))?
|
||||
.to_string();
|
||||
let include = parse_string_list(tbl.get("include"), name, "include")?;
|
||||
let lib = parse_string_list(tbl.get("lib"), name, "lib")?;
|
||||
let libs = parse_string_list(tbl.get("libs"), name, "libs")?;
|
||||
deps.push(DepSpec {
|
||||
name: name.to_string(),
|
||||
path_raw: path,
|
||||
include_raw: include,
|
||||
lib_raw: lib,
|
||||
libs_raw: libs,
|
||||
});
|
||||
}
|
||||
_ => {
|
||||
return Err(format!(
|
||||
"Dependency '{}' must be a table with path/include/lib",
|
||||
name
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
deps.sort_by(|a, b| a.name.cmp(&b.name));
|
||||
Ok(deps)
|
||||
}
|
||||
|
||||
fn parse_string_list(
|
||||
value: Option<&Value>,
|
||||
dep_name: &str,
|
||||
key: &str,
|
||||
) -> Result<Option<Vec<String>>, String> {
|
||||
let Some(value) = value else { return Ok(None) };
|
||||
let list = value.as_array().ok_or_else(|| {
|
||||
format!(
|
||||
"Dependency '{}' field '{}' must be an array of strings",
|
||||
dep_name, key
|
||||
)
|
||||
})?;
|
||||
let mut out = Vec::new();
|
||||
for item in list {
|
||||
let s = item
|
||||
.as_str()
|
||||
.ok_or_else(|| format!("Dependency '{}' field '{}' must be strings", dep_name, key))?;
|
||||
out.push(s.to_string());
|
||||
}
|
||||
Ok(Some(out))
|
||||
}
|
||||
|
||||
fn resolve_path(project_root: &Path, raw: &str) -> Result<PathBuf, String> {
|
||||
let p = Path::new(raw);
|
||||
let full = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
project_root.join(p)
|
||||
};
|
||||
Ok(full)
|
||||
}
|
||||
|
||||
fn resolve_paths(
|
||||
base: &Path,
|
||||
raw: Option<&[String]>,
|
||||
defaults: &[&str],
|
||||
profile: &str,
|
||||
) -> Result<Vec<PathBuf>, String> {
|
||||
let mut out = Vec::new();
|
||||
if let Some(raw) = raw {
|
||||
for r in raw {
|
||||
let expanded = expand_profile(r, profile);
|
||||
let p = Path::new(&expanded);
|
||||
let full = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
base.join(p)
|
||||
};
|
||||
if !full.exists() {
|
||||
return Err(format!("Path does not exist: {}", full.display()));
|
||||
}
|
||||
out.push(full);
|
||||
}
|
||||
return Ok(out);
|
||||
}
|
||||
|
||||
for d in defaults {
|
||||
let candidate = base.join(d);
|
||||
if candidate.exists() {
|
||||
out.push(candidate);
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn expand_profile(raw: &str, profile: &str) -> String {
|
||||
raw.replace("{profile}", profile)
|
||||
}
|
||||
|
||||
fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> {
|
||||
if dst.exists() {
|
||||
fs::remove_dir_all(dst)?;
|
||||
}
|
||||
copy_dir_all(src, dst)
|
||||
}
|
||||
|
||||
fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
|
||||
fs::create_dir_all(dst)?;
|
||||
for entry in fs::read_dir(src)? {
|
||||
let entry = entry?;
|
||||
let ty = entry.file_type()?;
|
||||
let from = entry.path();
|
||||
let to = dst.join(entry.file_name());
|
||||
if ty.is_dir() {
|
||||
copy_dir_all(&from, &to)?;
|
||||
} else {
|
||||
fs::copy(&from, &to)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_lock(
|
||||
project_root: &Path,
|
||||
project_name: &str,
|
||||
project_version: &str,
|
||||
packages: &[DepLock],
|
||||
) -> Result<(), String> {
|
||||
let mut out = String::new();
|
||||
if !packages.is_empty() {
|
||||
out.push_str("[[package]]\n");
|
||||
out.push_str(&format!("name = \"{}\"\n", escape_value(project_name)));
|
||||
out.push_str(&format!(
|
||||
"version = \"{}\"\n",
|
||||
escape_value(project_version)
|
||||
));
|
||||
out.push_str(&format!(
|
||||
"dependencies = [{}]\n\n",
|
||||
quote_list(&packages.iter().map(|p| p.name.clone()).collect::<Vec<_>>())
|
||||
));
|
||||
}
|
||||
for pkg in packages {
|
||||
out.push_str("[[package]]\n");
|
||||
out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name)));
|
||||
out.push_str(&format!("version = \"{}\"\n", escape_value(&pkg.version)));
|
||||
out.push_str(&format!("source = \"{}\"\n", escape_value(&pkg.source)));
|
||||
out.push_str(&format!("checksum = \"{}\"\n", escape_value(&pkg.checksum)));
|
||||
out.push('\n');
|
||||
}
|
||||
fs::write(project_root.join("dcr.lock"), out)
|
||||
.map_err(|err| format!("Failed to write dcr.lock: {err}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn quote_list(items: &[String]) -> String {
|
||||
items
|
||||
.iter()
|
||||
.map(|s| format!("\"{}\"", escape_value(s)))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ")
|
||||
}
|
||||
|
||||
fn escape_value(input: &str) -> String {
|
||||
input.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
fn read_dep_version(dep_path: &Path) -> Option<String> {
|
||||
let path = dep_path.join("dcr.toml");
|
||||
let content = fs::read_to_string(path).ok()?;
|
||||
let value: Value = content.parse().ok()?;
|
||||
value
|
||||
.get("package")
|
||||
.and_then(|v| v.as_table())
|
||||
.and_then(|t| t.get("version"))
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_string())
|
||||
}
|
||||
|
||||
fn compute_checksum(root: &Path) -> Result<String, String> {
|
||||
let mut files = Vec::new();
|
||||
collect_files(root, root, &mut files)?;
|
||||
files.sort();
|
||||
let mut hasher = Sha256::new();
|
||||
for rel in files {
|
||||
hasher.update(rel.as_bytes());
|
||||
let data =
|
||||
fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?;
|
||||
hasher.update(&data);
|
||||
}
|
||||
let hash = hasher.finalize();
|
||||
Ok(to_hex(&hash))
|
||||
}
|
||||
|
||||
fn collect_files(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
|
||||
for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? {
|
||||
let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?;
|
||||
let path = entry.path();
|
||||
let name = entry.file_name();
|
||||
let name_str = name.to_string_lossy();
|
||||
if name_str == "target" {
|
||||
continue;
|
||||
}
|
||||
if path.is_dir() {
|
||||
collect_files(root, &path, out)?;
|
||||
} else if path.is_file() {
|
||||
let rel = path
|
||||
.strip_prefix(root)
|
||||
.unwrap_or(&path)
|
||||
.to_string_lossy()
|
||||
.to_string();
|
||||
out.push(rel);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn to_hex(bytes: &[u8]) -> String {
|
||||
let mut out = String::with_capacity(bytes.len() * 2);
|
||||
for b in bytes {
|
||||
out.push_str(&format!("{:02x}", b));
|
||||
}
|
||||
out
|
||||
}
|
||||
99
src/core/deps/common.rs
Normal file
99
src/core/deps/common.rs
Normal file
@@ -0,0 +1,99 @@
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum DepSource {
|
||||
Path(String),
|
||||
Git {
|
||||
url: String,
|
||||
branch: Option<String>,
|
||||
tag: Option<String>,
|
||||
rev: Option<String>,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DepSpec {
|
||||
pub name: String,
|
||||
pub source: DepSource,
|
||||
pub include_raw: Option<Vec<String>>,
|
||||
pub lib_raw: Option<Vec<String>>,
|
||||
pub libs_raw: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ResolvedDeps {
|
||||
pub include_dirs: Vec<String>,
|
||||
pub lib_dirs: Vec<String>,
|
||||
pub libs: Vec<String>,
|
||||
}
|
||||
|
||||
pub fn resolve_path(project_root: &Path, raw: &str) -> Result<PathBuf, String> {
|
||||
let p = Path::new(raw);
|
||||
let full = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
project_root.join(p)
|
||||
};
|
||||
Ok(full)
|
||||
}
|
||||
|
||||
pub fn resolve_paths(
|
||||
base: &Path,
|
||||
raw: Option<&[String]>,
|
||||
defaults: &[&str],
|
||||
profile: &str,
|
||||
) -> Result<Vec<PathBuf>, String> {
|
||||
let mut out = Vec::new();
|
||||
if let Some(raw) = raw {
|
||||
for r in raw {
|
||||
let expanded = expand_profile(r, profile);
|
||||
let p = Path::new(&expanded);
|
||||
let full = if p.is_absolute() {
|
||||
p.to_path_buf()
|
||||
} else {
|
||||
base.join(p)
|
||||
};
|
||||
if !full.exists() {
|
||||
return Err(format!("Path does not exist: {}", full.display()));
|
||||
}
|
||||
out.push(full);
|
||||
}
|
||||
return Ok(out);
|
||||
}
|
||||
|
||||
for d in defaults {
|
||||
let candidate = base.join(d);
|
||||
if candidate.exists() {
|
||||
out.push(candidate);
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
pub fn expand_profile(raw: &str, profile: &str) -> String {
|
||||
raw.replace("{profile}", profile)
|
||||
}
|
||||
|
||||
pub fn sync_dep_dir(src: &Path, dst: &Path) -> std::io::Result<()> {
|
||||
if dst.exists() {
|
||||
fs::remove_dir_all(dst)?;
|
||||
}
|
||||
copy_dir_all(src, dst)
|
||||
}
|
||||
|
||||
pub fn copy_dir_all(src: &Path, dst: &Path) -> std::io::Result<()> {
|
||||
fs::create_dir_all(dst)?;
|
||||
for entry in fs::read_dir(src)? {
|
||||
let entry = entry?;
|
||||
let ty = entry.file_type()?;
|
||||
let from = entry.path();
|
||||
let to = dst.join(entry.file_name());
|
||||
if ty.is_dir() {
|
||||
copy_dir_all(&from, &to)?;
|
||||
} else {
|
||||
fs::copy(&from, &to)?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
52
src/core/deps/git.rs
Normal file
52
src/core/deps/git.rs
Normal file
@@ -0,0 +1,52 @@
|
||||
use std::path::Path;
|
||||
|
||||
pub fn fetch_git_dep(
|
||||
url: &str,
|
||||
target_dir: &Path,
|
||||
branch: Option<&str>,
|
||||
tag: Option<&str>,
|
||||
rev: Option<&str>,
|
||||
) -> Result<(), String> {
|
||||
if target_dir.exists() {
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let mut builder = git2::build::RepoBuilder::new();
|
||||
if let Some(b) = branch {
|
||||
builder.branch(b);
|
||||
}
|
||||
|
||||
let repo = builder
|
||||
.clone(url, target_dir)
|
||||
.map_err(|e| format!("failed to clone {}: {}", url, e))?;
|
||||
|
||||
if let Some(t) = tag {
|
||||
checkout_ref(&repo, &format!("refs/tags/{}", t))?;
|
||||
} else if let Some(r) = rev {
|
||||
checkout_ref(&repo, r)?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn checkout_ref(repo: &git2::Repository, reference_str: &str) -> Result<(), String> {
|
||||
let (object, reference) = repo
|
||||
.revparse_ext(reference_str)
|
||||
.map_err(|e| format!("failed to find ref {}: {}", reference_str, e))?;
|
||||
|
||||
repo.checkout_tree(&object, None).map_err(|e| {
|
||||
let ref_name = reference.as_ref().and_then(|r| r.name()).unwrap_or("HEAD");
|
||||
format!("failed to checkout {}: {}", ref_name, e)
|
||||
})?;
|
||||
|
||||
match reference {
|
||||
Some(gref) => {
|
||||
let ref_name = gref.name().unwrap_or("HEAD");
|
||||
repo.set_head(ref_name)
|
||||
}
|
||||
None => repo.set_head_detached(object.id()),
|
||||
}
|
||||
.map_err(|e| format!("failed to set HEAD: {}", e))?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
114
src/core/deps/lock.rs
Normal file
114
src/core/deps/lock.rs
Normal file
@@ -0,0 +1,114 @@
|
||||
use sha2::{Digest, Sha256};
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use toml::Value;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct DepLock {
|
||||
pub name: String,
|
||||
pub version: String,
|
||||
pub checksum: String,
|
||||
pub source: String,
|
||||
}
|
||||
|
||||
pub fn write_lock(
|
||||
project_root: &Path,
|
||||
project_name: &str,
|
||||
project_version: &str,
|
||||
packages: &[DepLock],
|
||||
) -> Result<(), String> {
|
||||
let mut out = String::new();
|
||||
if !packages.is_empty() {
|
||||
out.push_str("[[package]]\n");
|
||||
out.push_str(&format!("name = \"{}\"\n", escape_value(project_name)));
|
||||
out.push_str(&format!(
|
||||
"version = \"{}\"\n",
|
||||
escape_value(project_version)
|
||||
));
|
||||
out.push_str(&format!(
|
||||
"dependencies = [{}]\n\n",
|
||||
quote_list(&packages.iter().map(|p| p.name.clone()).collect::<Vec<_>>())
|
||||
));
|
||||
}
|
||||
for pkg in packages {
|
||||
out.push_str("[[package]]\n");
|
||||
out.push_str(&format!("name = \"{}\"\n", escape_value(&pkg.name)));
|
||||
out.push_str(&format!("version = \"{}\"\n", escape_value(&pkg.version)));
|
||||
out.push_str(&format!("source = \"{}\"\n", escape_value(&pkg.source)));
|
||||
out.push_str(&format!("checksum = \"{}\"\n", escape_value(&pkg.checksum)));
|
||||
out.push('\n');
|
||||
}
|
||||
fs::write(project_root.join("dcr.lock"), out)
|
||||
.map_err(|err| format!("Failed to write dcr.lock: {err}"))?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn quote_list(items: &[String]) -> String {
|
||||
items
|
||||
.iter()
|
||||
.map(|s| format!("\"{}\"", escape_value(s)))
|
||||
.collect::<Vec<_>>()
|
||||
.join(", ")
|
||||
}
|
||||
|
||||
fn escape_value(input: &str) -> String {
|
||||
input.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
pub fn read_dep_version(dep_path: &Path) -> Option<String> {
|
||||
let path = dep_path.join("dcr.toml");
|
||||
let content = fs::read_to_string(path).ok()?;
|
||||
let value: Value = content.parse().ok()?;
|
||||
value
|
||||
.get("package")
|
||||
.and_then(|v| v.as_table())
|
||||
.and_then(|t| t.get("version"))
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_string())
|
||||
}
|
||||
|
||||
pub fn compute_checksum(root: &Path) -> Result<String, String> {
|
||||
let mut files = Vec::new();
|
||||
collect_files(root, root, &mut files)?;
|
||||
files.sort();
|
||||
let mut hasher = Sha256::new();
|
||||
for rel in files {
|
||||
hasher.update(rel.as_bytes());
|
||||
let data =
|
||||
fs::read(root.join(&rel)).map_err(|err| format!("failed to read {}: {err}", rel))?;
|
||||
hasher.update(&data);
|
||||
}
|
||||
let hash = hasher.finalize();
|
||||
Ok(to_hex(&hash))
|
||||
}
|
||||
|
||||
fn collect_files(root: &Path, dir: &Path, out: &mut Vec<String>) -> Result<(), String> {
|
||||
for entry in fs::read_dir(dir).map_err(|err| format!("read_dir failed: {err}"))? {
|
||||
let entry = entry.map_err(|err| format!("read_dir failed: {err}"))?;
|
||||
let path = entry.path();
|
||||
let name = entry.file_name();
|
||||
let name_str = name.to_string_lossy();
|
||||
if name_str == "target" {
|
||||
continue;
|
||||
}
|
||||
if path.is_dir() {
|
||||
collect_files(root, &path, out)?;
|
||||
} else if path.is_file() {
|
||||
let rel = path
|
||||
.strip_prefix(root)
|
||||
.unwrap_or(&path)
|
||||
.to_string_lossy()
|
||||
.to_string();
|
||||
out.push(rel);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn to_hex(bytes: &[u8]) -> String {
|
||||
let mut out = String::with_capacity(bytes.len() * 2);
|
||||
for b in bytes {
|
||||
out.push_str(&format!("{:02x}", b));
|
||||
}
|
||||
out
|
||||
}
|
||||
286
src/core/deps/mod.rs
Normal file
286
src/core/deps/mod.rs
Normal file
@@ -0,0 +1,286 @@
|
||||
pub mod common;
|
||||
pub mod git;
|
||||
pub mod lock;
|
||||
|
||||
use crate::core::config::Config;
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
use toml::Value;
|
||||
|
||||
pub use common::{DepSource, DepSpec, ResolvedDeps};
|
||||
use common::{expand_profile, resolve_path, resolve_paths, sync_dep_dir};
|
||||
use git::fetch_git_dep;
|
||||
use lock::{DepLock, compute_checksum, read_dep_version, write_lock};
|
||||
|
||||
pub fn resolve_deps(
|
||||
config: &Config,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
project_root: &Path,
|
||||
) -> Result<ResolvedDeps, String> {
|
||||
let project_name = config
|
||||
.get("package.name")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let project_version = config
|
||||
.get("package.version")
|
||||
.and_then(|v| v.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
let deps = parse_dependencies(config, profile, target)?;
|
||||
if deps.is_empty() {
|
||||
return Ok(ResolvedDeps {
|
||||
include_dirs: Vec::new(),
|
||||
lib_dirs: Vec::new(),
|
||||
libs: Vec::new(),
|
||||
});
|
||||
}
|
||||
|
||||
let mut include_dirs = Vec::new();
|
||||
let mut lib_dirs = Vec::new();
|
||||
let mut libs = Vec::new();
|
||||
let mut lock_packages = Vec::new();
|
||||
|
||||
for dep in deps {
|
||||
let (dep_path, is_git) = match &dep.source {
|
||||
DepSource::Path(path_raw) => {
|
||||
let expanded = expand_profile(path_raw, profile);
|
||||
(resolve_path(project_root, &expanded)?, false)
|
||||
}
|
||||
DepSource::Git {
|
||||
url,
|
||||
branch,
|
||||
tag,
|
||||
rev,
|
||||
} => {
|
||||
let git_deps_dir = project_root
|
||||
.join("target")
|
||||
.join(profile)
|
||||
.join("deps")
|
||||
.join("git");
|
||||
fs::create_dir_all(&git_deps_dir)
|
||||
.map_err(|e| format!("failed to create target/{}/deps/git: {}", profile, e))?;
|
||||
let dep_dir = git_deps_dir.join(&dep.name);
|
||||
if !dep_dir.exists() {
|
||||
use crate::utils::text::{BOLD_GREEN, colored};
|
||||
use std::io::{self, Write};
|
||||
print!(
|
||||
" {} dependency `{}` from {}...",
|
||||
colored("Fetching", BOLD_GREEN),
|
||||
dep.name,
|
||||
url
|
||||
);
|
||||
io::stdout().flush().ok();
|
||||
|
||||
fetch_git_dep(
|
||||
url,
|
||||
&dep_dir,
|
||||
branch.as_deref(),
|
||||
tag.as_deref(),
|
||||
rev.as_deref(),
|
||||
)?;
|
||||
|
||||
print!(
|
||||
"\r\x1B[2K {} dependency `{}`\n",
|
||||
colored("Fetched", BOLD_GREEN),
|
||||
dep.name
|
||||
);
|
||||
io::stdout().flush().ok();
|
||||
} else {
|
||||
fetch_git_dep(
|
||||
url,
|
||||
&dep_dir,
|
||||
branch.as_deref(),
|
||||
tag.as_deref(),
|
||||
rev.as_deref(),
|
||||
)?;
|
||||
}
|
||||
(dep_dir, true)
|
||||
}
|
||||
};
|
||||
|
||||
if !dep_path.is_dir() {
|
||||
return Err(format!(
|
||||
"Dependency '{}' path is not a directory: {}",
|
||||
dep.name,
|
||||
dep_path.display()
|
||||
));
|
||||
}
|
||||
|
||||
let include = resolve_paths(&dep_path, dep.include_raw.as_deref(), &["include"], profile)?;
|
||||
let lib = resolve_paths(
|
||||
&dep_path,
|
||||
dep.lib_raw.as_deref(),
|
||||
&["lib", "lib64"],
|
||||
profile,
|
||||
)?;
|
||||
let libs_list = dep
|
||||
.libs_raw
|
||||
.clone()
|
||||
.unwrap_or_else(|| vec![dep.name.clone()]);
|
||||
|
||||
if include.is_empty() || lib.is_empty() {
|
||||
return Err(format!(
|
||||
"Dependency '{}' missing include/lib dirs. Add include/lib in dcr.toml.",
|
||||
dep.name
|
||||
));
|
||||
}
|
||||
|
||||
include_dirs.extend(include.iter().map(|p| p.to_string_lossy().to_string()));
|
||||
lib_dirs.extend(lib.iter().map(|p| p.to_string_lossy().to_string()));
|
||||
libs.extend(libs_list.iter().cloned());
|
||||
|
||||
if !is_git {
|
||||
let dep_cache = project_root
|
||||
.join("target")
|
||||
.join(profile)
|
||||
.join("deps")
|
||||
.join(&dep.name);
|
||||
sync_dep_dir(&dep_path, &dep_cache)
|
||||
.map_err(|err| format!("Failed to sync dep {}: {err}", dep.name))?;
|
||||
}
|
||||
|
||||
let dep_version = read_dep_version(&dep_path).unwrap_or_else(|| "0.0.0".to_string());
|
||||
let dep_checksum = compute_checksum(&dep_path)
|
||||
.map_err(|err| format!("Failed to hash dep {}: {err}", dep.name))?;
|
||||
let source_str = match &dep.source {
|
||||
DepSource::Path(p) => format!("path+{}", p),
|
||||
DepSource::Git { url, .. } => format!("git+{}", url),
|
||||
};
|
||||
lock_packages.push(DepLock {
|
||||
name: dep.name.clone(),
|
||||
version: dep_version,
|
||||
checksum: dep_checksum,
|
||||
source: source_str,
|
||||
});
|
||||
}
|
||||
|
||||
write_lock(
|
||||
project_root,
|
||||
&project_name,
|
||||
&project_version,
|
||||
&lock_packages,
|
||||
)?;
|
||||
|
||||
Ok(ResolvedDeps {
|
||||
include_dirs,
|
||||
lib_dirs,
|
||||
libs,
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_dependencies(
|
||||
config: &Config,
|
||||
profile: &str,
|
||||
target: Option<&str>,
|
||||
) -> Result<Vec<DepSpec>, String> {
|
||||
let mut deps_table = None;
|
||||
let combinations = if let Some(t) = target {
|
||||
let normalized_t = crate::cli::build::normalize_target_os(t);
|
||||
vec![
|
||||
format!("dependencies.{}.{}", normalized_t, profile),
|
||||
format!("dependencies.{}.{}", profile, normalized_t),
|
||||
format!("dependencies.{}", normalized_t),
|
||||
format!("dependencies.{}", profile),
|
||||
"dependencies".to_string(),
|
||||
]
|
||||
} else {
|
||||
vec![
|
||||
format!("dependencies.{}", profile),
|
||||
"dependencies".to_string(),
|
||||
]
|
||||
};
|
||||
for key in combinations {
|
||||
if let Some(val) = config.get(&key).and_then(|v| v.as_table()) {
|
||||
deps_table = Some(val);
|
||||
break;
|
||||
}
|
||||
}
|
||||
let deps_table = match deps_table {
|
||||
Some(t) => t,
|
||||
None => return Ok(Vec::new()),
|
||||
};
|
||||
let mut deps = Vec::new();
|
||||
for (name, value) in deps_table {
|
||||
match value {
|
||||
Value::String(path) => {
|
||||
deps.push(DepSpec {
|
||||
name: name.to_string(),
|
||||
source: DepSource::Path(path.to_string()),
|
||||
include_raw: None,
|
||||
lib_raw: None,
|
||||
libs_raw: None,
|
||||
});
|
||||
}
|
||||
Value::Table(tbl) => {
|
||||
if tbl.get("system").and_then(|v| v.as_bool()).unwrap_or(false) {
|
||||
return Err(format!(
|
||||
"Dependency '{}' uses system=true, which is not supported yet",
|
||||
name
|
||||
));
|
||||
}
|
||||
|
||||
let source = if let Some(git_url) = tbl.get("git").and_then(|v| v.as_str()) {
|
||||
DepSource::Git {
|
||||
url: git_url.to_string(),
|
||||
branch: tbl
|
||||
.get("branch")
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_string()),
|
||||
tag: tbl
|
||||
.get("tag")
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_string()),
|
||||
rev: tbl
|
||||
.get("rev")
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_string()),
|
||||
}
|
||||
} else if let Some(path) = tbl.get("path").and_then(|v| v.as_str()) {
|
||||
DepSource::Path(path.to_string())
|
||||
} else {
|
||||
return Err(format!("Dependency '{}' missing path or git", name));
|
||||
};
|
||||
|
||||
let include = parse_string_list(tbl.get("include"), name, "include")?;
|
||||
let lib = parse_string_list(tbl.get("lib"), name, "lib")?;
|
||||
let libs = parse_string_list(tbl.get("libs"), name, "libs")?;
|
||||
deps.push(DepSpec {
|
||||
name: name.to_string(),
|
||||
source,
|
||||
include_raw: include,
|
||||
lib_raw: lib,
|
||||
libs_raw: libs,
|
||||
});
|
||||
}
|
||||
_ => {
|
||||
return Err(format!("Dependency '{}' must be a string or a table", name));
|
||||
}
|
||||
}
|
||||
}
|
||||
deps.sort_by(|a, b| a.name.cmp(&b.name));
|
||||
Ok(deps)
|
||||
}
|
||||
|
||||
fn parse_string_list(
|
||||
value: Option<&Value>,
|
||||
dep_name: &str,
|
||||
key: &str,
|
||||
) -> Result<Option<Vec<String>>, String> {
|
||||
let Some(value) = value else { return Ok(None) };
|
||||
let list = value.as_array().ok_or_else(|| {
|
||||
format!(
|
||||
"Dependency '{}' field '{}' must be an array of strings",
|
||||
dep_name, key
|
||||
)
|
||||
})?;
|
||||
let mut out = Vec::new();
|
||||
for item in list {
|
||||
let s = item
|
||||
.as_str()
|
||||
.ok_or_else(|| format!("Dependency '{}' field '{}' must be strings", dep_name, key))?;
|
||||
out.push(s.to_string());
|
||||
}
|
||||
Ok(Some(out))
|
||||
}
|
||||
@@ -18,6 +18,7 @@ fn main() {
|
||||
let code = match cmd {
|
||||
"new" => cli::r#new::new(rest),
|
||||
"init" => cli::init::init(rest),
|
||||
"add" => cli::add::add(rest),
|
||||
"build" => cli::build::build(rest),
|
||||
"run" => cli::run::run(rest),
|
||||
"test" | "tests" => cli::test::test(rest),
|
||||
|
||||
Reference in New Issue
Block a user