Version3.0

.github/workflows/rust.yml

@@ -15,12 +15,13 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - uses: dtolnay/rust-toolchain@nightly
 
     - name: Install Rust
       run: rustup component add rustfmt clippy
 
     - name: Run Lint & Tests
       run: |
         cargo clippy -- -D warnings
-        cargo fmt --all -- --check
+        cargo +nightly fmt --all
         cargo test

Cargo.toml

@@ -1,42 +1,46 @@
 [package]
 name = "umya-spreadsheet"
-version = "2.2.0"
+version = "3.0.0"
 authors = ["MathNya <umya.net.info@gmail.com>"]
 repository = "https://github.com/MathNya/umya-spreadsheet"
 keywords = ["excel", "spreadsheet", "xlsx", "reader", "writer"]
+categories = ["parser-implementations", "encoding", "text-processing"]
 license = "MIT"
 readme = "README.md"
 description = "umya-spreadsheet is a library written in pure Rust to read and write xlsx file."
 edition = "2021"
+rust-version = "1.79.0"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 aes = "0.8.4"
-ahash = "0.8.11"
 base64 = "0.22.1"
 byteorder = "1.5"
 cbc = "0.1.2"
 cfb = "0.10.0"
-chrono = { version = "0.4.38", default-features = false, features = ["clock"] }
+chrono = { version = "0.4.39", default-features = false, features = ["clock"] }
 encoding_rs = "0.8.35"
 fancy-regex = "0.14.0"
-getrandom = { version = "0.2.15" }
 hmac = "0.12.1"
 html_parser = "0.7.0"
-image = { version = "0.25.5", optional = true }
-lazy_static = "1.5.0"
+imagesize = "0.14"
 md-5 = "0.10.6"
-regex = "1.11.1"
+num-traits = "0.2.19"
+paste = "1.0.15"
+phf = { version = "0.11.2", features = ["macros"] }
+quick-xml = { version = "0.37.1", features = ["serialize"] }
+rand = "0.8.5"
+rgb = "0.8.50"
 sha2 = "0.10.8"
-thin-vec = "0.2.13"
 thousands = "0.2.0"
-quick-xml = { version = "0.37.1", features = ["serialize"] }
-zip = { version = "2.2.1", default-features = false, features = ["deflate"] }
+zip = { version = "2.2.2", default-features = false, features = ["deflate"] }
+
+[dev-dependencies]
+hex-literal = "0.4.1"
 
 [lib]
 doctest = false
 
 [features]
-js = ["getrandom/js"]
-default = ["image"]
+

README.md

@@ -25,14 +25,14 @@ Please be aware of this.
 Copies the style of the specified column or row.
 ```rust
 let mut book = umya_spreadsheet::reader::xlsx::read(path).unwrap();
-let sheet = book.get_sheet_mut(&0).unwrap();
+let sheet = book.get_sheet_mut(0).unwrap();
 sheet.copy_row_styling(&3, &5, None, None);
 sheet.copy_col_styling(&3, &5, None, None);
 ```
 #### * The function to create a new comment has been implemented.
 ```rust
 let mut book = umya_spreadsheet::reader::xlsx::read(path).unwrap();
-let sheet = book.get_sheet_mut(&0).unwrap();
+let sheet = book.get_sheet_mut(0).unwrap();
 let mut comment = Comment::default();
 comment.new_comment("B2");
 comment.set_text_string("TEST");
@@ -77,25 +77,25 @@ let mut book = umya_spreadsheet::new_file();
 ### Write file
 ```rust
 let path = std::path::Path::new("./tests/result_files/bbb.xlsx");
-let _ = umya_spreadsheet::writer::xlsx::write(&book, path);
+let _unused =  umya_spreadsheet::writer::xlsx::write(&book, path);
 ```
 ### Write file with password
 ```rust
 let path = std::path::Path::new("./tests/result_files/bbb.xlsx");
-let _ = umya_spreadsheet::writer::xlsx::write_with_password(&book, path, "password");
+let _unused =  umya_spreadsheet::writer::xlsx::write_with_password(&book, path, "password");
 ```
 ```rust
 let from_path = std::path::Path::new("./tests/test_files/aaa.xlsx");
 let to_path = std::path::Path::new("./tests/result_files/bbb.xlsx");
-let _ = umya_spreadsheet::writer::xlsx::set_password(&from_path, &to_path, "password");
+let _unused =  umya_spreadsheet::writer::xlsx::set_password(&from_path, &to_path, "password");
 ```
 ### Read Value
 ```rust
 let mut book = umya_spreadsheet::new_file();
 book.get_sheet_by_name("Sheet1").unwrap().get_cell("A1").get_value();
 book.get_sheet_by_name("Sheet1").unwrap().get_cell((1, 1)).get_value();
