A few improvement ideas

I was reviewing code, and just made a bunch of minor fixes. I wasn't sure where you want to take this code next, so its one PR - but I could remove any parts that you think are not improving.

* Fix README crates link to point to crates.io, and add a few more status tags.
* Migrate to 2021 edition
* A few `cargo fmt` and `cargo clippy` changes
  * Use cm::Ordering to do the compare+match
* A few minor CI improvements to catch those
* Move main example to README.md, and made README.md included into the code as documentation - this way both GitHub and cargo.rs should the same documentation.
* Make README examples runnable/testable (now part of `cargo test`)

* I am not sure homepage should link to lib.rs -- perhaps consider removing it?

.editorconfig

@@ -3,4 +3,4 @@ root = true
 [*]
 indent_style = space
 insert_final_newline = true
-trim_trailing_whitespace = true
+trim_trailing_whitespace = true

.github/workflows/rust.yml

@@ -15,8 +15,10 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
-    - name: Build
-      run: cargo build --verbose
-    - name: Run tests
-      run: cargo test --verbose
+      - uses: actions/checkout@v2
+      - name: Build
+        run: RUSTFLAGS='-D warnings' cargo build --verbose
+      - name: Run tests
+        run: cargo test --verbose
+      - name: Clippy
+        run: cargo clippy -- -D warnings

.gitignore

@@ -3,4 +3,4 @@
 target/
 
 .DS_Store
-Cargo.lock
+Cargo.lock

Cargo.toml

@@ -9,5 +9,5 @@ keywords = ["bspatch", "patch", "diff", "delta", "binary"]
 license = "BSD-2-Clause"
 homepage = "https://lib.rs/bsdiff"
 repository = "https://github.com/space-wizards/bsdiff-rs"
-edition = "2018"
+edition = "2021"
 include = ["src/*.rs", "LICENSE", "README.md", "Cargo.toml"]

README.md

@@ -1,30 +1,57 @@
 # bsdiff-rs
 
