Add a simple base64 implementation

This keeps us from adding a crate for one function. It's mostly based on
https://github.com/marshallpierce/rust-base64/blob/a675443d327e175f735a37f574de803d6a332591/src/engine/naive.rs#L42

Author: groves

Cargo.lock

@@ -11,7 +11,7 @@ homepage = "https://helix-editor.com"
 
 [features]
 default = []
-term = ["crossterm", "base64"]
+term = ["crossterm"]
 
 [dependencies]
 bitflags = "1.3"
@@ -20,7 +20,6 @@ helix-core = { version = "0.6", path = "../helix-core" }
 helix-lsp = { version = "0.6", path = "../helix-lsp" }
 helix-dap = { version = "0.6", path = "../helix-dap" }
 crossterm = { version = "0.24", optional = true }
-base64 = { version = "0.13", optional = true }
 
 # Conversion traits
 once_cell = "1.13"

helix-view/Cargo.toml

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Alice Maz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

helix-view/src/base64/LICENSE-MIT

@@ -0,0 +1,5 @@
+A minimal base64 implementation to keep from pulling in a crate for just that. It's based on 
+https://github.com/marshallpierce/rust-base64 but without all the customization options.
+The biggest portion comes from
+https://github.com/marshallpierce/rust-base64/blob/a675443d327e175f735a37f574de803d6a332591/src/engine/naive.rs#L42
+Thanks, rust-base64!

helix-view/src/base64/README.md