-book.get_sheet_by_name("Sheet1").unwrap().get_cell((&1, &1)).get_value();
-book.get_sheet_mut(0).unwrap().get_cell((&1, &1)).get_value();
+book.get_sheet_by_name("Sheet1").unwrap().get_cell((1, 1)).get_value();
+book.get_sheet_mut(0).unwrap().get_cell((1, 1)).get_value();
 ```
 ### Change Value
 ```rust
@@ -142,15 +142,15 @@ book.get_sheet_by_name_mut("Sheet1").unwrap()
 
 ### Struct 
 
-Pass the book as a ```Spreadsheet``` to modify it in other functions. 
+Pass the book as a ```Workbook``` to modify it in other functions. 
 
 ```rust
 
 let mut book = umya_spreadsheet::new_file();
-let _ = book.new_sheet("Sheet2");
+let _unused =  book.new_sheet("Sheet2");
 update_excel(&mut book);
 
-fn update_excel(book: &mut Spreadsheet) {
+fn update_excel(book:  &mut Workbook) {
    book.get_sheet_by_name_mut("Sheet2").unwrap().get_cell_mut("A1").set_value("Test"); 
 }
 ```
@@ -184,3 +184,7 @@ Contributions by way of pull requests are welcome!  Please make sure your code u
 
 * `cargo fmt` for formatting
 * [clippy](https://github.com/rust-lang/rust-clippy)
+```rust
+cargo +nightly fmt --all
+cargo clippy -- -D warnings
+```

clippy.toml

@@ -0,0 +1 @@
+allowed-duplicate-crates = [ "thiserror", "thiserror-impl", "miniz_oxide", "syn"]

justfile

@@ -0,0 +1,23 @@
+# Justfile
+
+fmt:
+    cargo +nightly fmt --all
+
+clippy:
+    cargo +nightly clippy
+
+clean:
+    cargo clean
+
+gitclean:
+    git clean -dfx
+
+test:
+    #!/usr/bin/env sh
+    if cargo nextest --help &> /dev/null; then
+        # If successful, run 'cargo nextest run'
+        cargo nextest run
+    else
+        # If not successful, run 'cargo test'
+        cargo test
+    fi

rustfmt.toml

@@ -0,0 +1,58 @@
+# Edition and Feature Flags
+style_edition = "2024"
+unstable_features = true
+
+# Brace and Parentheses Style
+brace_style = "SameLineWhere"
+remove_nested_parens = true
+
+# Layout and Line Management
+condense_wildcard_suffixes = true
+error_on_line_overflow = true
+fn_params_layout = "Tall"
+overflow_delimited_expr = false
+type_punctuation_density = "Wide"
+where_single_line = false
+
+# Comment and Documentation Formatting
+normalize_comments = true
+normalize_doc_attributes = true
+wrap_comments = true
+format_code_in_doc_comments = true
+
+# Attribute and Shorthand Usage
+inline_attribute_width = 0
+use_field_init_shorthand = true
+use_try_shorthand = true
+use_small_heuristics = "Default"
+
+# Match and Block Formatting
+match_arm_blocks = true
+match_arm_leading_pipes = "Never"
+match_block_trailing_comma = false
+
+# Code Structure and Reordering
+reorder_impl_items = true
+reorder_modules = true
+
+# String and Macro Formatting
+format_macro_matchers = true
+format_strings = true
+
+# Indentation Style
+indent_style = "Block"
+
+# Imports Configuration
+group_imports = "StdExternalCrate"
+imports_granularity = "Crate"
+imports_layout = "Vertical"
+reorder_imports = true
+
+# Module and Struct Configuration
+struct_field_align_threshold = 50
+
+# Ignored Files
+ignore = [
+    "src/helper/const_str.rs",
+    "src/helper/crypt/constants.rs",
+]

src/helper/address.rs

@@ -1,17 +1,59 @@
-use fancy_regex::Regex;
+use crate::helper::utils::compile_regex;
 
+#[must_use]
 pub fn split_address(address: &str) -> (&str, &str) {
     address
         .rsplit_once('!')
-        .map(|(sheet_name, range)| (sheet_name.trim_matches(&['\'', '"'][..]), range))
-        .unwrap_or(("", address))
+        .map_or(("", address), |(sheet_name, range)| {
+            (sheet_name.trim_matches(&['\'', '"'][..]), range)
+        })
 }
 
+#[must_use]
 pub fn join_address(sheet_name: &str, address: &str) -> String {
-    if sheet_name == "" {
+    if sheet_name.is_empty() {
         return address.to_string();
     }
-    format!("{}!{}", sheet_name, address)
+    format!("{sheet_name}!{address}")
+}
+
+/// Checks if the given input string is a valid address format.
+///
+/// The address format is defined by the following regular expression:
+/// `^([^\:\\\?$$$$\/\*]+\!)?(\$?[A-Z]{1,3}\$?[0-9]+)(\:\$?[A-Z]{1,3}\$?[0-9]+)?
+/// $`.
+///
+/// # Parameters
+///
+/// - `input`: A string slice that can be converted to a string reference. This
+///   is the input string to be checked against the address format.
+///
+/// # Returns
+///
+/// Returns `true` if the input string matches the address format, and `false`
+/// otherwise.
+///
+/// # Panics
+///
+/// This function may panic if the regular expression fails to compile. However,
+/// since the regular expression is initialized only once and is hardcoded, this
+/// is unlikely to occur unless there is a bug in the regex itself. The panic
+/// will occur during the first call to this function if the regex is invalid.
+///
+/// # Examples
+///
+/// ```
+/// let valid_address = "$A1";
+/// assert!(is_address(valid_address));
+///
+/// let invalid_address = "invalid_address";
+/// assert!(!is_address(invalid_address));
+/// ```
+pub fn is_address<S: AsRef<str>>(input: S) -> bool {
+    let regex = compile_regex!(
+        r"^([^\:\\\?\[\]\/\*]+\!)?(\$?[A-Z]{1,3}\$?[0-9]+)(\:\$?[A-Z]{1,3}\$?[0-9]+)?$"
+    );
+    regex.is_match(input.as_ref()).unwrap()
 }
 
 #[test]
@@ -23,13 +65,6 @@ fn split_address_test() {
     assert_eq!(split_address(r#"'she"et1'!A1:B2"#), (r#"she"et1"#, "A1:B2"));
 }
 
-pub fn is_address<S: AsRef<str>>(input: S) -> bool {
-    let re =
-        Regex::new(r"^([^\:\\\?\[\]\/\*]+\!)?(\$?[A-Z]{1,3}\$?[0-9]+)(\:\$?[A-Z]{1,3}\$?[0-9]+)?$")
-            .unwrap();
-    re.is_match(input.as_ref()).unwrap()
-}
-
 #[test]
 fn is_address_test() {
     assert!(is_address("A1"));

src/helper/binary.rs

@@ -1,27 +1,47 @@
-use crate::structs::MediaObject;
-use base64::{engine::general_purpose::STANDARD, Engine as _};
-use std::fs;
-use std::fs::File;
-use std::io::BufReader;
-use std::io::Cursor;
-use std::io::Read;
+use std::{
+    fs,
+    path::Path,
+};
 
-#[inline]
-pub fn get_binary_data(path: &str) -> Vec<u8> {
-    let path = std::path::Path::new(path);
-    let mut buf = Vec::new();
+use crate::structs::MediaObject;
 
-    let file = File::open(path).unwrap();
-    BufReader::new(file).read_to_end(&mut buf).unwrap();
-    return buf;
-}
+/// Creates a `MediaObject` from the file at the specified path.
+///
+/// # Parameters
+///
+/// - `path`: A reference to a path from which to create the `MediaObject`.
+///
+/// # Returns
+///
+/// Returns a `MediaObject` populated with the image data, name, and title
+/// extracted from the file at the specified path.
+///
+/// # Panics
+///
+/// This function will panic if the file cannot be read, as it calls `unwrap()`
+/// on the result of `get_binary_data(path)`. Ensure that the file exists and is
+/// readable before calling this function.
+///
+/// # Example
+///
+/// ```
+/// let media_object = make_media_object("path/to/image.png");
+/// ```
+#[must_use]
+pub fn make_media_object<P: AsRef<Path>>(path: P) -> MediaObject {
+    let path = path.as_ref();
+    let file_name = path
+        .file_name()
+        .and_then(|name| name.to_str())
+        .unwrap_or("");
+    let title = path
+        .file_stem()
+        .and_then(|stem| stem.to_str())
+        .unwrap_or("");
 
-#[inline]
-pub fn make_media_object(path: &str) -> MediaObject {
-    let name = path.split("/").last().unwrap();
     let mut obj = MediaObject::default();
-    obj.set_image_data(get_binary_data(path));
-    obj.set_image_name(name);
-    obj.set_image_title(name.split(".").next().unwrap_or(""));
+    obj.set_image_data(fs::read(path).unwrap());
+    obj.set_image_name(file_name);
+    obj.set_image_title(title);
     obj
 }