ob64 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8b76a774595914a6124939fe2410fe4ae5bb0687286315ab4ec1f05b8569d70
-  data.tar.gz: 662b74f7505f28362436d44771e51720884cf0ea48076b12e59094eacf4e87b6
+  metadata.gz: 110cd68288a2dd3ff785dca2a4dc2bdc0b3d47445fae88d0fef3a3a3db1b0d96
+  data.tar.gz: a0d837a2ba44079613b99fd862cdf156d3105b69359edbefeae32711a2be402e
 SHA512:
-  metadata.gz: b0e357acff49af3e42b36cb41b521393ed4f6604fc4f5943c491a504741b985d5a47e63217acd27e0896cb2b23a8df2412fe133fff1d76d275decc5cf0a39f7f
-  data.tar.gz: 560f3439cff65bc442f16a8815afa729422e6286f6305a044f92035bf28666b80c80c8471ffd7ac0b83379ea999643a531ef9a5905449093dafe10cff36490e9
+  metadata.gz: 6a4fa2cabc1fad23055020ed1c49906de65e494f82fbf19966cc0a511cc8e073026dc77c4e0cb9b57d77d67e21f068fdbf79c6dfa2de978381444e1793a4793a
+  data.tar.gz: 432523720a899411c6a3840fc410bd4e540b7f8211dda82dff2643046959ce52ceec8bc0a8f15a6518bddb913cce69129b52ade76d8dbd33f3a7e980a690c693

data/.github/workflows/main.yml

@@ -89,7 +89,8 @@ jobs:
             require "ob64"
             require "ob64/core_ext"
             s = Random.bytes(4096)
-            abort "Base64 round trip failed" unless Ob64::Base64.decode(Ob64::Base64.encode(s)) == s
+            abort "RFC 4648 round trip failed" unless Ob64::Base64::RFC4648.decode(Ob64::Base64::RFC4648.encode(s)) == s
+            abort "RFC 2045 round trip failed" unless Ob64::Base64::RFC2045.decode(Ob64::Base64::RFC2045.encode(s)) == s
             abort "UU round trip failed" unless Ob64::UU.decode(Ob64::UU.encode(s)) == s
             abort "pack round trip failed" unless [s].pack("m0").unpack1("m0") == s
           '

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [0.7.0] - 2026-10-26
+
+- **Breaking:** Split `Ob64::Base64` into one module per RFC. `Ob64::Base64::RFC4648` has `encode`, `decode`, `encode_urlsafe`, `decode_urlsafe`, `encoded_length_of` and `decoded_length_of` (were `Ob64::Base64.encode`, `decode`, `urlsafe_encode`, `urlsafe_decode`, `encoded_length_of` and `decoded_length_of`).
+- Add `Ob64::Base64::RFC2045` with `encode` (optionally with CRLF line breaks), `decode`, `encoded_length_of` and `decoded_length_of`, like `pack("m")` and `unpack1("m")`.
+
 ## [0.6.0] - 2026-10-26
 
 - **Breaking:** `ob64/core_ext` patches `Array#pack`, `String#unpack` and `String#unpack1` instead of `Base64`.

data/Gemfile

@@ -5,7 +5,7 @@ source "https://rubygems.org"
 gemspec
 
 gem "benchmark-ips"
-gem "byebug"
+gem "debug"
 gem "guard"
 gem "guard-rspec"
 gem "rake", "~> 13.0"

data/README.md