-[![Build status](https://github.com/space-wizards/bsdiff-rs/actions/workflows/rust.yml/badge.svg)](https://github.com/space-wizards/bsdiff-rs/actions/workflows/rust.yml)
-[![Cargo Link](https://img.shields.io/crates/v/bsdiff.svg)](https://crates.rs/crates/bsdiff)
+[![GitHub](https://img.shields.io/badge/github-bsdiff-8da0cb?logo=github)](https://github.com/space-wizards/bsdiff-rs)
+[![crates.io version](https://img.shields.io/crates/v/bsdiff.svg)](https://crates.io/crates/bsdiff)
+[![docs.rs docs](https://docs.rs/bsdiff/badge.svg)](https://docs.rs/bsdiff)
+[![crates.io version](https://img.shields.io/crates/l/bsdiff.svg)](https://github.comspace-wizards/bsdiff-rss/blob/main/LICENSE-APACHE)
+[![CI build](https://github.com/space-wizards/bsdiff-rs/actions/workflows/rust.yml/badge.svg)](https://github.com/space-wizards/bsdiff-rs/actions)
 
-Rust port of a [bsdiff library](https://github.com/mendsley/bsdiff). High performance patching. All written in safe Rust.
+Bsdiff is a method of diffing files. This crate is a port of a [bsdiff library](https://github.com/mendsley/bsdiff).
+High performance patching. All written in safe
+Rust.
 
-## Diffing
+It is usually a good idea to use bsdiff alongside a compression algorithm like bzip2.
+
+## Usage
 
 ```rust
-let old = std::fs::read("old")?;
-let new = std::fs::read("new")?;
-let mut patch = Vec::new();
+fn main() {
+    let one = vec![1, 2, 3, 4, 5];
+    let two = vec![1, 2, 4, 6];
+    let mut patch = Vec::new();
+
+    bsdiff::diff(&one, &two, &mut patch).unwrap();
 
-bsdiff::diff(&old, &new, &mut patch)?;
-// TODO: compress `patch` here
-std::fs::write("patch", &patch)?;
+    let mut patched = Vec::with_capacity(two.len());
+    bsdiff::patch(&one, &mut patch.as_slice(), &mut patched).unwrap();
+    assert_eq!(patched, two);
+}
 ```
 
-## Patching
+## Diffing Files
 
 ```rust
-let old = std::fs::read("old")?;
-let patch = std::fs::read("patch")?;
-// TODO: decompress `patch` here
-let mut new = Vec::new();
+fn diff_files(file_a: &str, file_b: &str, patch_file: &str) -> std::io::Result<()> {
+    let old = std::fs::read(file_a)?;
+    let new = std::fs::read(file_b)?;
+    let mut patch = Vec::new();
+
+    bsdiff::diff(&old, &new, &mut patch)?;
+    // TODO: compress `patch` here
+    std::fs::write(patch_file, &patch)
+}
+```
 
-bsdiff::patch(&old, &mut patch.as_slice(), &mut new)?;
-std::fs::write("new", &new)?;
+## Patching Files
+
+```rust
+fn patch_file(file_a: &str, patch_file: &str, file_b: &str) -> std::io::Result<()> {
+    let old = std::fs::read(file_a)?;
+    let patch = std::fs::read(patch_file)?;
+    // TODO: decompress `patch` here
+    let mut new = Vec::new();
+
+    bsdiff::patch(&old, &mut patch.as_slice(), &mut new)?;
+    std::fs::write(file_b, &new)
+}
 ```

src/diff.rs

@@ -27,6 +27,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+use std::cmp::Ordering;
 use std::io;
 use std::io::Write;
 
@@ -101,15 +102,16 @@ fn split_internal(
         let mut k = 0;
         let mut i = start;
         while i < jj {
-            let v = V[usz(I[i] + h as isize)];
-            if v < x {
-                i += 1;
-            } else if v == x {
-                I.swap(i, jj + j);
-                j += 1;
-            } else {
-                I.swap(i, kk + k);
-                k += 1;
+            match V[usz(I[i] + h as isize)].cmp(&x) {
+                Ordering::Less => i += 1,
+                Ordering::Equal => {
+                    I.swap(i, jj + j);
+                    j += 1;
+                }
+                Ordering::Greater => {
+                    I.swap(i, kk + k);
+                    k += 1;
+                }
             }
         }
         while jj + j < kk {
@@ -210,14 +212,14 @@ fn matchlen(old: &[u8], new: &[u8]) -> usize {
 fn search(I: &[isize], old: &[u8], new: &[u8]) -> (isize, usize) {
     if I.len() < 3 {
         let x = matchlen(&old[usz(I[0])..], new);
-        let y = matchlen(&old[usz(I[I.len()-1])..], new);
+        let y = matchlen(&old[usz(I[I.len() - 1])..], new);
         if x > y {
             (I[0], x)
         } else {
-            (I[I.len()-1], y)
+            (I[I.len() - 1], y)
         }
     } else {
-        let mid = (I.len()-1) / 2;
+        let mid = (I.len() - 1) / 2;
         let left = &old[usz(I[mid])..];
         let right = new;
         let len_to_check = left.len().min(right.len());

src/lib.rs

@@ -1,22 +1,4 @@
-//! Bsdiff is a method of diffing files.
-//! This crate has been ported from C code.
-//! The original code and more info can be found [here](https://github.com/mendsley/bsdiff).
-//!
-//! It is usually a good idea to use bsdiff alongside a compression algorithm like bzip2.
-//!
-//! # Example
-//!
-//! ```
-//! let one = vec![1, 2, 3, 4, 5];
-//! let two = vec![1, 2, 4, 6];
-//! let mut patch = Vec::new();
-//!
-//! bsdiff::diff(&one, &two, &mut patch).unwrap();
-//!
-//! let mut patched = Vec::with_capacity(two.len());
-//! bsdiff::patch(&one, &mut patch.as_slice(), &mut patched).unwrap();
-//! assert_eq!(patched, two);
-//! ```
+#![doc = include_str!("../README.md")]
 
 mod diff;
 mod patch;

src/patch.rs

@@ -32,15 +32,15 @@ use std::io;
 use std::io::Read;
 
 /// Apply a patch to an "old" file, returning the "new" file.
-/// 
+///
 /// `old` is the old file, `patch` will be read from with the patch,`new` is the buffer that will be written into.
 pub fn patch<T: Read>(old: &[u8], patch: &mut T, new: &mut Vec<u8>) -> io::Result<()> {
     let mut oldpos: usize = 0;
     loop {
         // Read control data
         let mut buf = [0; 24];
         if read_or_eof(patch, &mut buf)? {
-            return Ok(())
+            return Ok(());
         }
 
         // only seek can be negative
@@ -99,7 +99,7 @@ fn read_or_eof<T: Read>(reader: &mut T, buf: &mut [u8; 24]) -> io::Result<bool>
                 } else {
                     Err(io::ErrorKind::UnexpectedEof.into())
                 }
-            },
+            }
             Ok(n) => {
                 if n >= tmp.len() {
                     return Ok(false);
@@ -116,9 +116,9 @@ fn read_or_eof<T: Read>(reader: &mut T, buf: &mut [u8; 24]) -> io::Result<bool>
 #[inline]
 fn offtin(buf: [u8; 8]) -> i64 {
     let y = i64::from_le_bytes(buf);
-    if 0 == y & (1<<63) {
+    if 0 == y & (1 << 63) {
         y
     } else {
-        -(y & !(1<<63))
+        -(y & !(1 << 63))
     }
 }