Merge pull request #62 from pontem-network/some_fix

Several improvements.

Author: RIg410

dove/src/cmd/init.rs

@@ -13,6 +13,8 @@ use lang::compiler::dialects::DialectName;
 use crate::cmd::Cmd;
 use crate::context::{Context, get_context};
 use crate::manifest::{DoveToml, MANIFEST};
+use lazy_static::lazy_static;
+use regex::Regex;
 
 const PONT_STDLIB: &str =
     r#"{ git = "https://github.com/pontem-network/move-stdlib", tag = "v0.1.2" }"#;
@@ -88,6 +90,12 @@ impl Cmd for Init {
             .and_then(|name| name.to_str())
             .ok_or_else(|| anyhow!("Failed to extract directory name."))?;
 
+        if !is_valid_name(name) {
+            return Err(anyhow!(
+                "Invalid project name. Allowed symbols a-z, A-Z, 0-9,_,-"
+            ));
+        }
+
         if !self.minimal {
             fs::create_dir_all(ctx.path_for(&ctx.manifest.layout.modules_dir))?;
             fs::create_dir_all(ctx.path_for(&ctx.manifest.layout.scripts_dir))?;
@@ -131,3 +139,10 @@ dependencies = [
         Ok(())
     }
 }
+
+fn is_valid_name(text: &str) -> bool {
+    lazy_static! {
+        static ref RE: Regex = Regex::new(r"^[\w\-_]{1,64}$").unwrap();
+    }
+    RE.is_match(text)
+}

dove/src/cmd/metadata.rs

@@ -1,12 +1,13 @@
+use std::path::Path;
+
 use anyhow::{Error, Result};
 use serde::Serialize;
 use structopt::StructOpt;
-use std::path::Path;
 
-use crate::index::resolver::git;
 use crate::cmd::Cmd;
 use crate::context::{Context, str_path};
-use crate::manifest::{Dependence, Git, Layout};
+use crate::index::resolver::git;
+use crate::manifest::{Dependence, Git, Layout, MANIFEST, read_manifest};
 use crate::stdoutln;
 
 fn into_metadata(mut ctx: Context) -> Result<DoveMetadata, Error> {
@@ -98,27 +99,67 @@ pub struct GitMetadata {
     /// Path.
     pub path: Option<String>,
     /// Local path.
-    pub local_path: Option<String>,
+    pub local_paths: Vec<String>,
 }
 
 impl GitMetadata {
     /// Create a new git metadata.
     pub fn new(git: Git, ctx: &Context) -> Result<GitMetadata, Error> {
         let path: &Path = ctx.manifest.layout.deps.as_ref();
-        let path = ctx.path_for(path.join(&git::make_local_name(&git)));
-        let local_path = if path.exists() {
-            Some(str_path(path)?)
-        } else {
-            None
-        };
+        let pac_path = ctx.path_for(path.join(&git::make_local_name(&git)));
+        let mut local_paths = Vec::new();
+
+        if pac_path.exists() {
+            let manifest_path = pac_path.join(MANIFEST);
+
+            let manifest = if manifest_path.exists() {
+                match read_manifest(&manifest_path) {
+                    Ok(manifest) => Some(manifest),
+                    Err(err) => {
+                        log::error!("Failed to parse dove manifest:{:?}. Err:{}", pac_path, err);
+                        None
+                    }
+                }
+            } else {
+                None
+            };
+
+            if let Some(manifest) = manifest {
+                let modules_dir = pac_path.join(manifest.layout.modules_dir);
+                if modules_dir.exists() {
+                    local_paths.push(str_path(modules_dir)?);
+                }
+                if let Some(deps) = manifest.package.dependencies {
+                    for dep in deps.deps.iter() {
+                        if let Dependence::Path(path) = dep {
+                            let local_dep_path = pac_path.join(path.as_ref()).canonicalize();
+                            if let Ok(local_dep_path) = local_dep_path {
+                                if local_dep_path.starts_with(&pac_path) {
+                                    local_paths.push(str_path(local_dep_path)?);
+                                    continue;
+                                }
+                            }
+
+                            log::warn!(
+                                "Package '{}' has invalid dependency:{:?}.",
+                                git.git,
+                                path
+                            );
+                        }
+                    }
+                }
+            } else {
+                local_paths.push(str_path(pac_path)?);
+            }
+        }
 
         Ok(GitMetadata {
             git: git.git,
             branch: git.branch,
             rev: git.rev,
             tag: git.tag,
             path: git.path,
-            local_path,
+            local_paths,
         })
     }
 }

dove/src/cmd/new.rs

@@ -5,7 +5,6 @@ use crate::cmd::Cmd;
 use crate::context::{Context, get_context};
 use crate::cmd::init::Init;
 use structopt::StructOpt;
-use move_core_types::identifier::Identifier;
 use std::path::PathBuf;
 use crate::manifest::DoveToml;
 
@@ -52,8 +51,6 @@ impl Cmd for New {
     }
 
     fn apply(self, mut ctx: Context) -> Result<(), Error> {
-        Identifier::new(self.project_name.as_str())?;
-
         let project_dir = ctx.project_dir.join(&self.project_name);
         if project_dir.exists() {
             return Err(anyhow!("destination `{:?}` already exists", project_dir));

dove/src/index/resolver/git.rs

@@ -39,6 +39,11 @@ pub fn resolve(ctx: &Context, git: &Git) -> Result<PathBuf, Error> {
             fs::remove_dir_all(&repo_path)?;
             return Err(err);
         }
+
+        if let Err(err) = fs::remove_dir_all(&repo_path.join(".git")) {
+            warn!("Failed to remove .git in repo {:?}. {}", repo_path, err);
+        }
+
         if let Some(path_in_repo) = &git.path {
             let source_path = repo_path
                 .join(&path_in_repo)

dove/src/manifest.rs

@@ -277,6 +277,12 @@ pub struct DepPath {
     pub path: String,
 }
 
+impl AsRef<str> for DepPath {
+    fn as_ref(&self) -> &str {
+        &self.path
+    }
+}
+
 /// Project dependencies.
 #[derive(Debug, Clone, PartialEq, Eq, Default)]
 pub struct Dependencies {