@@ -2,7 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/ob64.svg)](http://rubygems.org/gems/ob64)
 [![CI](https://github.com/jcmfernandes/ob64/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/jcmfernandes/ob64/actions/workflows/main.yml)
-[![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/ob64/0.6.0)
+[![Yard Docs](https://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/gems/ob64/0.7.0)
 
 A *fast* Base64 and uuencode encoder and decoder as a Ruby gem.
 
@@ -40,26 +40,34 @@ require "ob64"
 
 ### Base64
 
+One module per RFC, each with `encode`, `decode`, `encoded_length_of` and `decoded_length_of`.
+
+RFC 4648, no line breaks, same output as `pack("m0")` / `unpack1("m0")`:
+
 ```ruby
 bin1 = "This is data!"
-string = Ob64::Base64.encode(bin1)
+string = Ob64::Base64::RFC4648.encode(bin1)
 # string = "VGhpcyBpcyBkYXRhIQ=="
 
-bin2 = Ob64::Base64.decode(string)
+bin2 = Ob64::Base64::RFC4648.decode(string)
 puts "Same? #{bin1 == bin2}"
 # "Same? true"
+
+Ob64::Base64::RFC4648.decode("VGhpcyBpcyBkYXRhIQ", loose: true)  # padding optional
+Ob64::Base64::RFC4648.encode_urlsafe(bin1, padding: false)        # '-' and '_' instead of '+' and '/'
+Ob64::Base64::RFC4648.decode_urlsafe(string)
 ```
 
-Decode input with or without padding:
+Bad padding, non-zero trailing bits and non-alphabet characters raise `ArgumentError`.
+
+RFC 2045 (MIME), line-wrapped, same output as `pack("m")` / `unpack1("m")`:
 
 ```ruby
-Ob64::Base64.decode("VGhpcyBpcyBkYXRhIQ", loose: true)
+Ob64::Base64::RFC2045.encode(bin)              # 60-char lines, each ending in "\n"
+Ob64::Base64::RFC2045.encode(bin, 76, crlf: true)
+Ob64::Base64::RFC2045.decode(string)           # skips line breaks and other non-alphabet characters
 ```
 
-Bad padding, non-zero trailing bits and non-alphabet characters still raise `ArgumentError`.
-
-URL-safe alphabet: `Ob64::Base64.urlsafe_encode(bin, padding: false)`, `Ob64::Base64.urlsafe_decode(string)`.
-
 ### uuencode
 
 Same output as `pack("u")` / `unpack1("u")`:
@@ -118,8 +126,6 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/jcmfer
 ## TODO
 
 * Streaming interface
-* RFC 2045 (MIME) encoding/decoding
-* Windows support
 
 ## License
 

data/benchmark.rb

@@ -41,28 +41,30 @@ each_size do |bin|
 
   compare(
     "Ruby pack(\"m0\")" => -> { NATIVE_PACK.bind_call([bin], "m0") },
-    "ob64 Base64.encode" => -> { Ob64::Base64.encode(bin) },
+    "ob64 Base64::RFC4648.encode" => -> { Ob64::Base64::RFC4648.encode(bin) },
     "ob64 pack(\"m0\")" => -> { [bin].pack("m0") }
   )
   compare(
     "Ruby unpack1(\"m0\")" => -> { NATIVE_UNPACK1.bind_call(m0, "m0") },
-    "ob64 Base64.decode" => -> { Ob64::Base64.decode(m0) },
+    "ob64 Base64::RFC4648.decode" => -> { Ob64::Base64::RFC4648.decode(m0) },
     "ob64 unpack1(\"m0\")" => -> { m0.unpack1("m0") }
   )
   compare(
     "Ruby pack(\"m0\").tr" => -> { NATIVE_PACK.bind_call([bin], "m0").tr("+/", "-_") },
-    "ob64 Base64.urlsafe_encode" => -> { Ob64::Base64.urlsafe_encode(bin) }
+    "ob64 Base64::RFC4648.encode_urlsafe" => -> { Ob64::Base64::RFC4648.encode_urlsafe(bin) }
   )
   compare(
     "Ruby tr.unpack1(\"m0\")" => -> { NATIVE_UNPACK1.bind_call(urlsafe.tr("-_", "+/"), "m0") },
-    "ob64 Base64.urlsafe_decode" => -> { Ob64::Base64.urlsafe_decode(urlsafe) }
+    "ob64 Base64::RFC4648.decode_urlsafe" => -> { Ob64::Base64::RFC4648.decode_urlsafe(urlsafe) }
   )
   compare(
     "Ruby pack(\"m\")" => -> { NATIVE_PACK.bind_call([bin], "m") },
+    "ob64 Base64::RFC2045.encode" => -> { Ob64::Base64::RFC2045.encode(bin) },
     "ob64 pack(\"m\")" => -> { [bin].pack("m") }
   )
   compare(
     "Ruby unpack1(\"m\")" => -> { NATIVE_UNPACK1.bind_call(m, "m") },
+    "ob64 Base64::RFC2045.decode" => -> { Ob64::Base64::RFC2045.decode(m) },
     "ob64 unpack1(\"m\")" => -> { m.unpack1("m") }
   )
 end if $run_base64_benchmark

data/bin/rake

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+bundle_binstub = File.expand_path("bundle", __dir__)
+
+if File.file?(bundle_binstub)
+  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
+    load(bundle_binstub)
+  else
+    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
+Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
+  end
+end
+
+require "rubygems"
+require "bundler/setup"
+
+load Gem.bin_path("rake", "rake")

data/ext/ob64/ob64_pack.c

@@ -60,6 +60,20 @@ uuencode(VALUE from, long line_len)
   return ascii_result(res, n);
 }
 
+/* line_len: bytes per line, a multiple of 3; crlf: lines end in "\r\n" */
+static VALUE
+base64_encode_rfc2045(VALUE from, long line_len, int crlf)
+{
+  long plen = RSTRING_LEN(from);
+  /* A line break per line */
+  long lines = (plen + line_len - 1) / line_len;
+  VALUE res = rb_str_buf_new((plen + 2) / 3 * 4 + lines * (crlf ? 2 : 1));
+  size_t n = pack_base64_encode_rfc2045(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), (int)line_len, crlf);
+  RB_GC_GUARD(from);
+
+  return ascii_result(res, n);
+}
+
 static VALUE
 Ob64_pack(int argc, VALUE *argv, VALUE ary)
 {
@@ -75,31 +89,22 @@ Ob64_pack(int argc, VALUE *argv, VALUE ary)
     return rb_call_super_kw(argc, argv, RB_PASS_CALLED_KEYWORDS);
   }
 
-  VALUE res;
-  size_t n;
-
   if (type == 'm' && count == 0) {
-    res = rb_str_buf_new((plen + 2) / 3 * 4);
-    n = pack_base64_encode(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), 0);
-  }
-  else {
-    long len = count;
+    VALUE res = rb_str_buf_new((plen + 2) / 3 * 4);
+    size_t n = pack_base64_encode(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), 0);
+    RB_GC_GUARD(from);
 
-    /* '*' gets 45, as natively */
-    if (len <= 2) len = 45;
-    else if (len > 63 && type == 'u') len = 63;
-    else len = len / 3 * 3;
+    return ascii_result(res, n);
+  }
 
-    if (type == 'u') return uuencode(from, len);
+  long len = count;
 
-    /* A newline per line */
-    long lines = (plen + len - 1) / len;
-    res = rb_str_buf_new((plen + 2) / 3 * 4 + lines);
-    n = pack_base64_encode_rfc2045(RSTRING_PTR(from), (size_t)plen, RSTRING_PTR(res), (int)len);
-  }
-  RB_GC_GUARD(from);
+  /* '*' gets 45, as natively */
+  if (len <= 2) len = 45;
+  else if (len > 63 && type == 'u') len = 63;
+  else len = len / 3 * 3;
 
-  return ascii_result(res, n);
+  return type == 'u' ? uuencode(from, len) : base64_encode_rfc2045(from, len, 0);
 }
 
 static VALUE
