,
+
+ #[serde(skip)]
+ path: PathBuf,
}
-#[derive(Serialize, Deserialize, Debug)]
+impl BeefProj {
+ pub fn new(name: String, path: &P) -> BeefProj
+ where
+ P: AsRef,
+ {
+ let startup_object = format!("{}.Program", name);
+
+ Self {
+ file_version: 1,
+ dependencies: Default::default(),
+ project: Project {
+ name,
+ target_type: String::from("BeefConsoleApplication"),
+ startup_object,
+ ..Default::default()
+ },
+ other: Default::default(),
+ path: path.as_ref().to_path_buf(),
+ }
+ }
+
+ pub fn from_file(path: &P) -> Result
+ where
+ P: AsRef,
+ {
+ let mut proj: Self = toml::from_str(&fs::read_to_string(&path)?).with_context(|| {
+ format!("Failed to read project file '{}'", path.as_ref().display())
+ })?;
+ proj.path = path.as_ref().to_path_buf();
+ Ok(proj)
+ }
+
+ pub fn save(&self) -> Result<()> {
+ fs::write(&self.path, toml::to_string(&self)?)
+ .with_context(|| format!("Failed to write project file: '{}'", self.path.display()))
+ }
+
+ pub fn path(&mut self, path: &P) -> &mut Self
+ where
+ P: AsRef,
+ {
+ self.path = path.as_ref().to_path_buf();
+ self
+ }
+}
+
+#[derive(Serialize, Deserialize, Debug, Default)]
#[serde(rename_all = "PascalCase")]
pub struct Project {
pub name: String,
+ #[serde(default)]
+ pub target_type: String,
+ #[serde(default)]
+ pub startup_object: String,
+ #[serde(default)]
+ pub processor_macros: HashSet,
#[serde(flatten)]
pub other: HashMap,
diff --git a/src/commands.rs b/src/commands.rs
index e458d0e..01fbaaa 100644
--- a/src/commands.rs
+++ b/src/commands.rs
@@ -1,8 +1,9 @@
+pub mod init;
pub mod install;
pub mod list;
pub mod login;
pub mod make;
+pub mod new;
pub mod publish;
pub mod purge;
-pub mod remove;
-pub mod update_index;
+pub mod update;
diff --git a/src/commands/init.rs b/src/commands/init.rs
new file mode 100644
index 0000000..1af6773
--- /dev/null
+++ b/src/commands/init.rs
@@ -0,0 +1,30 @@
+use std::{fs, path::Path};
+
+use crate::{beef::BeefProj, prelude::*};
+
+pub fn cli() -> App {
+ App::new("init")
+ .about("Initialize an existing beef workspace with grill")
+ .arg(
+ Arg::new("path")
+ .long("path")
+ .value_name("PATH")
+ .default_value("."),
+ )
+}
+
+pub fn exec(args: &ArgMatches) -> Result<()> {
+ let path = Path::new(args.value_of("path").unwrap());
+ let proj_path = path.join("BeefProj.toml");
+ let name = if proj_path.exists() {
+ BeefProj::from_file(&proj_path)?.project.name
+ } else {
+ fs::canonicalize(std::env::current_dir()?.join(path))?
+ .file_name()
+ .context("Invalid filename")?
+ .to_string_lossy()
+ .to_string()
+ };
+
+ crate::ops::init::init(path, &name)
+}
diff --git a/src/commands/install.rs b/src/commands/install.rs
index c4e2b54..5235e32 100644
--- a/src/commands/install.rs
+++ b/src/commands/install.rs
@@ -49,7 +49,7 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
let cli_progress = ProgressBar::new(1)
.with_style(
ProgressStyle::default_bar()
- .template("{prefix:>12.bright.green} {msg} [{bar:40}]")
+ .template("{prefix:>12.bright.green} {msg} [{bar:40}]")?
.progress_chars("=> "),
)
.with_prefix("Installing")
@@ -86,11 +86,11 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
let mut pkg = url.host().ok_or(anyhow!("No host in url"))?.to_string();
pkg.push_str(&url.path().replace("/", "-").replace(".git", ""));
- let manifest_path = paths::tmp().join(crate::paths::PACKAGE_FILE);
+ let manifest_path = paths::tmp().join(crate::paths::MANIFEST_FILENAME);
let mut already_installed_prompt =
"This package is already installed, do you want to update it?".to_owned();
let has_manifest = if let Ok(file) = fs::read_to_string(manifest_path) {
- let manifest: Manifest = toml::from_str(&file)?;
+ let manifest = Manifest::from_file(&file)?;
pkg = manifest.package.name;
let pkg_path = paths::beeflib(&pkg);
diff --git a/src/commands/list.rs b/src/commands/list.rs
index eab8481..31896ad 100644
--- a/src/commands/list.rs
+++ b/src/commands/list.rs
@@ -14,7 +14,7 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
let dir = if args.is_present("themes") {
paths::themes()
} else {
- paths::pkgs()
+ paths::pkgs(".")
};
for entry in fs::read_dir(dir)? {
diff --git a/src/commands/make.rs b/src/commands/make.rs
index 9bda203..647a299 100644
--- a/src/commands/make.rs
+++ b/src/commands/make.rs
@@ -4,7 +4,7 @@ use crate::prelude::*;
pub fn cli() -> App {
App::new("make")
- .about("Installs the neccessary dependencies and makes a workspace")
+ .about("Install the neccessary dependencies and make a workspace")
.arg(
Arg::new("path")
.long("path")
@@ -13,9 +13,25 @@ pub fn cli() -> App {
.help("Path to the workspace"),
)
.arg(Arg::new("quiet").long("quiet").short('q'))
+ .arg(
+ Arg::new("fix-pkg")
+ .long("fix")
+ .value_name("PACKAGE")
+ .help("Run make for an installed package")
+ .conflicts_with("path"),
+ )
}
pub fn exec(args: &ArgMatches) -> Result<()> {
- let path = PathBuf::from(args.value_of("path").unwrap());
- crate::ops::make(&path, args.is_present("quiet"))
+ if let Some(pkg) = args.value_of("fix-pkg") {
+ let pkg_path = crate::paths::pkg(args.value_of("path").unwrap(), pkg);
+ if !pkg_path.exists() {
+ bail!("Package '{}' is not installed. Did you include the right version? I.e. Dummy-1.2.3", pkg)
+ }
+ log::debug!("Fixing {}", pkg);
+ crate::ops::install::prepare_pkg(&pkg_path, None)
+ } else {
+ let path = PathBuf::from(args.value_of("path").unwrap());
+ crate::ops::make(&path, args.is_present("quiet"))
+ }
}
diff --git a/src/commands/new.rs b/src/commands/new.rs
new file mode 100644
index 0000000..1d2a1c6
--- /dev/null
+++ b/src/commands/new.rs
@@ -0,0 +1,69 @@
+use std::{fs, path::Path};
+
+use crate::{beef::BeefProj, prelude::*};
+
+pub fn cli() -> App {
+ App::new("new")
+ .about("Create a new workspace and project")
+ .arg(Arg::new("path").value_name("PATH").default_value("."))
+ .arg(
+ Arg::new("lib")
+ .long("lib")
+ .help("Set project to be a library"),
+ )
+ .arg(
+ Arg::new("gui")
+ .long("gui")
+ .help("Set project to be a GUI application"),
+ )
+}
+
+pub fn exec(args: &ArgMatches) -> Result<()> {
+ let path = Path::new(args.value_of("path").unwrap());
+ if !path.exists() {
+ fs::create_dir(path)?;
+ }
+
+ let name = fs::canonicalize(std::env::current_dir()?.join(path))?
+ .file_name()
+ .context("Invalid filename")?
+ .to_string_lossy()
+ .to_string();
+
+ fs::create_dir(path.join("src"))?;
+ fs::write(
+ path.join("src").join("Program.bf"),
+ format!(
+ "\
+using System;
+
+namespace {}
+{{
+ class Program
+ {{
+ public static int Main(String[] args)
+ {{
+ return 0;
+ }}
+ }}
+}}
+ ",
+ name
+ ),
+ )?;
+
+ crate::ops::init::init(&path, &name)?;
+ crate::ops::make::make(&path, false)?;
+
+ if args.is_present("lib") {
+ let mut proj = BeefProj::from_file(&path.join("BeefProj.toml"))?;
+ proj.project.target_type = String::from("BeefLib");
+ proj.save()?;
+ } else if args.is_present("gui") {
+ let mut proj = BeefProj::from_file(&path.join("BeefProj.toml"))?;
+ proj.project.target_type = String::from("BeefGUIApplication");
+ proj.save()?;
+ }
+
+ Ok(())
+}
diff --git a/src/commands/publish.rs b/src/commands/publish.rs
index 3a8b4e7..1edf9f3 100644
--- a/src/commands/publish.rs
+++ b/src/commands/publish.rs
@@ -1,15 +1,21 @@
-use std::fs;
+use std::{collections::HashMap, fs};
use console::style;
use dialoguer::{theme::ColorfulTheme, Confirm, Select};
use git2::{Oid, Repository};
+use semver::VersionReq;
use serde_json::json;
-use crate::{index, manifest::Manifest, paths, prelude::*};
+use crate::{
+ index,
+ manifest::{self, Manifest},
+ paths,
+ prelude::*,
+};
pub fn cli() -> App {
App::new("publish")
- .about("Publishes the current package version")
+ .about("Publish the current package version")
.arg(
Arg::new("rev")
.short('r')
@@ -18,12 +24,18 @@ pub fn cli() -> App {
}
pub fn exec(args: &ArgMatches) -> Result<()> {
- let access_token = fs::read_to_string(paths::token())?;
- let manifest = Manifest::from_pkg("./")?;
- let package = manifest.package.name;
+ let token_path = paths::token();
+ if !token_path.exists() {
+ log::info!("You have to log in to use this command. Run `grill login` first.");
+ return Ok(());
+ }
+
+ let access_token = fs::read_to_string(token_path)?;
+ let manifest = Manifest::from_pkg(".")?;
+ let package = manifest.package.name.clone();
let version = manifest.package.version.to_string();
- let repo = Repository::open(".")?;
+ let repo = Repository::open(".").context("Failed to open repository")?;
let commit = if let Some(rev) = args.value_of("rev") {
let commit = repo
.find_commit(Oid::from_str(rev)?)
@@ -37,35 +49,76 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
};
let rev = commit.id().to_string();
+ let is_dirty = repo
+ .describe(git2::DescribeOptions::new().describe_all())?
+ .format(Some(
+ git2::DescribeFormatOptions::new().dirty_suffix("-dirty"),
+ ))?
+ .ends_with("-dirty");
+
println!("{:>12} {}", style("Package").bright().yellow(), package);
println!("{:>12} {}", style("Version").bright().yellow(), version);
println!("{:>12} {}", style("Commit").bright().yellow(), style(&rev));
+
+ if is_dirty {
+ print!("{:>12}", style("(dirty)").bright().red());
+ } else {
+ print!("{:>12}", "");
+ }
+
if let Some(msg) = commit.message() {
println!(
- "{:>14} {} {}",
+ " {} {} {}",
style('"').italic(),
msg.trim(),
style('"').italic(),
);
+ } else {
+ println!();
}
println!();
+ let prompt = if is_dirty {
+ "You have uncommitted changes. Do you still want to continue?"
+ } else {
+ "Publish?"
+ };
+
if Confirm::with_theme(&ColorfulTheme::default())
- .with_prompt("Continue?")
+ .with_prompt(prompt)
.interact()?
{
println!();
index::update(true, true)?;
let index = index::parse(false, false)?;
+
+ let mut deps: HashMap = manifest
+ .simple_deps()
+ .map(|(k, v)| (k.clone(), v.clone()))
+ .collect();
+
+ for (_, feature) in manifest.features.optional.iter() {
+ if let manifest::Feature::Project(path) = feature {
+ let feature_manifest = Manifest::from_pkg(&path)?;
+ deps.extend(
+ feature_manifest
+ .simple_deps()
+ .map(|(k, v)| (k.clone(), v.clone())),
+ );
+ }
+ }
+
let mut body = json!({
"access_token": access_token,
"package": package.clone(),
"metadata": json!({
"version": version.clone(),
"revision": rev,
- "dependencies": manifest.dependencies
+ "dependencies": deps,
+ "description": manifest.package.description
})
});
+
if !index.contains_key(&package) {
let remote_urls: Vec = repo
.remotes()?
@@ -91,10 +144,7 @@ pub fn exec(args: &ArgMatches) -> Result<()> {
);
}
- let res = reqwest::blocking::Client::new()
- .post("http://grillpm.vercel.app/api/publish")
- .json(&body)
- .send()?;
+ let res = crate::web::api("publish", &body)?;
if let Err(err) = res.error_for_status_ref() {
let body = res
diff --git a/src/commands/purge.rs b/src/commands/purge.rs
index 9a2d228..d52fa70 100644
--- a/src/commands/purge.rs
+++ b/src/commands/purge.rs
@@ -3,17 +3,34 @@ use std::fs;
use crate::prelude::*;
pub fn cli() -> App {
- App::new("purge").about("Deletes all installed packages")
+ App::new("purge").about("Delete all installed packages")
}
pub fn exec(_: &ArgMatches) -> Result<()> {
- let path = crate::paths::pkgs();
+ let path = crate::paths::pkgs(".");
let count = fs::read_dir(&path)?.count();
+
+ if count == 0 {
+ println!("No packages in cache");
+ return Ok(());
+ }
+
+ if !dialoguer::Confirm::new()
+ .with_prompt(format!(
+ "Are you sure you want to delete {} packages?",
+ count
+ ))
+ .interact()?
+ {
+ return Ok(());
+ }
+
rm_rf::remove(&path)?;
println!(
"{:>12} {} packages",
console::style("Deleted").bright().red(),
count
);
+
Ok(())
}
diff --git a/src/commands/remove.rs b/src/commands/remove.rs
deleted file mode 100644
index aa5f181..0000000
--- a/src/commands/remove.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use crate::{paths, prelude::*};
-
-pub fn cli() -> App {
- App::new("remove")
- .about("Remove a package")
- .arg(Arg::new("pkg").required(true))
-}
-
-pub fn exec(args: &ArgMatches) -> Result<()> {
- let pkg = args.value_of("pkg").unwrap();
- let path = paths::pkg(pkg);
- rm_rf::ensure_removed(path)?;
- Ok(())
-}
diff --git a/src/commands/update.rs b/src/commands/update.rs
new file mode 100644
index 0000000..c87c8f9
--- /dev/null
+++ b/src/commands/update.rs
@@ -0,0 +1,119 @@
+use std::path::Path;
+
+use crate::{
+ index,
+ lock::{self, Lock},
+ prelude::*,
+};
+use console::style;
+
+pub fn cli() -> App {
+ App::new("update")
+ .about("Update dependencies to the latest version")
+ .arg(Arg::new("quiet").long("quiet").short('q'))
+ // .arg(
+ // Arg::new("grill")
+ // .long("grill")
+ // .help("not yet implemented")
+ // .conflicts_with("index"),
+ // )
+ .arg(
+ Arg::new("index")
+ .long("index")
+ .help("Update the package index")
+ .conflicts_with("grill"),
+ )
+}
+
+pub fn exec(args: &ArgMatches) -> Result<()> {
+ if args.is_present("grill") {
+ todo!()
+ } else if args.is_present("index") {
+ index::update(!args.is_present("quiet"), false)
+ } else {
+ index::update(!args.is_present("quiet"), false)?;
+
+ let lock_path = Path::new(".").join(crate::paths::LOCK_FILENAME);
+ let old_lock = if lock_path.exists() {
+ Some(lock::read(lock_path)?)
+ } else {
+ None
+ };
+
+ let lock = lock::generate(Path::new("."), true, false)?;
+
+ if !args.is_present("quiet") {
+ if let Some(old_lock) = old_lock {
+ print_altered_deps(&old_lock, &lock);
+ } else {
+ for (dep, versions) in lock {
+ for version in versions {
+ println!(
+ "{:>12} {} v{}",
+ style("Added").bright().cyan(),
+ dep,
+ version
+ );
+ }
+ }
+ }
+ }
+
+ Ok(())
+ }
+}
+
+fn print_altered_deps(old_lock: &Lock, new_lock: &Lock) {
+ for (dep, versions) in new_lock {
+ for version in versions {
+ if old_lock.get(dep).map_or(true, |old_versions| {
+ !old_versions.iter().any(|v| v.major == version.major)
+ }) {
+ println!(
+ "{:>12} {} v{}",
+ style("Added").bright().cyan(),
+ dep,
+ version
+ );
+ }
+ }
+ }
+
+ for (dep, new_versions) in new_lock {
+ for new_version in new_versions {
+ if let Some(old_version) = old_lock.get(dep).and_then(|old_versions| {
+ if let Some(old_version) = old_versions
+ .iter()
+ .find(|&v| v.major == new_version.major && v != new_version)
+ {
+ Some(old_version)
+ } else {
+ None
+ }
+ }) {
+ println!(
+ "{:>12} {} v{} -> v{}",
+ style("Updated").bright().green(),
+ dep,
+ old_version,
+ new_version
+ );
+ }
+ }
+ }
+
+ for (dep, versions) in old_lock {
+ for version in versions {
+ if !new_lock.get(dep).map_or(false, |new_versions| {
+ new_versions.iter().any(|v| v.major == version.major)
+ }) {
+ println!(
+ "{:>12} {} v{}",
+ style("Removed").bright().red(),
+ dep,
+ version
+ );
+ }
+ }
+ }
+}
diff --git a/src/commands/update_index.rs b/src/commands/update_index.rs
deleted file mode 100644
index b0f3b63..0000000
--- a/src/commands/update_index.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::prelude::*;
-
-pub fn cli() -> App {
- App::new("update-index")
- .about("Updates the local registry with the latest packages and versions")
- .arg(Arg::new("quiet").long("quiet").short('q'))
-}
-
-pub fn exec(args: &ArgMatches) -> Result<()> {
- crate::index::update(!args.is_present("quiet"), false)
-}
diff --git a/src/index.rs b/src/index.rs
index d896ea4..3a676f9 100644
--- a/src/index.rs
+++ b/src/index.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashMap, fs};
+use std::{collections::HashMap, fs, time::Duration};
use anyhow::{Context, Result};
use git2::Repository;
@@ -24,7 +24,9 @@ pub struct VersionMetadata {
}
pub fn update(with_spinner: bool, clear_after: bool) -> Result<()> {
- rm_rf::ensure_removed(paths::tmp())?;
+ log::trace!("Updating index");
+
+ rm_rf::ensure_removed(paths::tmp()).context("Failed to remove tmp folder")?;
let spinner = ProgressBar::new_spinner();
if with_spinner {
@@ -32,11 +34,13 @@ pub fn update(with_spinner: bool, clear_after: bool) -> Result<()> {
"{:>10} index",
console::style("Updating").bright().cyan()
));
- spinner.enable_steady_tick(100);
+ spinner.enable_steady_tick(Duration::from_millis(100));
}
- Repository::clone("https://github.com/RogueMacro/grill-index", paths::tmp())?;
- fs::copy(paths::tmp().join("index.toml"), paths::index())?;
+ Repository::clone("https://github.com/RogueMacro/grill-index", paths::tmp())
+ .context("Failed to clone repository")?;
+ fs::copy(paths::tmp().join("index.toml"), paths::index())
+ .context("Failed to move index file")?;
if with_spinner {
if clear_after {
@@ -53,6 +57,8 @@ pub fn update(with_spinner: bool, clear_after: bool) -> Result<()> {
}
pub fn parse(with_spinner: bool, clear_after: bool) -> Result {
+ log::trace!("Parsing index");
+
let path = paths::index();
toml::from_str::(&fs::read_to_string(&path)?).or_else(|err| {
update(with_spinner, clear_after)?;
diff --git a/src/lib.rs b/src/lib.rs
index 498944c..67494e2 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -2,24 +2,28 @@ pub mod beef;
pub mod commands;
pub mod index;
pub mod lock;
+pub mod log;
pub mod manifest;
pub mod ops;
pub mod paths;
pub mod resolver;
-// pub mod log;
+pub mod web;
use prelude::App;
pub fn cli() -> App {
App::new("grill")
+ .about(clap::crate_description!())
+ .version(clap::crate_version!())
+ .subcommand(commands::init::cli())
.subcommand(commands::install::cli())
.subcommand(commands::list::cli())
.subcommand(commands::login::cli())
.subcommand(commands::make::cli())
+ .subcommand(commands::new::cli())
.subcommand(commands::publish::cli())
.subcommand(commands::purge::cli())
- .subcommand(commands::remove::cli())
- .subcommand(commands::update_index::cli())
+ .subcommand(commands::update::cli())
}
pub mod prelude {
diff --git a/src/lock.rs b/src/lock.rs
index bbfb29d..1625c4e 100644
--- a/src/lock.rs
+++ b/src/lock.rs
@@ -4,62 +4,105 @@ use std::{
path::Path,
};
-use anyhow::Result;
-use semver::{Version, VersionReq};
+use anyhow::{Context, Result};
+use semver::Version;
use crate::{manifest::Manifest, resolver::resolve};
pub type Lock = HashMap>;
+pub fn read(path: P) -> Result
+where
+ P: AsRef,
+{
+ Ok(
+ toml::from_str(&fs::read_to_string(path.as_ref()).with_context(|| {
+ format!(
+ "Failed to read lock file: {}",
+ path.as_ref().to_string_lossy()
+ )
+ })?)
+ .context("Failed to deserialize lock file")?,
+ )
+}
+
+pub fn write(path: P, lock: &Lock) -> Result<()>
+where
+ P: AsRef,
+{
+ Ok(fs::write(
+ path,
+ toml::to_string(lock).context("Failed to serialize lock")?,
+ )
+ .context("Failed to write lock file")?)
+}
+
pub fn validate(pkg_path: &Path) -> Result {
- let deps = Manifest::from_pkg(pkg_path)?.dependencies;
+ let manifest = Manifest::from_pkg(pkg_path)?;
- let file_path = pkg_path.join(crate::paths::LOCK_FILE);
+ let file_path = pkg_path.join(crate::paths::LOCK_FILENAME);
if !file_path.exists() {
return Ok(false);
}
- let lock: Lock = toml::from_str(&fs::read_to_string(file_path)?)?;
- Ok(validate_lock(&deps, &lock))
+ let lock: Lock = self::read(file_path)?;
+ Ok(validate_lock(&manifest, &lock))
}
-fn validate_lock(deps: &HashMap, lock: &Lock) -> bool {
- log::trace!("Validation lock");
- log::trace!("Dependencies: {:#?}", deps);
- log::trace!("Lock: {:#?}", lock);
+fn validate_lock(manifest: &Manifest, lock: &Lock) -> bool {
+ log::trace!("Validating lock");
- if deps.len() != lock.len() {
- log::trace!("Length doesn't match");
- return false;
+ for (dep, req) in manifest.simple_deps() {
+ if !lock.get(dep).map_or(false, |locked_versions| {
+ locked_versions.iter().any(|v| req.matches(v))
+ }) {
+ log::trace!("Invalid lock: No match for {} {}", dep, req);
+ return false;
+ }
}
- for (dep, req) in deps {
- if !lock
- .get(dep)
- .map_or(false, |vset| vset.iter().any(|v| req.matches(v)))
- {
- log::error!("No match for {} {} in vset {:?}", dep, req, lock.get(dep));
- return false;
+ for (dep, versions) in lock {
+ for v1 in versions.iter() {
+ for v2 in versions.iter() {
+ if v1.major == v2.major && v1 != v2 {
+ log::trace!(
+ "Invalid lock: {} v{} is incompatible with {} v{}",
+ dep,
+ v1,
+ dep,
+ v2
+ );
+ return false;
+ }
+ }
}
}
true
}
-pub fn generate(pkg_path: &Path) -> Result {
- let manifest = Manifest::from_pkg(pkg_path)?;
+pub fn generate(pkg_path: &Path, write_lock: bool, try_keep_lock: bool) -> Result {
+ let manifest = Manifest::from_pkg(pkg_path).context("Failed to read manifest")?;
- let lock_path = pkg_path.join(crate::paths::LOCK_FILE);
- let previous_lock = if lock_path.exists() {
- Some(toml::from_str(&fs::read_to_string(lock_path)?)?)
+ let lock_path = pkg_path.join(crate::paths::LOCK_FILENAME);
+ let previous_lock = if try_keep_lock && lock_path.exists() {
+ let lock = self::read(lock_path)?;
+ if validate_lock(&manifest, &lock) {
+ Some(lock)
+ } else {
+ None
+ }
} else {
None
};
- let resolved = resolve(&manifest, previous_lock.as_ref())?;
+ let index = crate::index::parse(false, false)?;
+
+ let lock = resolve(&manifest, previous_lock.as_ref(), &index)?;
- let lock_file = toml::to_string(&resolved)?;
- fs::write(pkg_path.join(crate::paths::LOCK_FILE), lock_file)?;
+ if write_lock {
+ self::write(pkg_path.join(crate::paths::LOCK_FILENAME), &lock)?;
+ }
- Ok(resolved)
+ Ok(lock)
}
diff --git a/src/log.rs b/src/log.rs
index ef2d29a..5983b12 100644
--- a/src/log.rs
+++ b/src/log.rs
@@ -1,32 +1,60 @@
-use std::{cell::RefCell, io::BufWriter};
+use std::fs::File;
-use indicatif::ProgressBar;
+use anyhow::Result;
+use indicatif::MultiProgress;
+use lazy_static::lazy_static;
-thread_local! {
- static PROGRESS_BAR: RefCell> = RefCell::new(None);
+use crate::paths;
+
+lazy_static! {
+ static ref PROGRESS_BAR: MultiProgress = MultiProgress::new();
+}
+
+pub fn init() -> Result<()> {
+ let console_logger = Box::new(ConsoleLogger::new());
+ let file_logger = simplelog::WriteLogger::new(
+ log::LevelFilter::max(),
+ Default::default(),
+ File::create(paths::home().join("log.txt"))?,
+ );
+ multi_log::MultiLogger::init(vec![console_logger, file_logger], log::Level::max())
+ .map_err(anyhow::Error::from)
+}
+
+pub fn get_multi_progress() -> &'static MultiProgress {
+ &PROGRESS_BAR
}
-struct Logger {
- logger: env_logger::Logger,
+struct ConsoleLogger {
+ inner: env_logger::Logger,
}
-impl Logger {
+impl ConsoleLogger {
pub fn new() -> Self {
- let buf = BufWriter::new(Vec::new());
- let logger = env_logger::builder().target(Target::Pipe(buf)).init();
+ Self {
+ inner: env_logger::builder()
+ .format_timestamp(None)
+ .format_target(false)
+ .filter_level(log::LevelFilter::Info)
+ .build(),
+ }
}
}
-impl log::Log for Logger {
+impl log::Log for ConsoleLogger {
fn enabled(&self, metadata: &log::Metadata) -> bool {
- self.logger.enabled(metadata)
+ self.inner.enabled(metadata)
}
fn log(&self, record: &log::Record) {
- self.logger.log(record)
+ if self.inner.matches(record) {
+ get_multi_progress().suspend(|| {
+ self.inner.log(record);
+ });
+ }
}
fn flush(&self) {
- self.logger.flush()
+ self.inner.flush();
}
}
diff --git a/src/main.rs b/src/main.rs
index ef565db..d38b703 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,58 +1,50 @@
-use std::fs::File;
-
use anyhow::{bail, Result};
use grill::paths;
fn main() -> Result<()> {
- let console_logger = Box::new(
- env_logger::builder()
- .format_timestamp(None)
- .format_target(false)
- .build(),
- );
- let file_logger = simplelog::WriteLogger::new(
- log::LevelFilter::max(),
- Default::default(),
- File::create(paths::home().join("log.txt"))?,
- );
- multi_log::MultiLogger::init(vec![console_logger, file_logger], log::Level::Trace)?;
-
- let result = run();
- let removed = rm_rf::ensure_removed(paths::tmp());
+ grill::log::init()?;
+
+ rm_rf::ensure_removed(paths::tmp())?;
+
+ let result = {
+ let args = grill::cli().get_matches();
+ match args.subcommand() {
+ Some((cmd, args)) => match cmd {
+ "init" => grill::commands::init::exec(args),
+ "install" => grill::commands::install::exec(args),
+ "list" => grill::commands::list::exec(args),
+ "login" => grill::commands::login::exec(args),
+ "make" => grill::commands::make::exec(args),
+ "new" => grill::commands::new::exec(args),
+ "publish" => grill::commands::publish::exec(args),
+ "purge" => grill::commands::purge::exec(args),
+ "update" => grill::commands::update::exec(args),
+ _ => bail!("Unkown command: {}", cmd),
+ },
+ None => {
+ grill::cli().print_help()?;
+ Ok(())
+ }
+ }
+ };
if let Err(err) = result {
println!();
- if let Some(source) = err.source() {
- log::error!("{}\n\nCaused by:\n {}", err, source);
+
+ if let Some(src) = err.source() {
+ log::error!("{}\n\nCaused by:\n {}", err, src);
} else {
log::error!("{}", err);
}
+
+ log::trace!("Backtrace: {}", err.backtrace());
+
println!();
}
- removed?;
+ if !cfg!(debug_assertions) {
+ rm_rf::ensure_removed(paths::tmp())?;
+ }
Ok(())
}
-
-fn run() -> Result<()> {
- let args = grill::cli().get_matches();
-
- match args.subcommand() {
- Some((cmd, args)) => match cmd {
- "install" => grill::commands::install::exec(args),
- "list" => grill::commands::list::exec(args),
- "login" => grill::commands::login::exec(args),
- "make" => grill::commands::make::exec(args),
- "publish" => grill::commands::publish::exec(args),
- "purge" => grill::commands::purge::exec(args),
- "remove" => grill::commands::remove::exec(args),
- "update-index" => grill::commands::update_index::exec(args),
- _ => bail!("Unkown command: {}", cmd),
- },
- None => {
- grill::cli().print_help()?;
- Ok(())
- }
- }
-}
diff --git a/src/manifest.rs b/src/manifest.rs
index a8370da..c34f971 100644
--- a/src/manifest.rs
+++ b/src/manifest.rs
@@ -1,32 +1,134 @@
-use std::{collections::HashMap, path::Path};
+use std::{
+ collections::{HashMap, HashSet},
+ path::{Path, PathBuf},
+};
use anyhow::Context;
use semver::{Version, VersionReq};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
pub struct Manifest {
pub package: Package,
#[serde(default)]
- pub dependencies: HashMap,
+ pub dependencies: HashMap,
+ #[serde(default)]
+ pub features: Features,
}
impl Manifest {
pub fn from_pkg(path: P) -> anyhow::Result
+ where
+ P: AsRef,
+ {
+ Self::from_file(path.as_ref().join(crate::paths::MANIFEST_FILENAME))
+ }
+
+ pub fn from_file(path: P) -> anyhow::Result
where
P: AsRef,
{
let path = path.as_ref();
let manifest = toml::from_str(
- &std::fs::read_to_string(path.join(crate::paths::PACKAGE_FILE))
- .context(format!("No manifest found at in '{}'", path.display()))?,
+ &std::fs::read_to_string(path)
+ .with_context(|| format!("Failed to read manifest at '{}'", path.display()))?,
)?;
Ok(manifest)
}
+
+ /// Get simple dependencies with requirements.
+ /// Ignores git dependencies.
+ pub fn simple_deps(&self) -> impl Iterator- {
+ self.dependencies.iter().filter_map(|(key, val)| {
+ if let Dependency::Simple(req) = val {
+ Some((key, req))
+ } else {
+ None
+ }
+ })
+ }
+
+ pub fn git_deps(&self) -> impl Iterator
- {
+ self.dependencies.iter().filter_map(|(key, val)| {
+ if let Dependency::Git(git_dep) = val {
+ Some((key, git_dep))
+ } else {
+ None
+ }
+ })
+ }
+
+ pub fn local_deps(&self) -> impl Iterator
- {
+ self.dependencies.iter().filter_map(|(key, val)| {
+ if let Dependency::Local(local) = val {
+ Some((key, local))
+ } else {
+ None
+ }
+ })
+ }
}
#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase")]
pub struct Package {
pub name: String,
pub version: Version,
+ pub description: String,
+ #[serde(default = "bool_true")]
+ pub corlib: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(untagged)]
+pub enum Dependency {
+ Simple(VersionReq),
+ Advanced(AdvancedDependency),
+ Git(GitDependency),
+ Local(LocalDependency),
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase", deny_unknown_fields)]
+pub struct AdvancedDependency {
+ #[serde(rename = "Version")]
+ pub req: VersionReq,
+ #[serde(default)]
+ pub features: HashSet,
+ #[serde(default = "bool_true")]
+ pub default_features: bool,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase", deny_unknown_fields)]
+pub struct GitDependency {
+ pub git: url::Url,
+ pub rev: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "PascalCase", deny_unknown_fields)]
+pub struct LocalDependency {
+ pub path: PathBuf,
+}
+
+#[derive(Serialize, Deserialize, Debug, Default)]
+#[serde(rename_all = "PascalCase")]
+pub struct Features {
+ #[serde(default)]
+ pub default: Vec,
+ #[serde(flatten)]
+ pub optional: HashMap,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(untagged)]
+pub enum Feature {
+ Project(String),
+ List(Vec),
+}
+
+fn bool_true() -> bool {
+ true
}
diff --git a/src/ops.rs b/src/ops.rs
index 375dbeb..516e170 100644
--- a/src/ops.rs
+++ b/src/ops.rs
@@ -1,3 +1,4 @@
+pub mod init;
pub mod install;
pub mod make;
diff --git a/src/ops/init.rs b/src/ops/init.rs
new file mode 100644
index 0000000..67730eb
--- /dev/null
+++ b/src/ops/init.rs
@@ -0,0 +1,25 @@
+use std::{fs, path::Path};
+
+use anyhow::{bail, Result};
+
+pub fn init(path: &Path, name: &str) -> Result<()> {
+ let manifest_path = path.join(crate::paths::MANIFEST_FILENAME);
+
+ if manifest_path.exists() {
+ bail!("Already initialized")
+ }
+
+ fs::write(
+ manifest_path,
+ format!(
+ "\
+[Package]
+Name = \"{}\"
+Version = \"0.1.0\"
+Description = \"\"
+",
+ name
+ ),
+ )?;
+ Ok(())
+}
diff --git a/src/ops/install.rs b/src/ops/install.rs
index 0c979c9..bc977e5 100644
--- a/src/ops/install.rs
+++ b/src/ops/install.rs
@@ -1,21 +1,32 @@
-use std::{collections::HashMap, fs, path::PathBuf};
+use std::{
+ collections::HashMap,
+ fs,
+ path::{Path, PathBuf},
+ time::Duration,
+};
use anyhow::Context;
-use git2::Repository;
-use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use indicatif::{ProgressBar, ProgressStyle};
use reqwest::Url;
use semver::Version;
use crate::{
beef,
index::{self, Index},
+ manifest::Manifest,
paths,
prelude::*,
};
-pub fn install
(pkg: S, version: &Version, index: Option<&Index>) -> Result
+pub fn install(
+ pkg: S,
+ version: &Version,
+ index: Option<&Index>,
+ progress_callback: C,
+) -> Result
where
S: AsRef,
+ C: FnMut(git2::Progress<'_>),
{
let pkg = pkg.as_ref();
@@ -39,63 +50,172 @@ where
.with_context(|| format!("{} is not a version of '{}'", version, pkg))?;
let ident = format!("{}-{}", pkg, version);
- let path = paths::pkg(&ident);
+ let path = paths::pkg(".", &ident);
if path.exists() {
return Ok(path);
}
- let path = install_git(&entry.url, Some(&metadata.rev), Some(&ident))?;
+ let (path, _) = install_git(
+ &entry.url,
+ Some(&metadata.rev),
+ Some(&ident),
+ progress_callback,
+ )?;
Ok(path)
}
-pub fn install_git(url: &Url, rev: Option<&str>, pkg_ident: Option<&String>) -> Result {
+/// Returns the path to the installed package and the revision
+/// that was checked out.
+pub fn install_git(
+ url: &Url,
+ rev: Option<&str>,
+ pkg_ident: Option<&String>,
+ mut progress_callback: C,
+) -> Result<(PathBuf, String)>
+where
+ C: FnMut(git2::Progress<'_>),
+{
rm_rf::ensure_removed(paths::tmp())?;
- let repo = Repository::clone(url.as_str(), &paths::tmp())?;
- if let Some(rev) = rev {
- let (object, reference) = repo.revparse_ext(&rev)?;
+
+ // let repo = Repository::init(&paths::tmp())?;
+ // let mut remote = repo.remote("origin", url.as_str())?;
+ let checkout_rev;
+ {
+ let mut callbacks = git2::RemoteCallbacks::new();
+ callbacks.transfer_progress(|p| {
+ progress_callback(p);
+ true
+ });
+
+ // remote.download::(
+ // &[],
+ // Some(git2::FetchOptions::new().remote_callbacks(callbacks)),
+ // )?;
+
+ // log::trace!(
+ // "Downloaded from remote: {}",
+ // remote.url().unwrap_or("Url unavailable")
+ // );
+ let mut fo = git2::FetchOptions::new();
+ fo.remote_callbacks(callbacks);
+ let repo = git2::build::RepoBuilder::new()
+ .fetch_options(fo)
+ .clone(url.as_str(), &paths::tmp())?;
+
+ let head = repo
+ .find_commit(repo.head().unwrap().target().unwrap())?
+ .id()
+ .to_string();
+
+ // drop(remote);
+
+ checkout_rev = rev.map(str::to_owned).unwrap_or(head.to_string());
+
+ let (object, reference) = repo.revparse_ext(&checkout_rev)?;
repo.checkout_tree(&object, None)?;
match reference {
Some(gref) => repo.set_head(gref.name().with_context(|| "Invalid gref name")?),
None => repo.set_head_detached(object.id()),
}?;
- }
- // Dropping the repository gives us access to the directory
- drop(repo);
+ // Dropping the repository gives us access to the directory
+ }
- let path = pkg_ident.map(|ident| paths::pkg(ident)).unwrap_or_else(|| {
- let mut pkg = url
- .host()
- .ok_or(anyhow!("No host in url"))
- .unwrap()
- .to_string();
- pkg.push_str(&url.path().replace("/", "-").replace(".git", ""));
- paths::pkg(&pkg)
- });
+ let path = pkg_ident
+ .map(|ident| paths::pkg(".", ident))
+ .unwrap_or_else(|| {
+ let mut pkg = url.host().unwrap().to_string();
+ pkg.push_str(&url.path().replace("/", "-").replace(".git", ""));
+ pkg = format!("{}-{}", pkg, checkout_rev);
+ paths::pkg(".", &pkg)
+ });
if path.exists() {
- bail!("Package already installed")
+ return Ok((path, checkout_rev));
}
- fs::rename(paths::tmp(), &path).context("Failed to move package")?;
+ fs::rename(paths::tmp(), &path).context("Failed to move tmp folder")?;
- if let Some(ident) = pkg_ident {
- let proj_file_path = path.join("BeefProj.toml");
- let mut proj_file: beef::BeefProj =
- toml::from_str(&fs::read_to_string(&proj_file_path)?)
- .with_context(|| format!("Failed to read project file of package '{}'", ident))?;
+ if pkg_ident.is_some() {
+ prepare_pkg(&path, pkg_ident.map(String::as_str))?;
+ }
+
+ Ok((path, checkout_rev))
+}
+
+pub fn prepare_pkg(path: &Path, ident: Option<&str>) -> Result<()> {
+ let ident = ident.map(str::to_owned).unwrap_or(
+ path.file_name()
+ .context("Invalid file name for package path")?
+ .to_string_lossy()
+ .to_string(),
+ );
- proj_file.project.name = ident.to_owned();
+ let proj_file_path = path.join("BeefProj.toml");
+ let mut proj_file = beef::BeefProj::from_file(&proj_file_path)?;
- fs::write(&proj_file_path, toml::to_string(&proj_file)?)
- .context("Failed to write project file")?;
+ proj_file.project.name = ident.clone();
+ proj_file
+ .dependencies
+ .insert(String::from("corlib"), String::from("*"));
+
+ let manifest = Manifest::from_pkg(&path)?;
+
+ for (feature_name, feature_project) in
+ manifest
+ .features
+ .optional
+ .iter()
+ .filter_map(|(feature_name, feature)| {
+ if let crate::manifest::Feature::Project(project) = feature {
+ Some((feature_name, project))
+ } else {
+ None
+ }
+ })
+ {
+ let feature_proj_path = path.join(feature_project).join("BeefProj.toml");
+ let mut feature_proj_file = beef::BeefProj::from_file(&feature_proj_path)?;
+ feature_proj_file.project.name = format!("{}/{}", ident, feature_name);
+ feature_proj_file.save()?;
}
- if path.join(paths::PACKAGE_FILE).exists() {
- crate::ops::make(&path, true)?;
+ for feature_project in manifest.features.optional.iter().filter_map(|(_, f)| {
+ if let crate::manifest::Feature::Project(project) = f {
+ Some(project)
+ } else {
+ None
+ }
+ }) {
+ let feature_project_path = path.join(feature_project);
+ if !feature_project_path.join(paths::MANIFEST_FILENAME).exists() {
+ continue;
+ }
+
+ let feature_manifest = Manifest::from_pkg(&feature_project_path)?;
+
+ let feature_proj_file_path = feature_project_path.join("BeefProj.toml");
+ let mut feature_proj = beef::BeefProj::from_file(&feature_proj_file_path)?;
+ feature_proj.dependencies.clear();
+ feature_proj
+ .dependencies
+ .insert(String::from("corlib"), String::from("*"));
+
+ for (_, dep) in feature_manifest.local_deps() {
+ let dep_proj_path = feature_project_path.join(&dep.path).join("BeefProj.toml");
+ let dep_proj_file = beef::BeefProj::from_file(&dep_proj_path)?;
+
+ feature_proj
+ .dependencies
+ .insert(dep_proj_file.project.name, String::from("*"));
+ }
+
+ feature_proj.save()?;
}
- Ok(path)
+ proj_file.save()?;
+
+ Ok(())
}
pub fn install_multiple(
@@ -118,11 +238,11 @@ where
let mut paths = HashMap::new();
if with_progress {
- let progress = MultiProgress::new();
+ let progress = crate::log::get_multi_progress();
let install_progress = progress.add(
ProgressBar::new_spinner().with_style(
ProgressStyle::default_spinner()
- .template("{spinner:>11}> {msg}")
+ .template("{spinner:>11}> {msg}")?
.tick_chars("=\\|/==="),
),
);
@@ -130,18 +250,18 @@ where
ProgressBar::new(pkgs.len() as u64)
.with_style(
ProgressStyle::default_bar()
- .template("{prefix:>12.bright.cyan} [{bar:40}] {pos}/{len}")
+ .template("{prefix:>12.bright.cyan} [{bar:40}] {pos}/{len}")?
.progress_chars("=> "),
)
.with_prefix("Fetching"),
);
- install_progress.enable_steady_tick(150);
+ install_progress.enable_steady_tick(Duration::from_millis(150));
fetch_progress.tick();
for (pkg, version) in pkgs.iter() {
install_progress.set_message(format!("{} v{}", pkg, version));
- let path = install(pkg, version, Some(index))?;
+ let path = install(pkg, version, Some(index), |_| {})?;
paths.insert(pkg.clone(), path);
install_progress.println(format!(
@@ -162,7 +282,7 @@ where
progress.clear()?;
} else {
for (pkg, version) in pkgs.iter() {
- let path = install(pkg, version, Some(index))?;
+ let path = install(pkg, version, Some(index), |_| {})?;
paths.insert(pkg.clone(), path);
if let Some(on_install) = &on_install {
on_install(pkg, version);
diff --git a/src/ops/make.rs b/src/ops/make.rs
index c37c6ce..e0f3efb 100644
--- a/src/ops/make.rs
+++ b/src/ops/make.rs
@@ -1,18 +1,18 @@
use std::{
collections::{HashMap, HashSet},
fs,
- path::Path,
+ path::{Path, PathBuf},
+ time::Duration,
};
-use anyhow::Context;
use console::Emoji;
+use either::{self, Either};
use indicatif::{MultiProgress, ProgressBar, ProgressStyle};
+use semver::Version;
use crate::{
- beef,
- index::{self},
- lock::{self, Lock},
- manifest::Manifest,
+ beef, index, lock,
+ manifest::{self, Manifest},
prelude::*,
};
@@ -20,7 +20,7 @@ const COMPASS: Emoji = Emoji("🧭 ", "");
const LOOKING_GLASS: Emoji = Emoji("🔍 ", "");
const TRUCK: Emoji = Emoji("🚚 ", "");
const PACKAGE: Emoji = Emoji("📦 ", "");
-const BEEF: Emoji = Emoji("🥩 ", "");
+const SPAGHETTI: Emoji = Emoji("🍝 ", "");
pub fn make(path: &Path, silent: bool) -> Result<()> {
let manifest = Manifest::from_pkg(&path)?;
@@ -34,7 +34,7 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
);
}
- let multi = MultiProgress::new();
+ let multi = crate::log::get_multi_progress();
let index = make_step(
&multi,
@@ -60,12 +60,9 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
silent,
|_, _| {
if !lock::validate(&path)? {
- lock::generate(&path)
+ lock::generate(&path, false, true)
} else {
- let lock: Lock =
- toml::from_str(&fs::read_to_string(path.join(crate::paths::LOCK_FILE))?)
- .context("Invalid lock")?;
- Ok(lock)
+ lock::read(path.join(crate::paths::LOCK_FILENAME))
}
},
)?;
@@ -82,7 +79,7 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
let progress = multi.add(
ProgressBar::new(1).with_style(
ProgressStyle::default_bar()
- .template("{prefix:>12.bright.cyan} [{bar:11}]")
+ .template("{prefix:>12} [{bar:11}] {msg:.bright.grey}")?
.progress_chars("=> "),
),
);
@@ -92,31 +89,82 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
.map(|(_, versions)| versions.len())
.sum::() as u64,
);
- progress.set_style(
- ProgressStyle::default_bar()
- .template("{msg:>12} [{bar:11}]")
- .progress_chars("=> "),
- );
- progress.set_message(format!("{} / {}", 0, progress.length()));
+ progress.set_prefix(format!(
+ "{} / {}",
+ 0,
+ progress.length().ok_or(anyhow!("No progress length"))?
+ ));
}
let mut pkgs = HashMap::new();
for (pkg, versions) in lock {
for version in versions {
- let path = crate::ops::install(&pkg, &version, Some(&index))?;
- pkgs.insert(format!("{}-{}", pkg, version), path);
+ progress.set_message(format!("{} 0%", pkg));
+ let path =
+ crate::ops::install(&pkg, &version, Some(&index), |install_progress| {
+ progress.set_message(format!(
+ "{} {}% ({}/{}) {}",
+ pkg,
+ ((install_progress.received_objects()
+ + install_progress.indexed_objects())
+ as f32
+ / (install_progress.total_objects() * 2) as f32
+ * 100f32)
+ .round(),
+ install_progress.received_objects(),
+ install_progress.total_objects(),
+ install_progress.indexed_objects()
+ ))
+ })?;
+
+ pkgs.insert((pkg.clone(), either::Left(version)), path);
if !silent {
progress.inc(1);
- progress.set_message(format!(
+ progress.set_prefix(format!(
"{} / {}",
progress.position(),
- progress.length()
+ progress.length().ok_or(anyhow!("No progress length"))?
));
}
}
}
+ for (name, dep) in manifest.git_deps() {
+ progress.set_message(format!("{} 0%", name));
+ let (path, rev) = crate::ops::install_git(
+ &dep.git,
+ Some(&dep.rev),
+ Some(name),
+ |install_progress| {
+ progress.set_message(format!(
+ "{} {}% ({}/{}) {}",
+ name,
+ ((install_progress.received_objects()
+ + install_progress.indexed_objects())
+ as f32
+ / (install_progress.total_objects() * 2) as f32
+ * 100f32)
+ .round(),
+ install_progress.received_objects(),
+ install_progress.total_objects(),
+ install_progress.indexed_objects()
+ ))
+ },
+ )?;
+
+ pkgs.insert((name.clone(), either::Right(rev)), path);
+
+ if !silent {
+ progress.inc(1);
+ progress.set_prefix(format!(
+ "{} / {}",
+ progress.position(),
+ progress.length().ok_or(anyhow!("No progress length"))?
+ ));
+ }
+ }
+
progress.finish_and_clear();
Ok(pkgs)
},
@@ -133,29 +181,25 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
|_, _| {
let ws_file_path = path.join("BeefSpace.toml");
let proj_file_path = path.join("BeefProj.toml");
- let mut ws: beef::BeefSpace = toml::from_str(&fs::read_to_string(&ws_file_path)?)?;
- let mut proj: beef::BeefProj = toml::from_str(&fs::read_to_string(&proj_file_path)?)?;
- if !ws.workspace_folders.contains_key("Packages") {
- ws.workspace_folders
- .insert(String::from("Packages"), HashSet::new());
- }
+ let mut ws = if ws_file_path.exists() {
+ toml::from_str(&fs::read_to_string(&ws_file_path)?)?
+ } else {
+ beef::BeefSpace::default()
+ };
- ws.workspace_folders
- .get_mut("Packages")
- .unwrap()
- .retain(|pkg| {
- if !pkgs.contains_key(pkg) {
- ws.projects.remove(pkg);
- false
- } else {
- true
- }
- });
+ let mut proj = if proj_file_path.exists() {
+ beef::BeefProj::from_file(&proj_file_path)?
+ } else {
+ beef::BeefProj::new(manifest.package.name.clone(), &proj_file_path)
+ };
+ proj.project.name = manifest.package.name.clone();
+ proj.save()?;
- proj.dependencies
- .retain(|pkg, _| manifest.dependencies.contains_key(pkg) && pkg != "corlib");
+ let mut ws_package_folder = HashSet::new();
+ ws.workspace.startup_project = proj.project.name.clone();
+ ws.projects.clear();
ws.projects.insert(
String::from("corlib"),
beef::ProjectEntry {
@@ -163,43 +207,44 @@ pub fn make(path: &Path, silent: bool) -> Result<()> {
..Default::default()
},
);
+
+ ws.locked.clear();
ws.locked.insert(String::from("corlib"));
- proj.dependencies
- .insert(String::from("corlib"), String::from("*"));
-
- for (ident, path) in pkgs {
- ws.projects.insert(
- ident.clone(),
- beef::ProjectEntry {
- path,
- ..Default::default()
- },
- );
- ws.locked.insert(ident.clone());
+ connect(
+ &manifest.package.name,
+ Some(&either::Left(manifest.package.version)),
+ path,
+ &pkgs,
+ &mut ws,
+ &mut ws_package_folder,
+ false,
+ )?;
- ws.workspace_folders
- .get_mut("Packages")
- .unwrap()
- .insert(ident.clone());
+ ws.projects.get_mut(&manifest.package.name).unwrap().path = ".".into();
- if manifest
- .dependencies
- .contains_key(ident.rsplit_once('-').unwrap().0)
- {
- proj.dependencies.insert(ident, String::from("*"));
- }
+ for ((pkg_name, pkg_version), pkg_path) in pkgs.iter() {
+ connect(
+ pkg_name,
+ Some(pkg_version),
+ pkg_path,
+ &pkgs,
+ &mut ws,
+ &mut ws_package_folder,
+ true,
+ )?;
}
+ ws.workspace_folders
+ .insert(String::from("Packages"), ws_package_folder);
fs::write(&ws_file_path, toml::to_string(&ws)?)?;
- fs::write(&proj_file_path, toml::to_string(&proj)?)?;
Ok(())
},
)?;
if !silent {
- println!("\n{:>13}{}Enjoy your meal!", " ", BEEF);
+ println!("\n{:>13}{}Enjoy your spaghetti!", " ", SPAGHETTI);
}
Ok(())
@@ -219,7 +264,7 @@ where
F: FnOnce(&MultiProgress, &ProgressBar) -> Result,
{
let spinner_style = ProgressStyle::default_spinner()
- .template("{msg} {spinner}")
+ .template("{msg} {spinner}")?
.tick_chars("⠁⠂⠄⡀⢀⠠⠐⠈✔");
let progress = multi.insert(
step as usize - 1,
@@ -233,7 +278,7 @@ where
.with_style(spinner_style),
);
if !silent {
- progress.enable_steady_tick(100);
+ progress.enable_steady_tick(Duration::from_millis(100));
}
let result = func(multi, &progress)?;
@@ -249,3 +294,184 @@ where
Ok(result)
}
+
+fn connect(
+ pkg_name: &str,
+ pkg_version: Option<&Either>,
+ pkg_path: &Path,
+ pkgs: &HashMap<(String, Either), PathBuf>,
+ ws: &mut beef::BeefSpace,
+ ws_package_folder: &mut HashSet,
+ is_pkg: bool,
+) -> Result {
+ let manifest = Manifest::from_pkg(&pkg_path)?;
+ let mut proj = beef::BeefProj::from_file(&pkg_path.join("BeefProj.toml"))?;
+ proj.dependencies.clear();
+ proj.dependencies
+ .insert(String::from("corlib"), String::from("*"));
+
+ let pkg_ident = if let Some(pkg_version) = pkg_version {
+ match pkg_version {
+ either::Left(v) => format!("{}-{}", pkg_name, v),
+ either::Right(rev) => format!("{}-{}", pkg_name, rev),
+ }
+ } else {
+ pkg_name.to_owned()
+ };
+
+ 'dep_loop: for (name, dep) in manifest.dependencies.iter() {
+ if let manifest::Dependency::Local(local) = dep {
+ let dep_path = pkg_path.join(&local.path);
+ let dep_manifest = Manifest::from_pkg(&dep_path)?;
+
+ let dep_ident = if std::fs::canonicalize(&dep_path)?.starts_with(pkg_path) {
+ // We are a root package
+ connect(
+ &format!("{}/{}", pkg_name, name),
+ None,
+ &dep_path,
+ pkgs,
+ ws,
+ ws_package_folder,
+ true,
+ )?
+ } else {
+ // We are a package inside a package
+ connect(
+ name,
+ Some(&either::Left(dep_manifest.package.version)),
+ &dep_path,
+ pkgs,
+ ws,
+ ws_package_folder,
+ true,
+ )?
+ };
+
+ proj.dependencies.insert(dep_ident, String::from("*"));
+
+ continue;
+ }
+
+ for ((pkg, version), path) in pkgs.iter() {
+ if pkg == name {
+ let mut features = None;
+ let mut default_features = false;
+ let add = match version {
+ either::Left(version) => {
+ if let manifest::Dependency::Simple(req) = dep {
+ req.matches(&version)
+ } else if let manifest::Dependency::Advanced(dep) = dep {
+ features = Some(&dep.features);
+ default_features = dep.default_features;
+ dep.req.matches(&version)
+ } else {
+ false
+ }
+ }
+ either::Right(rev) => {
+ if let manifest::Dependency::Git(dep) = dep {
+ &dep.rev == rev
+ } else {
+ false
+ }
+ }
+ };
+
+ if add {
+ let ident = match version {
+ either::Left(v) => format!("{}-{}", pkg, v),
+ either::Right(rev) => format!("{}-{}", pkg, rev),
+ };
+ proj.dependencies.insert(ident, String::from("*"));
+
+ if let Some(features) = features {
+ let dep_manifest = Manifest::from_pkg(path)?;
+
+ let features: Box> = if default_features {
+ Box::new(features.iter().chain(dep_manifest.features.default.iter()))
+ } else {
+ Box::new(features.iter())
+ };
+
+ for feature in features {
+ let feature_idents =
+ enable_feature(path, &feature, ws, ws_package_folder, pkgs)?;
+ proj.dependencies
+ .extend(feature_idents.into_iter().map(|i| (i, String::from("*"))));
+ }
+ }
+
+ continue 'dep_loop;
+ }
+ }
+ }
+
+ log::error!("{} missing dependency {}", pkg_name, name);
+ }
+
+ if is_pkg {
+ ws.projects.insert(
+ pkg_ident.clone(),
+ beef::ProjectEntry {
+ path: pkg_path.to_path_buf(),
+ ..Default::default()
+ },
+ );
+ ws.locked.insert(pkg_ident.clone());
+ ws_package_folder.insert(pkg_ident.clone());
+ } else {
+ ws.projects.insert(
+ pkg_name.to_owned(),
+ beef::ProjectEntry {
+ path: pkg_path.to_path_buf(),
+ ..Default::default()
+ },
+ );
+ }
+
+ proj.save()?;
+
+ Ok(pkg_ident)
+}
+
+fn enable_feature(
+ path: &Path,
+ feature: &str,
+ ws: &mut beef::BeefSpace,
+ ws_package_folder: &mut HashSet,
+ pkgs: &HashMap<(String, Either), PathBuf>,
+) -> Result> {
+ let manifest = Manifest::from_pkg(path)?;
+
+ if !manifest.features.optional.contains_key(feature) {
+ bail!("Unkown feature '{}' for {}", feature, manifest.package.name);
+ }
+
+ let mut idents = Vec::new();
+ match manifest.features.optional.get(feature).unwrap() {
+ manifest::Feature::List(sub_features) => {
+ for sub_feature in sub_features {
+ enable_feature(path, sub_feature, ws, ws_package_folder, pkgs)?;
+ }
+ }
+ manifest::Feature::Project(feature_path) => {
+ let ident = format!(
+ "{}-{}/{}",
+ manifest.package.name, manifest.package.version, feature
+ );
+ connect(
+ &ident,
+ None,
+ &path.join(feature_path),
+ pkgs,
+ ws,
+ ws_package_folder,
+ true,
+ )?;
+ idents.push(ident);
+ }
+ }
+
+ Ok(idents)
+}
diff --git a/src/paths.rs b/src/paths.rs
index 65f3b0c..9ae9f59 100644
--- a/src/paths.rs
+++ b/src/paths.rs
@@ -3,18 +3,21 @@ use std::{
path::{Path, PathBuf},
};
-pub const PACKAGE_FILE: &'static str = "Package.toml";
-pub const LOCK_FILE: &'static str = "Package.lock";
+pub const MANIFEST_FILENAME: &'static str = "Package.toml";
+pub const LOCK_FILENAME: &'static str = "Package.lock";
-pub fn pkg(pkg: P) -> PathBuf
+pub fn pkg
(ws: &P, pkg: &P) -> PathBuf
where
- P: AsRef,
+ P: AsRef + ?Sized,
{
- pkgs().join(pkg)
+ pkgs(ws).join(pkg)
}
-pub fn pkgs() -> PathBuf {
- ensure_exists(home().join("pkg"))
+pub fn pkgs(ws: &P) -> PathBuf
+where
+ P: AsRef + ?Sized,
+{
+ ensure_exists(ws.as_ref().join("pkg"))
}
pub fn tmp() -> PathBuf {
@@ -30,7 +33,7 @@ pub fn token() -> PathBuf {
}
pub fn home() -> PathBuf {
- dirs::home_dir().unwrap().join(".grill")
+ ensure_exists(dirs::home_dir().unwrap().join(".grill"))
}
pub fn beeflibs() -> PathBuf {
diff --git a/src/resolver.rs b/src/resolver.rs
index a223e9f..78ea8df 100644
--- a/src/resolver.rs
+++ b/src/resolver.rs
@@ -1,135 +1,233 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
-use anyhow::{bail, Context, Result};
-use indexmap::IndexSet;
+use anyhow::{anyhow, Result};
use itertools::Itertools;
use semver::{Version, VersionReq};
use crate::{
- index::{self, Index},
+ index::Index,
lock::Lock,
- manifest::Manifest,
+ manifest::{self, Manifest},
};
-pub fn resolve(
- manifest: &Manifest,
- lock: Option<&Lock>,
-) -> Result>> {
- let mut activated = HashMap::new();
- if let Some(lock) = lock {
- activated.extend(lock.iter().filter_map(|(pkg, versions)| {
- manifest.dependencies.get(pkg).and_then(|req| {
- if versions.iter().any(|version| req.matches(version)) {
- Some((pkg.as_str(), versions.clone()))
- } else {
- None
- }
- })
- }));
- }
+pub fn resolve(manifest: &Manifest, lock: Option<&Lock>, index: &Index) -> Result {
+ log::trace!(
+ "Resolving dependency tree{}",
+ if lock.is_some() { " with lock" } else { "" }
+ );
- let index = index::parse(false, false)?;
- activate_deps(
- &manifest.dependencies,
- &mut activated,
- &index,
- &mut IndexSet::new(),
- )?;
-
- Ok(activated
- .into_iter()
- .map(|(k, v)| (k.to_owned(), v))
- .collect())
-}
-
-fn activate<'a>(
- dep: &'a str,
- req: &VersionReq,
- activated: &mut HashMap<&'a str, HashSet>,
- index: &'a Index,
- conflicts: &mut IndexSet<(&'a str, Version)>,
-) -> Result {
- let mut local_conflicts = IndexSet::new();
-
- 'version_loop: for (version, metadata) in index
- .get(dep)
- .with_context(|| format!("Package not found: '{}'", dep))?
- .versions
+ // Add the root dependencies.
+ let mut candidates: Vec = manifest
+ .dependencies
.iter()
- .filter(|(version, _)| {
- req.matches(&version) && !conflicts.contains(&(dep, (*version).clone()))
+ .filter_map(|(name, dep)| {
+ if let manifest::Dependency::Simple(req) = dep {
+ Some(Candidate::new(name, req, index, lock))
+ } else if let manifest::Dependency::Advanced(adv_dep) = dep {
+ Some(Candidate::new(name, &adv_dep.req, index, lock))
+ } else {
+ None
+ }
})
- .sorted_unstable_by(|(v1, _), (v2, _)| v2.cmp(&v1))
- {
- if let Some(versions) = activated.get(dep) {
- for v in versions.iter() {
- if v.major == version.major && v.minor != version.minor {
- local_conflicts.insert((dep, v.clone()));
- continue 'version_loop;
+ .collect();
+
+ // We should not remove any candidates before this index.
+ let root_candidates_len = candidates.len();
+ let mut i = 0;
+ let mut failed = false;
+ let mut complete = false;
+
+ while !complete {
+ while let Some(mut candidate) = candidates.get(i).and_then(|v| Some(v.clone())) {
+ let mut next_version = None;
+ // The available versions are sorted so that the top element
+ // is always the latest version.
+ while let Some(version) = candidate.available_versions.pop() {
+ if !candidates
+ .iter()
+ .enumerate()
+ .filter(|&(idx, c)| c.version.is_some() && idx != i)
+ .any(|(_, i_candidate)| {
+ let i_version = i_candidate.version.as_ref().unwrap();
+ // Two versions are conflicting if they have the same major version,
+ // but a different minor versions. I.e. '1.2.x' is conflicting with '1.3.x'.
+ // Different major versions for the same dependency is allowed.
+ // This is for convenience when using libraries together,
+ // as different versions can't be mixed.
+ let is_conflicting = i_candidate.name == candidate.name
+ && i_version.major == version.major
+ && i_version != &version;
+
+ if is_conflicting {
+ log::trace!("Conflicting with: {} v{}", i_candidate.name, i_version);
+ }
+
+ is_conflicting
+ })
+ {
+ // This version matches the requirements and does not
+ // come into conflict with any previously selected versions.
+ next_version = Some(version);
+ break;
}
}
+
+ if let Some(next_version) = next_version {
+ let deps = &index
+ .get(&candidate.name)
+ .unwrap()
+ .versions
+ .get(&next_version)
+ .unwrap()
+ .deps;
+
+ candidates.extend(
+ deps.iter()
+ .map(|(dep, req)| Candidate::new(dep, req, index, lock)),
+ );
+
+ // "Commit" this candidate to the list of candidates.
+ // Will update the selected versions and the available versions left.
+ candidate.version = Some(next_version.clone());
+ candidates[i] = candidate;
+
+ i += 1;
+ } else {
+ if i >= root_candidates_len {
+ // There were conflicts while selecting a version for this dependency
+ // so we invalidate the rest of the candidates by removing them.
+ // This is important as the dependency tree might change when we
+ // backtrack, leaving unused dependencies.
+ candidates.truncate(i);
+ } else if i == 0 {
+ // There was no more versions left for the first
+ // dependency that satisfies the requirements.
+ failed = true;
+ break;
+ } else {
+ // We can't remove a root dependency so we just
+ // unset the version and make sure it is ready for
+ // picking another version.
+ candidates[i].version = None;
+ candidates[i].update_available_versions(index, lock);
+ }
+
+ i -= 1;
+ }
+ }
+
+ // All combinations have been tried.
+ // This manifest can't be resolved.
+ if failed {
+ break;
}
- activated
- .entry(dep)
- .or_insert(HashSet::new())
- .insert(version.clone());
+ // When conflicts arise and we remove the invalidated candidates,
+ // some of the previous dependencies might not get re-iterated so
+ // that their dependencies are added as candidates again.
+ // We go over the candidate list again to make sure all dependencies
+ // are present and if not, we add the missing dependencies and restart
+ // resolution loop.
+ let mut missing_dependencies = Vec::new();
+ for candidate in &candidates {
+ let deps = &index
+ .get(&candidate.name)
+ .unwrap()
+ .versions
+ .get(candidate.version.as_ref().unwrap())
+ .unwrap()
+ .deps;
- if activate_deps(&metadata.deps, activated, index, conflicts).is_err() {
- if let Some(activated_versions) = activated.get_mut(dep) {
- activated_versions.remove(&version);
+ for (dep, req) in deps {
+ if !candidates
+ .iter()
+ .filter(|&c| &c.name == dep)
+ .any(|c| req.matches(c.version.as_ref().unwrap()))
+ {
+ missing_dependencies.push((dep, req));
+ }
}
- continue 'version_loop;
}
- return Ok(version.clone());
+ if missing_dependencies.is_empty() {
+ // All dependencies are present so the resolution is ready,
+ // so we stop the resolution loop.
+ complete = true;
+ } else {
+ // We need to resolve the missing dependencies.
+ // The resolution loop will continue automatically.
+ log::trace!("{:?}", missing_dependencies);
+ candidates.extend(
+ missing_dependencies
+ .iter()
+ .map(|(dep, req)| Candidate::new(dep, req, index, lock)),
+ );
+ }
}
- conflicts.extend(local_conflicts);
+ if failed {
+ log::trace!("Resolution failed");
+ Err(anyhow!("Failed to resolve dependencies"))
+ } else {
+ let mut lock = Lock::new();
+ lock.reserve(candidates.len());
+ for candidate in candidates {
+ lock.entry(candidate.name)
+ .or_insert_with(|| HashSet::new())
+ .insert(candidate.version.unwrap());
+ }
- bail!("No version satisfying requirement {} of {}", req, dep)
+ Ok(lock)
+ }
}
-fn activate_deps<'a>(
- deps: &'a HashMap,
- activated: &mut HashMap<&'a str, HashSet>,
- index: &'a Index,
- conflicts: &mut IndexSet<(&'a str, Version)>,
-) -> Result<()> {
- let mut i = 0;
- let mut retry = true;
- let mut result = Ok(());
- 'retry_loop: while i < 2 && retry {
- i += 1;
- retry = false;
- result = Ok(());
- for (dep, req) in deps.iter() {
- let conflicts_before = conflicts.len();
- if let Err(err) = activate(dep, req, activated, index, conflicts) {
- let conflicts_after = conflicts.len();
- if conflicts_after > conflicts_before {
- retry = true;
- let conflicting = conflicts.last().unwrap();
- if let Some(activated_versions) = activated.get_mut(conflicting.0) {
- activated_versions.remove(&conflicting.1);
- }
- }
+#[derive(Clone)]
+struct Candidate {
+ name: String,
+ req: VersionReq,
+ version: Option,
+ available_versions: Vec,
+}
- result = Err(err);
- continue 'retry_loop;
- }
- }
+impl Candidate {
+ pub fn new(name: &str, req: &VersionReq, index: &Index, lock: Option<&Lock>) -> Self {
+ let mut candidate = Self {
+ name: name.to_owned(),
+ req: req.clone(),
+ version: None,
+ available_versions: Vec::new(),
+ };
+ candidate.update_available_versions(index, lock);
+ candidate
}
- result
+ pub fn update_available_versions(&mut self, index: &Index, lock: Option<&Lock>) {
+ self.available_versions.clear();
+ if let Some(entry) = index.get(&self.name) {
+ self.available_versions.extend(
+ entry
+ .versions
+ .keys()
+ .filter(|v| self.req.matches(v))
+ .map(|v| v.clone())
+ .sorted_unstable_by(|v1, v2| v1.cmp(&v2)),
+ );
+ }
+
+ if let Some(version) = lock
+ .and_then(|lock| lock.get(&self.name))
+ .and_then(|locked_versions| locked_versions.iter().find(|&v| self.req.matches(v)))
+ {
+ // Push the locked version to the top so it gets tried first.
+ self.available_versions.push(version.clone());
+ }
+ }
}
#[cfg(test)]
mod tests {
- use std::{collections::HashMap, str::FromStr};
+ use std::str::FromStr;
- use indexmap::IndexSet;
- use itertools::Itertools;
use maplit::hashmap;
use semver::{Version, VersionReq};
@@ -140,213 +238,77 @@ mod tests {
#[test]
fn basic() {
- for _ in 0..1000 {
- let index: Index = hashmap! {
- String::from("a") => IndexEntry {
- url: url::Url::parse("http://localhost").unwrap(),
- versions: hashmap! {
- Version::from_str("0.1.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("=0.1.0").unwrap()
- }
- },
- Version::from_str("0.1.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("=0.1.0").unwrap()
- }
- },
- Version::from_str("0.2.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("0.2").unwrap()
- }
+ let (manifest, index) = get_test_data();
+
+ simplelog::TermLogger::init(
+ log::LevelFilter::Debug,
+ Default::default(),
+ simplelog::TerminalMode::Stdout,
+ simplelog::ColorChoice::Auto,
+ )
+ .unwrap();
+
+ super::resolve(&manifest, None, &index).unwrap();
+ }
+
+ fn get_test_data() -> (Manifest, Index) {
+ let index: Index = hashmap! {
+ String::from("b") => IndexEntry {
+ url: url::Url::parse("http://localhost").unwrap(),
+ versions: hashmap! {
+ Version::from_str("1.0.0").unwrap() => VersionMetadata {
+ rev: String::new(),
+ deps: hashmap! {
+ String::from("d") => VersionReq::from_str("=1.0").unwrap(),
}
- }
- },
- String::from("b") => IndexEntry {
- url: url::Url::parse("http://localhost").unwrap(),
- versions: hashmap! {
- Version::from_str("0.1.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("=0.1.1").unwrap(),
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.1.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("=0.1.1").unwrap(),
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.2.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("=0.1.1").unwrap(),
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.3.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("c") => VersionReq::from_str("0.2").unwrap(),
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- }
- },
- String::from("c") => IndexEntry {
- url: url::Url::parse("http://localhost").unwrap(),
- versions: hashmap! {
- Version::from_str("0.1.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("d") => VersionReq::from_str("0.1").unwrap(),
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- Version::from_str("0.1.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("d") => VersionReq::from_str("0.1").unwrap(),
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- Version::from_str("0.2.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("d") => VersionReq::from_str("0.1").unwrap(),
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- Version::from_str("0.3.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- Version::from_str("0.4.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("d") => VersionReq::from_str("0.2").unwrap(),
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- }
- },
- String::from("d") => IndexEntry {
- url: url::Url::parse("http://localhost").unwrap(),
- versions: hashmap! {
- Version::from_str("0.1.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("e") => VersionReq::from_str("0.1").unwrap(),
- }
- },
- Version::from_str("0.1.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("e") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.2.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("e") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.2.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("e") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- Version::from_str("0.2.2").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {
- String::from("e") => VersionReq::from_str("0.2").unwrap(),
- }
- },
- }
- },
- String::from("e") => IndexEntry {
- url: url::Url::parse("http://localhost").unwrap(),
- versions: hashmap! {
- Version::from_str("0.1.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {}
- },
- Version::from_str("0.1.1").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {}
- },
- Version::from_str("0.1.2").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {}
- },
- Version::from_str("0.2.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {}
- },
- Version::from_str("1.0.0").unwrap() => VersionMetadata {
- rev: String::new(),
- deps: hashmap! {}
- },
- }
- },
- };
-
- let manifest = Manifest {
- package: Package {
- name: String::from("test"),
- version: Version::new(0, 1, 0),
- },
- dependencies: hashmap! {
- String::from("c") => VersionReq::from_str("0.1").unwrap(),
- String::from("d") => VersionReq::from_str("0.1").unwrap(),
- String::from("e") => VersionReq::from_str("1.0").unwrap(),
- },
- };
-
- let mut activated = HashMap::new();
- let result = super::activate_deps(
- &manifest.dependencies,
- &mut activated,
- &index,
- &mut IndexSet::new(),
- );
+ },
+ }
+ },
+ String::from("c") => IndexEntry {
+ url: url::Url::parse("http://localhost").unwrap(),
+ versions: hashmap! {
+ Version::from_str("1.0.0").unwrap() => VersionMetadata {
+ rev: String::new(),
+ deps: hashmap! {}
+ },
+ Version::from_str("1.1.0").unwrap() => VersionMetadata {
+ rev: String::new(),
+ deps: hashmap! {
+ String::from("d") => VersionReq::from_str("1.1").unwrap(),
+ }
+ },
+ }
+ },
+ String::from("d") => IndexEntry {
+ url: url::Url::parse("http://localhost").unwrap(),
+ versions: hashmap! {
+ Version::from_str("1.0.0").unwrap() => VersionMetadata {
+ rev: String::new(),
+ deps: hashmap! {}
+ },
+ Version::from_str("1.1.0").unwrap() => VersionMetadata {
+ rev: String::new(),
+ deps: hashmap! {}
+ },
+ }
+ },
+ };
- assert!(result.is_ok(), "Activation failed!");
-
- println!("{:#?}", activated);
-
- // The latest compatible version is not always selected.
- // TODO: Fix
- // let expected = hashmap! {
- // "c" => HashSet::from_iter([Version::new(0, 1, 1)]),
- // "d" => HashSet::from_iter([Version::new(0, 1, 0)]),
- // "e" => HashSet::from_iter([Version::new(1, 0, 0), Version::new(0, 1, 2)]),
- // };
- // assert!(
- // activated.len() == expected.len()
- // && activated.iter().all(|(k, v)| {
- // if !expected.contains_key(k) {
- // false
- // } else {
- // let expected_v = expected.get(k).unwrap();
- // expected_v.is_subset(v) && v.is_subset(expected_v)
- // }
- // })
- // );
-
- assert!(activated.values().all(|vset| vset
- .iter()
- .map(|v| Version::new(v.major, v.minor, 0))
- .all_unique()));
- }
+ let manifest = Manifest {
+ package: Package {
+ name: String::from("a"),
+ version: Version::new(1, 0, 0),
+ description: String::from(""),
+ corlib: true,
+ },
+ dependencies: hashmap! {
+ String::from("b") => crate::manifest::Dependency::Simple(VersionReq::from_str("1.0").unwrap()),
+ String::from("c") => crate::manifest::Dependency::Simple(VersionReq::from_str("1.0").unwrap()),
+ String::from("d") => crate::manifest::Dependency::Simple(VersionReq::from_str("1.0").unwrap()),
+ },
+ features: Default::default(),
+ };
+
+ (manifest, index)
}
}
diff --git a/src/web.rs b/src/web.rs
new file mode 100644
index 0000000..95867c4
--- /dev/null
+++ b/src/web.rs
@@ -0,0 +1,16 @@
+use reqwest::blocking::{Client, Response};
+use serde::Serialize;
+
+pub const API_BASE: &'static str = "http://grillpm.vercel.app/api";
+
+pub fn api(sub: S, body: &B) -> anyhow::Result
+where
+ S: AsRef,
+ B: Serialize,
+{
+ Client::new()
+ .post(format!("{}/{}", API_BASE, sub.as_ref()))
+ .json(body)
+ .send()
+ .map_err(anyhow::Error::msg)
+}