adding Reset and no_search to support input of ontology list file

Author: gtfierro

cli/Cargo.toml

@@ -22,3 +22,4 @@ env_logger.workspace = true
 oxigraph.workspace = true
 chrono.workspace = true
 walkdir.workspace = true
+serde_json.workspace = true

cli/src/main.rs

@@ -1,10 +1,13 @@
 use anyhow::Result;
 use clap::{Parser, Subcommand};
+use ontoenv::config::{Config, EnvironmentConfig};
 use ontoenv::ontology::{GraphIdentifier, OntologyLocation};
 use ontoenv::util::write_dataset_to_file;
-use ontoenv::{config::Config, OntoEnv, ontology_config::{OntologyConfig, OntologyLocation}};
+use ontoenv::OntoEnv;
 use oxigraph::model::{NamedNode, NamedNodeRef};
+use serde_json;
 use std::env::current_dir;
+use std::fs::File;
 use std::path::PathBuf;
 
 #[derive(Debug, Parser)]
@@ -46,14 +49,15 @@ enum Commands {
         /// Glob patterns for which files to exclude, defaults to []
         #[clap(long, short, num_args = 1..)]
         excludes: Vec<String>,
+        /// Recreate the environment if it already exists
         #[clap(long, short, default_value = "false")]
         recreate: bool,
-    },
-    /// Fetch all ontologies and their dependencies from a configuration file
-    Fetch {
-        /// Path to the environment JSON configuration file
-        #[clap(long, short)]
-        config_file: PathBuf,
+        /// A JSON file containing a list of ontologies to add to the environment
+        #[clap(long = "list", short = 'l')]
+        ontology_list_file: Option<String>,
+        /// Do not search for ontologies in the search directories
+        #[clap(long = "no-search", short = 'n', action)]
+        no_search: bool,
     },
     /// Prints the version of the ontoenv binary
     Version,
@@ -106,6 +110,8 @@ enum Commands {
     },
     /// Run the doctor to check the environment for issues
     Doctor,