@@ -174,6 +179,58 @@ Ob64_unpack1(int argc, VALUE *argv, VALUE str)
   return res;
 }
 
+/* Bytes per line for a line_length in chars; validates both arguments */
+static long
+rfc2045_line_bytes(VALUE bin, VALUE line_length)
+{
+  long chars = NUM2LONG(line_length);
+
+  StringValue(bin);
+  if (chars < 4 || chars % 4 || chars / 4 * 3 > INT_MAX) {
+    rb_raise(rb_eArgError, "line length must be a positive multiple of 4: %ld", chars);
+  }
+  /* Bound the output size */
+  if (RSTRING_LEN(bin) > LONG_MAX / 4) rb_raise(rb_eArgError, "argument too big");
+
+  return chars / 4 * 3;
+}
+
+static VALUE
+Ob64_encode_rfc_2045(VALUE self, VALUE bin, VALUE line_length, VALUE crlf)
+{
+  long line_bytes = rfc2045_line_bytes(bin, line_length);
+
+  return base64_encode_rfc2045(bin, line_bytes, RTEST(crlf));
+}
+
+static VALUE
+Ob64_decode_rfc_2045(VALUE self, VALUE string)
+{
+  StringValue(string);
+
+  return base64_decode(string, 1);
+}
+
+static VALUE
+Ob64_encoded_length_of_rfc_2045(VALUE self, VALUE bin, VALUE line_length, VALUE crlf)
+{
+  long line_bytes = rfc2045_line_bytes(bin, line_length);
+  long plen = RSTRING_LEN(bin);
+
+  /* 4 chars per 3 bytes, a line break per line */
+  return LONG2NUM((plen + 2) / 3 * 4 + (plen + line_bytes - 1) / line_bytes * (RTEST(crlf) ? 2 : 1));
+}
+
+static VALUE
+Ob64_decoded_length_of_rfc_2045(VALUE self, VALUE string)
+{
+  StringValue(string);
+  size_t n = pack_base64_decoded_length_rfc2045(RSTRING_PTR(string), (size_t)RSTRING_LEN(string));
+  RB_GC_GUARD(string);
+
+  return SIZET2NUM(n);
+}
+
 static VALUE
 Ob64_uuencode(VALUE self, VALUE bin)
 {
@@ -221,6 +278,10 @@ Init_ob64_pack(VALUE mExt)
   rb_define_method(mUnpack, "unpack", Ob64_unpack, -1);
   rb_define_method(mUnpack, "unpack1", Ob64_unpack1, -1);
 
+  rb_define_private_method(mExt, "__encode_rfc_2045", Ob64_encode_rfc_2045, 3);
+  rb_define_private_method(mExt, "__decode_rfc_2045", Ob64_decode_rfc_2045, 1);
+  rb_define_private_method(mExt, "__encoded_length_of_rfc_2045", Ob64_encoded_length_of_rfc_2045, 3);
+  rb_define_private_method(mExt, "__decoded_length_of_rfc_2045", Ob64_decoded_length_of_rfc_2045, 1);
   rb_define_private_method(mExt, "__uuencode", Ob64_uuencode, 1);
   rb_define_private_method(mExt, "__uudecode", Ob64_uudecode, 1);
   rb_define_private_method(mExt, "__uuencoded_length_of", Ob64_uuencoded_length_of, 1);

data/ext/ob64/pack_base64.c

@@ -4993,7 +4993,7 @@ pack_base64_decode (const char *src, size_t srclen, char *out, size_t *outlen, i
  * ====================================================================== */
 
 static size_t
-encode_rfc2045_plain(const char *src, size_t srclen, char *out, int bytes_per_line)
+encode_rfc2045_plain(const char *src, size_t srclen, char *out, int bytes_per_line, int crlf)
 {
     const uint8_t *s = (const uint8_t *)src;
     char *o = out;
@@ -5012,6 +5012,7 @@ encode_rfc2045_plain(const char *src, size_t srclen, char *out, int bytes_per_li
         srclen -= 3;
         line_bytes += 3;
         if (line_bytes >= bytes_per_line) {
+            if (crlf) *o++ = '\r';
             *o++ = '\n';
             line_bytes = 0;
         }
@@ -5022,6 +5023,7 @@ encode_rfc2045_plain(const char *src, size_t srclen, char *out, int bytes_per_li
         *o++ = base64_table_enc_6bit[((s[0] & 0x03) << 4) | (s[1] >> 4)];
         *o++ = base64_table_enc_6bit[(s[1] & 0x0F) << 2];
         *o++ = '=';
+        if (crlf) *o++ = '\r';
         *o++ = '\n';
     }
     else if (srclen == 1) {
@@ -5029,9 +5031,11 @@ encode_rfc2045_plain(const char *src, size_t srclen, char *out, int bytes_per_li
         *o++ = base64_table_enc_6bit[(s[0] & 0x03) << 4];
         *o++ = '=';
         *o++ = '=';
+        if (crlf) *o++ = '\r';
         *o++ = '\n';
     }
     else if (line_bytes > 0) {
+        if (crlf) *o++ = '\r';
         *o++ = '\n';
     }
 
@@ -5052,13 +5056,13 @@ encode_whole (const struct codec *codec, const char *src, size_t srclen, char *o
 }
 
 size_t
-pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_per_line)
+pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_per_line, int crlf)
 {
 	const struct codec *codec = codec_get();
 
 	bytes_per_line = bytes_per_line / 3 * 3;
 	if (bytes_per_line == 0) bytes_per_line = 45;
-	if (!codec->enc_loop) return encode_rfc2045_plain(src, srclen, out, bytes_per_line);
+	if (!codec->enc_loop) return encode_rfc2045_plain(src, srclen, out, bytes_per_line, crlf);
 
 	size_t line = (size_t)bytes_per_line;
 	size_t chars = line / 3 * 4;
@@ -5072,6 +5076,7 @@ pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_
 		if (lines_per_batch == 0) {
 			/* Lines longer than the buffer: encode in place */
 			o += encode_whole(codec, src, line, o);
+			if (crlf) *o++ = '\r';
 			*o++ = '\n';
 			lines = 1;
 		}
@@ -5081,6 +5086,7 @@ pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_
 			for (size_t i = 0; i < lines; i++) {
 				memcpy(o, buf + i * chars, chars);
 				o += chars;
+				if (crlf) *o++ = '\r';
 				*o++ = '\n';
 			}
 		}
@@ -5088,7 +5094,7 @@ pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_
 		srclen -= lines * line;
 	}
 
-	return (size_t)(o - out) + encode_rfc2045_plain(src, srclen, o, bytes_per_line);
+	return (size_t)(o - out) + encode_rfc2045_plain(src, srclen, o, bytes_per_line, crlf);
 }
 
 /*
@@ -5180,3 +5186,24 @@ pack_base64_decode_rfc2045(const char *src, size_t srclen, char *out)
 	if (n == 0) return (size_t)(o - (uint8_t *)out) + decode_rfc2045_from(s, end, o, NULL, 0);
 	return (size_t)(o - (uint8_t *)out) + decode_rfc2045_from(s, end, o, buf, n);
 }
+
+size_t
+pack_base64_decoded_length_rfc2045(const char *src, size_t srclen)
+{
+	const uint8_t *s = (const uint8_t *)src;
+	const uint8_t *end = s + srclen;
+	size_t n = 0;
+
+	/* Counts what pack_base64_decode_rfc2045 decodes: alphabet chars up to a '=' in group position 3-4 */
+	for (; s < end; s++) {
+		const uint8_t v = base64_table_dec_8bit[*s];
+
+		if (v == 255) continue;
+		if (v == 254) {
+			if (n % 4 >= 2) break;
+			continue;
+		}
+		n++;
+	}
+	return n / 4 * 3 + (n % 4 == 3 ? 2 : n % 4 == 2 ? 1 : 0);
+}

