From d8be93a740e8cc8103c4f9e260a62244eba1a6a4 Mon Sep 17 00:00:00 2001
From: Igor Tolmachov <me@igorek.dev>
Date: Thu, 17 Aug 2023 15:34:47 +0900
Subject: Add basic lib architecture

---
 .vscode/settings.json |  3 ++-
 src/archive.rs        | 38 ++++++++++++++++++++++++++++++++++++++
 src/io.rs             | 21 +++++++++++++++++++++
 src/lib.rs            |  6 ++++++
 src/result.rs         | 32 ++++++++++++++++++++++++++++++++
 src/zip.rs            | 28 ++++++++++++++++++++++++++++
 6 files changed, 127 insertions(+), 1 deletion(-)
 create mode 100644 src/archive.rs
 create mode 100644 src/io.rs
 create mode 100644 src/result.rs
 create mode 100644 src/zip.rs

diff --git a/.vscode/settings.json b/.vscode/settings.json
index 967c36b..065d76f 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,4 @@
 {
-  "cSpell.words": ["archivator"]
+  "cSpell.words": ["archivator"],
+  "rust-analyzer.linkedProjects": ["./Cargo.toml"]
 }
diff --git a/src/archive.rs b/src/archive.rs
new file mode 100644
index 0000000..a1fe344
--- /dev/null
+++ b/src/archive.rs
@@ -0,0 +1,38 @@
+use crate::result::ArchiveResult;
+use std::{fs::File, path::Path};
+
+use crate::io::{ArchiveRead, ArchiveWrite};
+
+pub struct Archive<IO> {
+    io: IO,
+}
+
+impl<IO: ArchiveRead> Archive<IO> {
+    pub fn open(path: impl AsRef<Path>) -> ArchiveResult<Self>
+    where
+        IO: ArchiveRead<Reader = File>,
+    {
+        Self::reader(File::open(path)?)
+    }
+
+    pub fn reader(reader: IO::Reader) -> ArchiveResult<Self> {
+        Ok(Self {
+            io: IO::new(reader)?,
+        })
+    }
+}
+
+impl<IO: ArchiveWrite> Archive<IO> {
+    pub fn create(path: impl AsRef<Path>) -> ArchiveResult<Self>
+    where
+        IO: ArchiveWrite<Writer = File>,
+    {
+        Self::writer(File::create(path)?)
+    }
+
+    pub fn writer(writer: IO::Writer) -> ArchiveResult<Self> {
+        Ok(Self {
+            io: IO::new(writer)?,
+        })
+    }
+}
diff --git a/src/io.rs b/src/io.rs
new file mode 100644
index 0000000..cea998f
--- /dev/null
+++ b/src/io.rs
@@ -0,0 +1,21 @@
+use std::io::{Read, Seek, Write};
+
+use crate::result::ArchiveResult;
+
+pub trait ArchiveRead
+where
+    Self: Sized,
+{
+    type Reader: Read + Seek;
+
+    fn new(reader: Self::Reader) -> ArchiveResult<Self>;
+}
+
+pub trait ArchiveWrite
+where
+    Self: Sized,
+{
+    type Writer: Write;
+
+    fn new(write: Self::Writer) -> ArchiveResult<Self>;
+}
diff --git a/src/lib.rs b/src/lib.rs
index 8b13789..04496fd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1 +1,7 @@
+pub mod zip;
 
+mod archive;
+mod io;
+mod result;
+
+pub use archive::Archive;
diff --git a/src/result.rs b/src/result.rs
new file mode 100644
index 0000000..47302ae
--- /dev/null
+++ b/src/result.rs
@@ -0,0 +1,32 @@
+use std::error::Error;
+use std::fmt::{Debug, Display};
+use std::io;
+
+pub type ArchiveResult<R> = Result<R, ArchiveError>;
+
+#[derive(Debug)]
+pub enum ArchiveError {
+    IO(io::Error),
+}
+
+impl From<io::Error> for ArchiveError {
+    fn from(value: io::Error) -> Self {
+        Self::IO(value)
+    }
+}
+
+impl Display for ArchiveError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::IO(err) => write!(f, "{err}"),
+        }
+    }
+}
+
+impl Error for ArchiveError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::IO(source) => Some(source),
+        }
+    }
+}
diff --git a/src/zip.rs b/src/zip.rs
new file mode 100644
index 0000000..a5d0fc5
--- /dev/null
+++ b/src/zip.rs
@@ -0,0 +1,28 @@
+use crate::io::{ArchiveRead, ArchiveWrite};
+use crate::result::ArchiveResult;
+use std::io::{Seek, Write};
+use std::{fs::File, io::Read};
+
+pub struct ZipReader<R: Read + Seek = File> {
+    reader: R,
+}
+
+impl<R: Read + Seek> ArchiveRead for ZipReader<R> {
+    type Reader = R;
+
+    fn new(reader: Self::Reader) -> ArchiveResult<Self> {
+        Ok(Self { reader })
+    }
+}
+
+pub struct ZipWriter<W: Write = File> {
+    writer: W,
+}
+
+impl<W: Write> ArchiveWrite for ZipWriter<W> {
+    type Writer = W;
+
+    fn new(writer: Self::Writer) -> ArchiveResult<Self> {
+        Ok(Self { writer })
+    }
+}
-- 
cgit v1.2.3