chore: get crate ready for release

.github/workflows/build.yaml

@@ -11,10 +11,11 @@ jobs:
   build:
 
     runs-on: ubuntu-latest
-
     steps:
     - uses: actions/checkout@v3
     - name: Build
       run: cargo build --verbose
+    - name: Run lint
+      run: cargo clippy --verbose
     - name: Run tests
       run: cargo test --verbose

.gitignore

@@ -1,2 +1,3 @@
+/.idea
 /target
 /Cargo.lock

Cargo.toml

@@ -1,11 +1,20 @@
 [package]
 name = "fcmlib"
 version = "0.1.0"
+repository = "https://github.com/justjanne/fcmlib/"
+authors = ["Janne Mareike Koschinski <[email protected]>"]
+description = "Library to read and write Brother's FCM plotter files"
+readme = "README.md"
+license = "MPL-2.0"
+keywords = ["plotter", "parser"]
+categories = ["encoding"]
 edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+exclude = ["/.*", "/tests"]
 
 [dependencies]
 nom = "7.1.3"
 log = "0.4.20"
-bitflags = "2.4.2"
+bitflags = "2.4.2"
+
+[lints.rust]
+unsafe_code = "forbid"

src/encode.rs

@@ -13,84 +13,84 @@ pub(crate) trait Encode {
 
 impl Encode for u8 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for u16 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for u32 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for u64 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for u128 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for i8 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for i16 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for i32 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for i64 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for i128 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for f32 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }
 
 impl Encode for f64 {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
-        buffer.write(&self.to_le_bytes())?;
+        buffer.write_all(&self.to_le_bytes())?;
         Ok(())
     }
 }

src/file_header.rs