data/ext/ob64/pack_base64.h

@@ -27,7 +27,10 @@ size_t pack_base64_encode(const char *src, size_t srclen, char *out, int flags);
 int pack_base64_decode(const char *src, size_t srclen, char *out, size_t *outlen, int flags);
 
 /* RFC 2045 codec (m with line wrapping, lenient decode) */
-size_t pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_per_line);
+/* Lines end in "\r\n" if crlf, "\n" otherwise */
+size_t pack_base64_encode_rfc2045(const char *src, size_t srclen, char *out, int bytes_per_line, int crlf);
 size_t pack_base64_decode_rfc2045(const char *src, size_t srclen, char *out);
+/* Length pack_base64_decode_rfc2045 would return; reads all of src */
+size_t pack_base64_decoded_length_rfc2045(const char *src, size_t srclen);
 
 #endif /* PACK_BASE64_H */

data/lib/ob64/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ob64
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/lib/ob64.rb

@@ -3,7 +3,8 @@
 require_relative "ob64/version"
 require_relative "ob64_ext"
 
-# Fast base64 and uuencode encoding and decoding: see {Base64} and {UU}.
+# Fast base64 and uuencode encoding and decoding: see {Base64::RFC4648},
+# {Base64::RFC2045} and {UU}.
 module Ob64
   # The glue between Ruby and the C codecs. See +../ext/ob64/ob64_ext.c+.
   module Ext; end
