initial commit

Signed-off-by: sisungo <[email protected]>

src/lib.rs

@@ -0,0 +1,113 @@
+mod common;
+pub mod config;
+pub mod install;
+pub mod link;
+pub mod local;
+pub mod package;
+pub mod profile;
+pub mod remove;
+pub mod repo;
+pub mod version;
+
+use common::fs::LockGuard;
+use config::AllConfig;
+use local::{Cache, DataDir, LocalDb};
+use profile::Profile;
+use rust_i18n::t;
+
+rust_i18n::i18n!("locales/libpackie", fallback = "en");
+
+/// Main Packie state.
+#[derive(Debug)]
+pub struct Packie {
+    profile: Profile,
+    local_db: LocalDb,
+    config: AllConfig,
+    local_data: DataDir,
+    cache: Cache,
+    _lock_guard: LockGuard,
+}
+impl Packie {
+    /// Returns profile of the Packie instance.
+    pub fn profile(&self) -> &Profile {
+        &self.profile
+    }
+
+    /// Returns cache manager for the Packie instance.
+    pub fn cache(&self) -> &Cache {
+        &self.cache
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PackieBuilder {
+    profile: Profile,
+    readonly: bool,
+    nonblocking: bool,
+}
+impl PackieBuilder {
+    pub fn new() -> Self {
+        Self {
+            profile: Profile::builtin(),
+            readonly: false,
+            nonblocking: false,
+        }
+    }
+
+    pub fn readonly(mut self, val: bool) -> Self {
+        self.readonly = val;
+        self
+    }
+
+    pub fn nonblocking(mut self, val: bool) -> Self {
+        self.nonblocking = val;
+        self
+    }
+
+    pub fn profile(mut self, val: Profile) -> Self {
+        self.profile = val;
+        self
+    }
+
+    pub fn build(self) -> Result<Packie, BuildPackieError> {
+        let mut _lock_guard = LockGuard::noop();
+        if !self.readonly {
+            _ = std::fs::create_dir_all(&self.profile.packie_data_dir);
+            _ = std::fs::create_dir_all(&self.profile.packie_cache_dir);
+            _ = std::fs::create_dir_all(&self.profile.packie_config_dir);
+            _ = std::fs::create_dir_all(&self.profile.pkg_dir);
+
+            let lock_path = self.profile.packie_data_dir.join("packie.lock");
+            _lock_guard =
+                LockGuard::open(lock_path, self.nonblocking).map_err(BuildPackieError::Lock)?;
+        }
+        let local_db_path = self.profile.packie_data_dir.join(LocalDb::FILENAME);
+        let open_local_db = if self.readonly {
+            LocalDb::open_ro
+        } else {
+            LocalDb::open_rw
+        };
+        let local_db = open_local_db(local_db_path).map_err(BuildPackieError::LocalDb)?;
+        let config = AllConfig::open(&self.profile.packie_config_dir);
+        let cache = Cache(self.profile.packie_cache_dir.clone());
+        let local_data = DataDir(self.profile.packie_data_dir.clone());
+
+        Ok(Packie {
+            profile: self.profile,
+            local_db,
+            config,
+            cache,
+            local_data,
+            _lock_guard,
+        })
+    }
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum BuildPackieError {
+    #[error("{0}")]
+    LocalDb(rusqlite::Error),
+
+    #[error("{}", t!("BuildPackieError.Lock", error = .0))]
+    Lock(std::io::Error),
+}