@@ -86,7 +86,7 @@ pub(crate) fn read_file_header(input: &[u8]) -> IResult<&[u8], FileHeader> {
 impl Encode for FileHeader {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
         self.variant.encode(buffer)?;
-        buffer.write(&self.version.as_bytes()[0..4])?;
+        buffer.write_all(&self.version.as_bytes()[0..4])?;
         self.content_id.encode(buffer)?;
 
         let mut variable_header: Vec<u8> = vec![];
@@ -101,15 +101,15 @@ impl Encode for FileHeader {
         self.thumbnail_block_size_height
             .encode(&mut variable_header)?;
         (self.thumbnail.len() as u32).encode(&mut variable_header)?;
-        variable_header.write(&self.thumbnail)?;
+        variable_header.write_all(&self.thumbnail)?;
 
         self.generator.encode(&mut variable_header)?;
         if let Some(print_to_cut) = &self.print_to_cut {
             (*print_to_cut as u32).encode(&mut variable_header)?;
         }
 
         (variable_header.len() as u32).encode(buffer)?;
-        buffer.write(&variable_header)?;
+        buffer.write_all(&variable_header)?;
 
         Ok(())
     }

src/file_type.rs

@@ -23,8 +23,8 @@ pub(crate) fn read_file_type(input: &[u8]) -> IResult<&[u8], FileType> {
 impl Encode for FileType {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
         match self {
-            FileType::Cut => buffer.write(&0x10u32.to_le_bytes())?,
-            FileType::PrintAndCut => buffer.write(&0x38u32.to_le_bytes())?,
+            FileType::Cut => buffer.write_all(&0x10u32.to_le_bytes())?,
+            FileType::PrintAndCut => buffer.write_all(&0x38u32.to_le_bytes())?,
         };
         Ok(())
     }

src/file_variant.rs

@@ -23,8 +23,8 @@ pub(crate) fn read_variant(input: &[u8]) -> IResult<&[u8], FileVariant> {
 impl Encode for FileVariant {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
         match self {
-            FileVariant::FCM => buffer.write("#FCM".as_bytes())?,
-            FileVariant::VCM => buffer.write("#VCM".as_bytes())?,
+            FileVariant::FCM => buffer.write_all("#FCM".as_bytes())?,
+            FileVariant::VCM => buffer.write_all("#VCM".as_bytes())?,
         };
         Ok(())
     }

src/generator.rs

@@ -46,11 +46,11 @@ impl Encode for Generator {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
         match self {
             Generator::App(version) => {
-                buffer.write("1APP".as_bytes())?;
+                buffer.write_all("1APP".as_bytes())?;
                 version.encode(buffer)?;
             }
             Generator::Web(version) => {
-                buffer.write("1WEB".as_bytes())?;
+                buffer.write_all("1WEB".as_bytes())?;
                 version.encode(buffer)?;
             }
             Generator::Device(id, version) => {

src/lib.rs

@@ -40,6 +40,3 @@ mod point;
 mod segment_bezier;
 mod segment_line;
 mod util;
-
-#[cfg(test)]
-mod tests;

src/outline.rs

@@ -27,14 +27,14 @@ pub(crate) fn read_outline(input: &[u8]) -> IResult<&[u8], Outline> {
 fn read_outline_line(input: &[u8]) -> IResult<&[u8], Outline> {
     map(
         length_count(le_u32, segment_line::read_segment_line),
-        |segments| Outline::Line(segments),
+        Outline::Line,
     )(input)
 }
 
 fn read_outline_bezier(input: &[u8]) -> IResult<&[u8], Outline> {
     map(
         length_count(le_u32, segment_bezier::read_segment_bezier),
-        |segments| Outline::Bezier(segments),
+        Outline::Bezier,
     )(input)
 }
 
@@ -43,14 +43,14 @@ impl Encode for Outline {
         match self {
             Outline::Line(segments) => {
                 OutlineTag::Line.encode(buffer)?;
-                buffer.write(&(segments.len() as u32).to_le_bytes())?;
+                buffer.write_all(&(segments.len() as u32).to_le_bytes())?;
                 for segment in segments {
                     segment.encode(buffer)?;
                 }
             }
             Outline::Bezier(segments) => {
                 OutlineTag::Bezier.encode(buffer)?;
-                buffer.write(&(segments.len() as u32).to_le_bytes())?;
+                buffer.write_all(&(segments.len() as u32).to_le_bytes())?;
                 for segment in segments {
                     segment.encode(buffer)?;
                 }

src/outline_tag.rs

@@ -23,8 +23,8 @@ pub(crate) fn read_outline_tag(input: &[u8]) -> IResult<&[u8], OutlineTag> {
 impl Encode for OutlineTag {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
         match self {
-            OutlineTag::Line => buffer.write(&0u32.to_le_bytes())?,
-            OutlineTag::Bezier => buffer.write(&1u32.to_le_bytes())?,
+            OutlineTag::Line => buffer.write_all(&0u32.to_le_bytes())?,
+            OutlineTag::Bezier => buffer.write_all(&1u32.to_le_bytes())?,
         };
         Ok(())
     }

src/path.rs

@@ -59,7 +59,7 @@ pub(crate) fn read_path(input: &[u8]) -> IResult<&[u8], Path> {
 impl Encode for Path {
     fn encode(&self, buffer: &mut Vec<u8>) -> io::Result<()> {
         self.tool.encode(buffer)?;
-        buffer.write(
+        buffer.write_all(
             &self
                 .shape
                 .as_ref()

src/path_shape.rs

@@ -18,7 +18,7 @@ pub fn read_path_shape<'a>(
     cond(
         outline_count > 0,
         map(
-            tuple((read_point, count(read_outline, outline_count as usize))),
+            tuple((read_point, count(read_outline, outline_count))),
             move |(start, outlines)| PathShape { start, outlines },
         ),
     )

src/path_tool.rs

@@ -30,8 +30,8 @@ pub fn read_path_tool(input: &[u8]) -> IResult<&[u8], PathTool> {
 
 impl Encode for PathTool {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
-        buffer.write(&4u32.to_le_bytes())?;
-        buffer.write(&self.bits().to_le_bytes())?;
+        buffer.write_all(&4u32.to_le_bytes())?;
+        buffer.write_all(&self.bits().to_le_bytes())?;
         Ok(())
     }
 }

src/piece.rs

@@ -102,7 +102,7 @@ impl Encode for Piece {
             0u32.encode(buffer)?;
         } else {
             1u8.encode(buffer)?;
-            buffer.write(&self.label.as_bytes()[0..3])?;
+            buffer.write_all(&self.label.as_bytes()[0..3])?;
         }
 
         let mut path_data: Vec<Vec<u8>> = vec![];
@@ -113,7 +113,7 @@ impl Encode for Piece {
         (path_data.len() as u32).encode(buffer)?;
         for path in path_data {
             (path.len() as u32).encode(buffer)?;
-            buffer.write(&path)?;
+            buffer.write_all(&path)?;
         }
 
         Ok(())

src/piece_restrictions.rs

@@ -27,7 +27,7 @@ pub(crate) fn read_piece_restrictions(input: &[u8]) -> IResult<&[u8], PieceRestr
 
 impl Encode for PieceRestrictions {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
-        buffer.write(&self.bits().to_le_bytes())?;
+        buffer.write_all(&self.bits().to_le_bytes())?;
         Ok(())
     }
 }

src/piece_table.rs

@@ -53,7 +53,7 @@ impl Encode for PieceTable {
             id.encode(buffer)?;
         }
         for (_, data) in &piece_data {
-            buffer.write(data)?;
+            buffer.write_all(data)?;
         }
 
         Ok(())

src/point.rs

@@ -17,8 +17,8 @@ pub(crate) fn read_point(input: &[u8]) -> IResult<&[u8], Point> {
 
 impl Encode for Point {
     fn encode(&self, buffer: &mut Vec<u8>) -> std::io::Result<()> {
-        buffer.write(&self.x.to_le_bytes())?;
-        buffer.write(&self.y.to_le_bytes())?;
+        buffer.write_all(&self.x.to_le_bytes())?;
+        buffer.write_all(&self.y.to_le_bytes())?;
         Ok(())
     }
 }