@@ -44,88 +45,150 @@ module Ob64
     codecs.last
   end
 
-  # Methods for base64-encoding and -decoding strings.
+  # Base64 encoding and decoding, one module per RFC: {RFC4648} and {RFC2045}.
   module Base64
-    include Ext
-    extend Ext
-
-    module_function
-
-    # Returns the Base64-encoded version of +bin+.
-    # This method complies with RFC 4648.
-    # No line feeds are added.
-    #
-    # @param bin [String]
-    # @return [String]
-    def encode(bin)
-      __encode(bin, false, true)
-    end
-
-    # Returns the Base64-decoded version of +string+.
-    # This method complies with RFC 4648.
-    # ArgumentError is raised if +string+ is incorrectly padded or contains
-    # non-alphabet characters. Note that CR or LF are also rejected.
-    #
-    # With +loose+, the padding character is optional: both correctly-padded
-    # and unpadded input are accepted. Incorrectly-padded input is still
-    # rejected.
-    #
-    # @param string [String]
-    # @param loose [Boolean] - if unpadded input is accepted
-    # @return [String]
-    # @raise [ArgumentError] if +string+ cannot be decoded
-    def decode(string, loose: false)
-      __decode(string, false, loose)
-    end
-
-    # Returns the Base64-encoded version of +bin+.
-    # This method complies with ``Base 64 Encoding with URL and Filename Safe
-    # Alphabet'' in RFC 4648.
-    # The alphabet uses '-' instead of '+' and '_' instead of '/'.
-    # Note that the result can still contain '='.
-    # You can remove the padding by setting +padding+ as false.
-    #
-    # @param bin [String]
-    # @param padding [Boolean] - if the output must be padded
-    # @return [String]
-    def urlsafe_encode(bin, padding: true)
-      __encode(bin, true, padding)
-    end
-
-    # Returns the Base64-decoded version of +string+.
-    # This method complies with ``Base 64 Encoding with URL and Filename Safe
-    # Alphabet'' in RFC 4648.
-    # The alphabet uses '-' instead of '+' and '_' instead of '/'.
-    #
-    # The padding character is optional.
-    # This method accepts both correctly-padded and unpadded input.
-    # Note that it still rejects incorrectly-padded input.
-    #
-    # @param string [String]
-    # @return [String]
-    # @raise [ArgumentError] if +string+ cannot be decoded
-    def urlsafe_decode(string)
-      __decode(string, true, true)
+    # Base64 as in RFC 4648: no line breaks, strict decoding.
+    module RFC4648
+      include Ext
+      extend Ext
+
+      module_function
+
+      # Returns the Base64-encoded version of +bin+, like
+      # <tt>[bin].pack("m0")</tt>. No line feeds are added.
+      #
+      # @param bin [String]
+      # @return [String]
+      def encode(bin)
+        __encode(bin, false, true)
+      end
+
+      # Returns the Base64-decoded version of +string+, like
+      # <tt>string.unpack1("m0")</tt>.
+      # ArgumentError is raised if +string+ is incorrectly padded or contains
+      # non-alphabet characters. Note that CR or LF are also rejected.
+      #
+      # With +loose+, the padding character is optional: both correctly-padded
+      # and unpadded input are accepted. Incorrectly-padded input is still
+      # rejected.
+      #
+      # @param string [String]
+      # @param loose [Boolean] - if unpadded input is accepted
+      # @return [String]
+      # @raise [ArgumentError] if +string+ cannot be decoded
+      def decode(string, loose: false)
+        __decode(string, false, loose)
+      end
+
+      # Returns the Base64-encoded version of +bin+ with the ``URL and Filename
+      # Safe'' alphabet: '-' instead of '+' and '_' instead of '/'.
+      # Note that the result can still contain '='.
+      # You can remove the padding by setting +padding+ as false.
+      #
+      # @param bin [String]
+      # @param padding [Boolean] - if the output must be padded
+      # @return [String]
+      def encode_urlsafe(bin, padding: true)
+        __encode(bin, true, padding)
+      end
+
+      # Returns the Base64-decoded version of +string+ with the ``URL and
+      # Filename Safe'' alphabet: '-' instead of '+' and '_' instead of '/'.
+      #
+      # The padding character is optional.
+      # This method accepts both correctly-padded and unpadded input.
+      # Note that it still rejects incorrectly-padded input.
+      #
+      # @param string [String]
+      # @return [String]
+      # @raise [ArgumentError] if +string+ cannot be decoded
+      def decode_urlsafe(string)
+        __decode(string, true, true)
+      end
+
+      # Returns the length of {encode} (or, with the same +padding+,
+      # {encode_urlsafe}) of +bin+.
+      #
+      # Fast: computed from +bin+'s length.
+      #
+      # @param bin [String]
+      # @param padding [Boolean] - if the Base64-encoded version of +bin+ will be padded
+      # @return [Integer]
+      def encoded_length_of(bin, padding: true)
+        __encoded_length_of(bin, padding)
+      end
+
+      # Returns the length of {decode} (or {decode_urlsafe}) of +string+,
+      # padded or not.
+      #
+      # Fast: computed from +string+'s length and its last two characters. It
+      # doesn't validate the rest, so decoding may still raise.
+      #
+      # @param string [String]
+      # @return [Integer]
+      # @raise [ArgumentError] if +string+ has an invalid length
+      def decoded_length_of(string)
+        __decoded_length_of(string)
+      end
     end
 