@@ -0,0 +1,185 @@
+use std::ops::{BitAnd, BitOr, Shl, Shr};
+
+pub fn encode<T: AsRef<[u8]>>(input: T) -> String {
+    let encoded_size =
+        encoded_len(input.as_ref().len()).expect("integer overflow when calculating buffer size");
+    let mut buf = vec![0; encoded_size];
+
+    encode_with_padding(input.as_ref(), &mut buf[..], encoded_size);
+
+    String::from_utf8(buf).expect("Invalid UTF8")
+}
+
+pub fn encoded_len(bytes_len: usize) -> Option<usize> {
+    let rem = bytes_len % 3;
+
+    let complete_input_chunks = bytes_len / 3;
+    let complete_chunk_output = complete_input_chunks.checked_mul(4);
+
+    if rem > 0 {
+        complete_chunk_output.and_then(|c| c.checked_add(4))
+    } else {
+        complete_chunk_output
+    }
+}
+
+fn encode_with_padding(input: &[u8], output: &mut [u8], expected_encoded_size: usize) {
+    debug_assert_eq!(expected_encoded_size, output.len());
+
+    let b64_bytes_written = encode_bytes(input, output);
+
+    let padding_bytes = add_padding(input.len(), &mut output[b64_bytes_written..]);
+
+    let encoded_bytes = b64_bytes_written
+        .checked_add(padding_bytes)
+        .expect("usize overflow when calculating b64 length");
+
+    debug_assert_eq!(expected_encoded_size, encoded_bytes);
+}
+
+pub fn add_padding(input_len: usize, output: &mut [u8]) -> usize {
+    // TODO base on encoded len to use cheaper mod by 4 (aka & 7)
+    let rem = input_len % 3;
+    let mut bytes_written = 0;
+    for _ in 0..((3 - rem) % 3) {
+        output[bytes_written] = PAD_BYTE;
+        bytes_written += 1;
+    }
+
+    bytes_written
+}
+const PAD_BYTE: u8 = b'=';
+const ENCODE_TABLE: &[u8] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".as_bytes();
+
+fn encode_bytes(input: &[u8], output: &mut [u8]) -> usize {
+    // complete chunks first
+
+    const LOW_SIX_BITS: u32 = 0x3F;
+
+    let rem = input.len() % 3;
+    // will never underflow
+    let complete_chunk_len = input.len() - rem;
+
+    let mut input_index = 0_usize;
+    let mut output_index = 0_usize;
+    if let Some(last_complete_chunk_index) = complete_chunk_len.checked_sub(3) {
+        while input_index <= last_complete_chunk_index {
+            let chunk = &input[input_index..input_index + 3];
+
+            // populate low 24 bits from 3 bytes
+            let chunk_int: u32 =
+                (chunk[0] as u32).shl(16) | (chunk[1] as u32).shl(8) | (chunk[2] as u32);
+            // encode 4x 6-bit output bytes
+            output[output_index] = ENCODE_TABLE[chunk_int.shr(18) as usize];
+            output[output_index + 1] =
+                ENCODE_TABLE[chunk_int.shr(12_u8).bitand(LOW_SIX_BITS) as usize];
+            output[output_index + 2] =
+                ENCODE_TABLE[chunk_int.shr(6_u8).bitand(LOW_SIX_BITS) as usize];
+            output[output_index + 3] = ENCODE_TABLE[chunk_int.bitand(LOW_SIX_BITS) as usize];
+
+            input_index += 3;
+            output_index += 4;
+        }
+    }
+
+    // then leftovers
+    if rem == 2 {
+        let chunk = &input[input_index..input_index + 2];
+
+        // high six bits of chunk[0]
+        output[output_index] = ENCODE_TABLE[chunk[0].shr(2) as usize];
+        // bottom 2 bits of [0], high 4 bits of [1]
+        output[output_index + 1] = ENCODE_TABLE
+            [(chunk[0].shl(4_u8).bitor(chunk[1].shr(4_u8)) as u32).bitand(LOW_SIX_BITS) as usize];
+        // bottom 4 bits of [1], with the 2 bottom bits as zero
+        output[output_index + 2] =
+            ENCODE_TABLE[(chunk[1].shl(2_u8) as u32).bitand(LOW_SIX_BITS) as usize];
+
+        output_index += 3;
+    } else if rem == 1 {
+        let byte = input[input_index];
+        output[output_index] = ENCODE_TABLE[byte.shr(2) as usize];
+        output[output_index + 1] =
+            ENCODE_TABLE[(byte.shl(4_u8) as u32).bitand(LOW_SIX_BITS) as usize];
+        output_index += 2;
+    }
+
+    output_index
+}
+
+#[cfg(test)]
+mod tests {
+    fn compare_encode(expected: &str, target: &[u8]) {
+        assert_eq!(expected, super::encode(target));
+    }
+
+    #[test]
+    fn encode_rfc4648_0() {
+        compare_encode("", b"");
+    }
+
+    #[test]
+    fn encode_rfc4648_1() {
+        compare_encode("Zg==", b"f");
+    }
+
+    #[test]
+    fn encode_rfc4648_2() {
+        compare_encode("Zm8=", b"fo");
+    }
+
+    #[test]
+    fn encode_rfc4648_3() {
+        compare_encode("Zm9v", b"foo");
+    }
+
+    #[test]
+    fn encode_rfc4648_4() {
+        compare_encode("Zm9vYg==", b"foob");
+    }
+
+    #[test]
+    fn encode_rfc4648_5() {
+        compare_encode("Zm9vYmE=", b"fooba");
+    }
+
+    #[test]
+    fn encode_rfc4648_6() {
+        compare_encode("Zm9vYmFy", b"foobar");
+    }
+
+    #[test]
+    fn encode_all_ascii() {
+        let mut ascii = Vec::<u8>::with_capacity(128);
+
+        for i in 0..128 {
+            ascii.push(i);
+        }
+
+        compare_encode(
+            "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
+         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn8\
+         =",
+            &ascii,
+        );
+    }
+
+    #[test]
+    fn encode_all_bytes() {
+        let mut bytes = Vec::<u8>::with_capacity(256);
+
+        for i in 0..255 {
+            bytes.push(i);
+        }
+        bytes.push(255); //bug with "overflowing" ranges?
+
+        compare_encode(
+            "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7P\
+         D0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn\
+         +AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6\
+         /wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==",
+            &bytes,
+        );
+    }
+}

helix-view/src/base64/mod.rs

@@ -148,7 +148,7 @@ mod provider {
 
     #[cfg(feature = "term")]
     mod osc52 {
-        use {super::ClipboardType, base64, crossterm};
+        use {super::ClipboardType, crate::base64, crossterm};
 
         #[derive(Debug)]
         pub struct SetClipboardCommand {

helix-view/src/clipboard.rs

@@ -10,6 +10,8 @@ pub mod handlers {
     pub mod dap;
     pub mod lsp;
 }
+#[cfg(feature = "term")]
+mod base64;
 pub mod info;
 pub mod input;
 pub mod keyboard;