Implemented Requirements Module and added test file for it

Author: Kiwifuit

src/requirements/mod.rs

@@ -4,8 +4,45 @@ use std::fmt::Display;
 use std::fs::{read_to_string, File};
 use std::path::PathBuf;
 
+use anyhow::{bail, Result};
+use package_version::PackageVersion;
+use pomsky_macro::pomsky;
+use regex::Regex;
+
+static REQUIREMENTS_LINE_PARSER: &str = pomsky!(
+    "v"?
+    (
+        :op("==" | ">=" | "<=")
+    )
+);
+
 pub enum PyRequirementsOperator {
     EqualTo,
+    GreaterThan,
+    LesserThan,
+}
+
+impl PyRequirementsOperator {
+    /// Creates a new `PyRequirementsOperator`
+    ///
+    /// # Usage
+    /// ```
+    /// let a  = PyRequirementsOperator::new("==").unwrap(); // Returns PyRequirementsOperator::EqualTo
+    /// let b  = PyRequirementsOperator::new("BigChungus"); // Returns an Err
+    /// let c  = PyRequirementsOperator::new("!!").unwrap(); // Also returns an Err
+    /// ```
+    fn new(op: &str) -> Result<Self, String> {
+        if op.len() > 2 {
+            return Err(format!("Operator is {} long", op.len()));
+        }
+
+        match op {
+            "==" => Ok(Self::EqualTo),
+            ">=" => Ok(Self::GreaterThan),
+            "<=" => Ok(Self::LesserThan),
+            _ => Err(format!("Unknown Operator: {}", op)),
+        }
+    }
 }
 
 impl Default for PyRequirementsOperator {
@@ -21,6 +58,8 @@ impl Display for PyRequirementsOperator {
             "{}",
             match self {
                 Self::EqualTo => "==",
+                Self::GreaterThan => ">=",
+                Self::LesserThan => "<=",
             }
         )
     }
@@ -29,13 +68,34 @@ impl Display for PyRequirementsOperator {
 /// Represents a module in a `requirements.txt` file
 pub struct PyRequirementsModule {
     pub package: String,
-    pub version: String,
+    pub version: PackageVersion,
     pub operator: PyRequirementsOperator,
 }
 
 impl PyRequirementsModule {
-    fn new(raw: String) -> Self {
-        todo!();
+    fn new(raw: &str) -> Result<Self> {
+        let regex = Regex::new(REQUIREMENTS_LINE_PARSER).unwrap();
+        let res = match regex.captures(raw) {
+            Some(caps) => caps,
+            None => bail!("unable to parse line"),
+        };
+
+        let op = res.name("op").unwrap();
+        let (op_start, op_end) = (op.start(), op.end());
+
+        Ok(Self {
+            operator: match PyRequirementsOperator::new(
+                res.name("op").unwrap().as_str(),
+            ) {
+                Ok(op) => op,
+                Err(err) => bail!("Op Parsing returned an error: {}", err),
+            },
+            package: raw[..op_start].to_string(),
+            version: match PackageVersion::new(&raw[op_end..]) {
+                Ok(ver) => ver,
+                Err(err) => bail!("Package Versioner returned an error: {}", err),
+            },
+        })
     }
 }
 
@@ -53,19 +113,37 @@ pub struct PyRequirements {
 
 impl PyRequirements {
     pub fn new(path: &PathBuf) -> Result<(), String> {
+        // Check if the path specified is a file
         if !path.is_file() {
             return Err(format!("{:?} is not a file!", path.to_str().unwrap()));
-        } else {
-            let raw: Vec<String> = read_to_string(&path)
-                .expect(
-                    format!("Unable to read file: {:?}", path.to_str().unwrap())
-                        .as_str(),
-                )
-                .split("\n")
-                .map(|item| item.to_string())
-                .collect();
         }
 
-        return Ok(());
+        // Then check if that file is a "requirements.txt" file
+        // TODO: Use some magic to see if the file can be parsed
+        //       and then use that to check instead of this
+        if !path.ends_with("requirements.txt") {
+            return Err(format!(
+                "File specified is not a 'requirements.txt' file: {:?}",
+                path.to_str().unwrap()
+            ));
+        }
+
+        let binding = read_to_string(&path).expect(
+            format!("Unable to read file: {:?}", path.to_str().unwrap()).as_str(),
+        );
+
+        let raw: Vec<&str> = binding.split("\n").collect();
+        let mut requirements = Vec::<PyRequirementsModule>::new();
+
+        for (lineno, line) in raw.iter().enumerate() {
+            match PyRequirementsModule::new(line) {
+                Ok(py_mod) => requirements.push(py_mod),
+                Err(err) => {
+                    println!("Unable to parse line {}: {}", lineno, err)
+                }
+            }
+        }
+
+        Ok(())
     }
 }

test/README.txt

@@ -0,0 +1,4 @@
+This folder is for testing purposes. All files in this directory (except this README)
+has been put here to test this codebase's functions
+
+- Kiwifruit

test/requirements.txt

@@ -0,0 +1,29 @@
+aiohttp==3.8.1
+aiosignal==1.2.0
+async-timeout==4.0.2
+attrs==21.4.0
+beautifulsoup4==4.10.0
+black==22.3.0
+certifi==2021.10.8
+charset-normalizer==2.0.12
+click==8.1.2
+commonmark==0.9.1
+expiringdict==1.2.1
+frozenlist==1.3.0
+idna==3.3
+multidict==6.0.2
+mypy-extensions==0.4.3
+NHentai-API==0.0.19
+pathspec==0.9.0
+platformdirs==2.5.1
+Pygments==2.11.2
+PyYAML==6.0
+requests==2.27.1
+retrying==1.3.3
+rich==12.1.0
+six==1.16.0
+soupsieve==2.3.2
+textual==0.1.17
+tomli==2.0.1
+urllib3==1.26.9
+yarl==1.7.2