-    # Returns the length of the Base64-encoded version of +bin+.
-    #
-    # @param bin [String]
-    # @param padding [Boolean] - if the Base64-encoded version of +bin+ will be padded
-    # @return [Integer]
-    def encoded_length_of(bin, padding: true)
-      __encoded_length_of(bin, padding)
-    end
-
-    # Returns the length of the Base64-decoded version of +string+.
-    #
-    # ArgumentError is raised if +string+ has an invalid length.
-    #
-    # @param string [String]
-    # @return [Integer]
-    # @raise [ArgumentError] if +string+ has an invalid length
-    def decoded_length_of(string)
-      __decoded_length_of(string)
+    # Base64 as in RFC 2045 (MIME): line breaks, lenient decoding.
+    module RFC2045
+      include Ext
+      extend Ext
+
+      module_function
+
+      # Returns the Base64-encoded version of +bin+ in lines of +line_length+
+      # characters, each ending in a line break. Like <tt>[bin].pack("m")</tt>
+      # by default; with +crlf+, lines end in "\r\n", as MIME requires.
+      # RFC 2045 allows lines of up to 76 characters; longer ones are allowed
+      # here, as in +pack+, but break the RFC.
+      #
+      # @param bin [String]
+      # @param line_length [Integer] - characters per line, a positive multiple of 4
+      # @param crlf [Boolean] - if lines end in "\r\n" instead of "\n"
+      # @return [String]
+      # @raise [ArgumentError] if +line_length+ is not a positive multiple of 4
+      def encode(bin, line_length = 60, crlf: false)
+        __encode_rfc_2045(bin, line_length, crlf)
+      end
+
+      # Returns the Base64-decoded version of +string+, like
+      # <tt>string.unpack1("m")</tt>: characters outside the alphabet, such
+      # as line breaks, are skipped. Decoding is lenient, as in Ruby, and
+      # never raises for malformed input.
+      #
+      # @param string [String]
+      # @return [String]
+      def decode(string)
+        __decode_rfc_2045(string)
+      end
+
+      # Returns the length of {encode} of +bin+.
+      #
+      # Fast: computed from +bin+'s length.
+      #
+      # @param bin [String]
+      # @param line_length [Integer] - characters per line, a positive multiple of 4
+      # @param crlf [Boolean] - if lines end in "\r\n" instead of "\n"
+      # @return [Integer]
+      # @raise [ArgumentError] if +line_length+ is not a positive multiple of 4
+      def encoded_length_of(bin, line_length = 60, crlf: false)
+        __encoded_length_of_rfc_2045(bin, line_length, crlf)
+      end
+
+      # Returns the length of {decode} of +string+.
+      #
+      # Costly: reads all of +string+, since skipped characters and +=+ decide
+      # the length. To size a buffer, <tt>string.bytesize * 3 / 4</tt> is
+      # always enough and fast.
+      #
+      # @param string [String]
+      # @return [Integer]
+      def decoded_length_of(string)
+        __decoded_length_of_rfc_2045(string)
+      end
     end
   end
 