+    /// Reset the ontology environment by removing the .ontoenv directory
+    Reset,
 }
 
 fn main() -> Result<()> {
@@ -127,8 +133,11 @@ fn main() -> Result<()> {
             includes,
             excludes,
             recreate,
+            ontology_list_file,
+            no_search,
         } => {
             // if search_directories is empty, use the current directory
+            println!("no search? {}", no_search);
             let config = Config::new(
                 current_dir()?,
                 search_directories,
@@ -138,8 +147,19 @@ fn main() -> Result<()> {
                 strict,
                 offline,
                 policy,
+                no_search,
             )?;
             let mut env = OntoEnv::new(config, recreate)?;
+
+            // if an ontology config file is provided, load it and add the ontologies
+            if let Some(file) = ontology_list_file {
+                let file = File::open(file)?;
+                let config: EnvironmentConfig = serde_json::from_reader(file)?;
+                for ont in config.ontologies {
+                    env.add(ont.location)?;
+                }
+            }
+
             env.update()?;
             env.save_to_directory()?;
         }
@@ -276,27 +296,12 @@ fn main() -> Result<()> {
             let env = OntoEnv::from_file(&path, true)?;
             env.doctor();
         }
-        Commands::Fetch { config_file } => {
-            // Load the configuration from the specified JSON file
-            let config: EnvironmentConfig = serde_json::from_reader(std::fs::File::open(&config_file)?)?;
-
-            // Create a new OntoEnv with the default configuration
-            let mut env = OntoEnv::new(Config::default(), false)?;
-
-            // Iterate over each ontology in the configuration and add it to the environment
-            for ontology in config.ontologies {
-                let location = match ontology.location {
-                    OntologyLocation::File { file } => OntologyLocation::File(file),
-                    OntologyLocation::Uri { uri } => OntologyLocation::Url(uri),
-                };
-                env.add(location)?;
+        Commands::Reset => {
+            // remove .ontoenv directory
+            let path = current_dir()?.join(".ontoenv");
+            if path.exists() {
+                std::fs::remove_dir_all(path)?;
             }
-
-            // Update the environment to fetch dependencies
-            env.update()?;
-
-            // Save the updated environment
-            env.save_to_directory()?;
         }
     }
 

lib/src/config.rs

@@ -1,3 +1,4 @@
+use crate::ontology::OntologyLocation;
 use crate::policy::{DefaultPolicy, ResolutionPolicy};
 use anyhow::Result;
 use glob::{Pattern, PatternError};
@@ -25,6 +26,18 @@ where
     patterns.map_err(serde::de::Error::custom)
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct EnvironmentConfig {
+    pub ontologies: Vec<OntologyConfig>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct OntologyConfig {
+    #[serde(flatten)]
+    pub location: OntologyLocation,
+    pub version: Option<String>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct Config {
     pub root: PathBuf,
@@ -63,6 +76,7 @@ impl Config {
         strict: bool,
         offline: bool,
         resolution_policy: String,
+        no_search: bool,
     ) -> Result<Self>
     where
         I: IntoIterator,
@@ -72,9 +86,16 @@ impl Config {
         K: IntoIterator<Item = PathBuf>,
     {
         // if search directories are empty, add the root. Otherwise, use the provided search directories
+        // if no_search is true, then do not default to the root directory
         let search_directories = search_directories
             .map(|dirs| dirs.into_iter().collect())
-            .unwrap_or_else(|| vec![root.clone()]);
+            .unwrap_or_else(|| {
+                if no_search {
+                    vec![]
+                } else {
+                    vec![root.clone()]
+                }
+            });
 
         let mut config = Config {
             root,
@@ -135,6 +156,7 @@ impl Config {
             strict,
             offline,
             DefaultPolicy.policy_name().to_string(),
+            false,
         )
     }
 

lib/src/lib.rs

@@ -2,7 +2,6 @@ extern crate derive_builder;
 
 pub mod config;
 pub mod consts;
-pub mod environment_config;
 pub mod doctor;
 pub mod errors;
 pub mod ontology;
@@ -71,7 +70,9 @@ pub struct EnvironmentStatus {
 // impl Display pretty print for EnvironmentStatus
 impl std::fmt::Display for EnvironmentStatus {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        let exists = if self.exists { "Yes" } else { "No" };
+        if !self.exists {
+            return write!(f, "No environment found");
+        }
         // convert last_updated to local timestamp, or display N/A if
         // it is None
         let last_updated = match self.last_updated {
@@ -202,7 +203,6 @@ impl OntoEnv {
 
     /// Calculates and returns the environment status
     pub fn status(&self) -> Result<EnvironmentStatus> {
-        let store = self.store()?;
         // get time modified of the self.store_path() directory
         let last_updated: DateTime<Utc> = std::fs::metadata(self.store_path()?)?.modified()?.into();
         // get the size of the .ontoenv directory on disk
@@ -277,6 +277,14 @@ impl OntoEnv {
 
     /// Load an OntoEnv from the given path
     pub fn from_file(path: &Path, read_only: bool) -> Result<Self> {
+        // if path does not exist, return an error
+        if !path.exists() {
+            return Err(anyhow::anyhow!(
+                "OntoEnv environment not found at: {:?}",
+                path
+            ));
+        }
+
         let file = std::fs::File::open(path)?;
         let reader = BufReader::new(file);
         let env: OntoEnv = serde_json::from_reader(reader)?;

lib/src/ontology.rs

@@ -94,7 +94,9 @@ impl GraphIdentifier {
 
 #[derive(Serialize, Deserialize, Hash, Clone, Eq, PartialEq, Debug)]
 pub enum OntologyLocation {
+    #[serde(rename = "file")]
     File(PathBuf),
+    #[serde(rename = "url")]
     Url(String),
 }
 

python/src/lib.rs

@@ -158,6 +158,7 @@ impl Config {
                 strict,
                 offline,
                 resolution_policy.to_string(),
+                false,
             )
             .map_err(|e| PyErr::new::<pyo3::exceptions::PyValueError, _>(e.to_string()))?,
         })