@@ -155,7 +218,9 @@ module Ob64
       __uudecode(string)
     end
 
-    # Returns the length of the uuencoded version of +bin+.
+    # Returns the length of {encode} of +bin+.
+    #
+    # Fast: computed from +bin+'s length.
     #
     # @param bin [String]
     # @return [Integer]
@@ -163,9 +228,13 @@ module Ob64
       __uuencoded_length_of(bin)
     end
 
-    # Returns the length of the uudecoded version of +string+.
+    # Returns the length of {decode} of +string+.
     # Like {decode}, never raises for malformed input.
     #
+    # Costly: reads all of +string+, since each line's length character
+    # decides the length. To size a buffer, <tt>string.bytesize * 3 / 4</tt>
+    # is always enough and fast.
+    #
     # @param string [String]
     # @return [Integer]
     def decoded_length_of(string)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ob64
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - João Fernandes
@@ -35,6 +35,7 @@ files:
 - bin/_guard-core
 - bin/console
 - bin/guard
+- bin/rake
 - bin/rspec
 - bin/setup
 - bin/standardrb
@@ -58,8 +59,8 @@ licenses:
 metadata:
   homepage_uri: https://github.com/jcmfernandes/ob64
   changelog_uri: https://github.com/jcmfernandes/ob64/blob/master/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/ob64/0.6.0
-  source_code_uri: https://github.com/jcmfernandes/ob64/tree/v0.6.0
+  documentation_uri: https://www.rubydoc.info/gems/ob64/0.7.0
+  source_code_uri: https://github.com/jcmfernandes/ob64/tree/v0.7.0
 rdoc_options: []
 require_paths:
 - lib
@@ -74,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.23
 specification_version: 4
 summary: A fast Base64 and uuencode encoder and decoder.
 test_files: []