base85 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 328dd90db168fa41b46bfe68fbee1fecf63547fa31cdae25a9405753c58cb8f3
-  data.tar.gz: 631040e522c72ec2191b709d024334f98a0c1caf1a71067ae3c63563d4eedc6b
+  metadata.gz: 4f8a6088b3843d55dae49087d58126a5527c36804fbcee912db569db9950ab40
+  data.tar.gz: 5da6748b35556b5723052547d4c10cc0e55a5c1f85ab88f29df32760e164c4ce
 SHA512:
-  metadata.gz: 74fd0e3d3a76477ae6598e6665499150b3c874dc2e052d9797dc884a82a4736724a28647a16f7873cf502d8893f733b22b0cafb544097090de1ece7d81f0c6f2
-  data.tar.gz: 7d34cdcd2606ad5ed01f95875c4b1b3d183af6855dd0fda9f543fe179c63ac0d556f4ac500765f8b5cfd55bf3eacb762aece0f87bb29991d5721c42273ae220b
+  metadata.gz: 6e63afeb1c585b407dc2bb154ecc1a363e28919b7a354a9ae1c355293c5ed7b3e91c51a98f4adc8bd88c84391f47b4ccf825a545017a96fbb263d0863e5935c9
+  data.tar.gz: d0e243fb0f19e05733836879cb47577b0127439e5145f5e11939eb3fab34837ebcba486681061a3f2a53cb8c5d3a161bac73e11b4184a64e937a3c46b749e738

data/.rubocop.yml

@@ -10,6 +10,9 @@ AllCops:
 Layout/LineLength:
   Max: 120
 
+Metrics/MethodLength:
+  Max: 20
+
 RSpec/DescribedClass:
   Enabled: false
 

data/CHANGELOG.md

@@ -1,4 +1,8 @@
-## [Unreleased]
+# Changelog
+
+## [0.2.0] - 20025-06-25
+
+- Add Z85 and RFC1924 alphabets
 
 ## [0.1.0] - 2025-06-14
 

data/README.md

@@ -2,6 +2,12 @@
 
 Base85 is a pure Ruby gem to encode/decode data using Base85 encoding.
 
+It handles mulitple alphabets:
+
+* standard (original) one,
+* Z85 from [ZeroMQ](https://github.com/zeromq/libzmq),
+* [RFC1924](https://www.rfc-editor.org/rfc/rfc1924).
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -19,7 +25,15 @@ To encode a string:
 ```ruby
 require "base85"
 
+# Use standard alphabet
 Base85.encode("test1")  #=> "FCfN80`"
+Base85.encode("test1", alphabet: :standard)  #=> "FCfN80`"
+
+# Use Z85 alphabet
+Base85.encode("test1", alphabet: :z85)  #=> "By/Jnf-"
+
+# Use RFC1924 alphabet
+Base85.encode("test1", alphabet: :rfc1924)  #=> "bY*jNF#"
 ```
 
 To decode a string:
@@ -27,7 +41,15 @@ To decode a string:
 ```ruby
 require "base85"
 
-Base85.decode("!!!!!")  #=> "\u0000\u0000\u0000\u0000"
+# Use standard alphabet
+Base85.decode("ASu!rA7]9")  #=> "encoded"
+Base85.decode("ASu!rA7]9", alphabet: :standard)  #=> "encoded"
+
+# Use Z85 alphabet
+Base85.decode("wO#0@wmYo", alphabet: :z85)  #=> "encoded"
+
+# Use RFC1924 alphabet
+Base85.decode("Wo~0{WMyO", alphabet: :rfc1924)  #=> "encoded"
 ```
 
 ## Development

data/lib/base85/module_methods.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Base85
+  # Module handling common module methods to all encodings
+  # @author sd77
+  module ModuleMethods
+    # @private
+    LUT = (0..4).map { |count| 85**(4 - count) }.freeze
+
+    # @private
+    # Encode a single word
+    # @param [Integer] word
+    # @param [Integer] byte_count byte count of word. Must be in range 1..4
+    def encode_word(word, byte_count: 4)
+      encoded = "~" * 5
+      5.times do |i|
+        word, r = word.divmod(85)
+        encoded[-i - 1] = encode_value(r)
+      end
+      encoded[..byte_count]
+    end
+
+    # Encode data using standard base85 encoding
+    # @param [String] data
+    # @return [String]
+    def encode(data)
+      result = +""
+      data.unpack("N*").each do |word|
+        result << encode_word(word)
+      end
+
+      last_count = data.length % 4
+      return result if last_count.zero?
+
+      last_chars =  data[-last_count..] << ("\x00" * (4 - last_count))
+      result << encode_word(last_chars.unpack1("N"), byte_count: last_count)
+    end
+
+    # Decode data using standard base85 encoding
+    # @param [String] data
+    # @return [String]
+    # @raise [DecodeError] unknown character or invalid tuple
+    def decode(data)
+      result = +""
+      word = 0
+      count = 0
+      data.each_char do |c|
+        idx = decode_char(c)
+        p c if idx.nil?
+
+        word += idx * LUT[count]
+        count += 1
+
+        if (count == 5) && (word > 0xffffffff)
+          raise DecodeError, "invalid tuple"
+        elsif count == 5
+          wordbuf = " " * 4
+          3.downto(0) do |i|
+            wordbuf.setbyte(i, word & 0xff)
+            word >>= 8
+          end
+          result << wordbuf
+          count = 0
+          word = 0
+        end
+      end
+
+      return result if count.zero?
+
+      count -= 1
+      word += LUT[count]
+      result << ((word >> 24) & 0xff).chr if count >= 1
+      result << ((word >> 16) & 0xff).chr if count >= 2
+      result << ((word >> 8) & 0xff).chr if count == 3
+      result
+    end
+  end
+end

data/lib/base85/rfc1924.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Base85
+  # RFC 1924 base85 encoding
+  # # @author sd77
+  module Rfc1924
+    extend ModuleMethods
+
+    # RFC1924 alphabet
+    ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~"
+
+    # Encode a value (0..84 integer) to a RFC 1924 character
+    # @param [Integer] value
+    # @return [String]
+    def self.encode_value(value)
+      ALPHABET[value]
+    end
+
+    # Decode a character from RFC 1924 alphabet and give its index in alphabet
+    # @param [String] char a acharacter from base85 alphabet
+    # @return [Integer] index of this character in alphabet
+    # @raise DecodeError +char+ is not known in alphabet
+    def self.decode_char(char)
+      case char
+      when "0".."9"
+        char.ord - 48
+      when "A".."Z"
+        char.ord - 55 # - 65 + 10
+      when "a".."z"
+        char.ord - 61 # - 97 + 36
+      when "!", "#".."&", "(".."+", "-", ";".."@", "^".."`", "{".."~"
+        ALPHABET.index(char)
+      else
+        raise DecodeError, "unknown character '#{char}'"
+      end
+    end
+  end
+end

data/lib/base85/standard.rb

@@ -4,81 +4,29 @@ module Base85
   # Standard base85 encoding. This encoding uses '!' to 'u' ASCII characters to encode data.
   # @author sd77
   module Standard
+    extend ModuleMethods
+
     # ASCII value for character '!'
     BASE_ASCII_VALUE = "!".ord
-    # @private
-    LUT = (0..4).map { |count| 85**(4 - count) }.freeze
-
-    # @private
-    # Encode a single word
-    # @param [Integer] word
-    # @param [Integer] byte_count byte count of word. Must be in range 1..4
-    def self.encode_word(word, byte_count: 4)
-      encoded = "~" * 5
-      5.times do |i|
-        word, r = word.divmod(85)
-        encoded[-i - 1] = (BASE_ASCII_VALUE + r).chr
-      end
-      encoded[..byte_count]
-    end
 
-    # Encode data using standard base85 encoding
-    # @param [String] data
+    # Encode a value (0..84 integer) to a standard base85 character
+    # @param [Integer] value
     # @return [String]
-    def self.encode(data)
-      result = +""
-      data.unpack("N*").each do |word|
-        result << encode_word(word)
-      end
-
-      last_count = data.length % 4
-      return result if last_count.zero?
-
-      last_chars =  data[-last_count..] << ("\x00" * (4 - last_count))
-      result << encode_word(last_chars.unpack1("N"), byte_count: last_count)
+    def self.encode_value(value)
+      (BASE_ASCII_VALUE + value).chr
     end
 
-    # Decode data using standard base85 encoding
-    # @param [String] data
-    # @return [String]
-    # @raise [DecodeError] unknown character or invalid tuple
-    def self.decode(data)
-      result = +""
-      word = 0
-      count = 0
-      data.each_char do |c|
-        case c
-        when "!".."u" # rubocop:disable Lint/MixedCaseRange
-          idx = c.ord - BASE_ASCII_VALUE
-        else
-          raise DecodeError, "unknown character '#{c}'"
-        end
-
-        word += idx * LUT[count]
-        count += 1
-
-        if (count == 5) && (word > 0xffffffff)
-          raise DecodeError, "invalid tuple"
-        elsif count == 5
-          wordbuf = " " * 4
-          3.downto(0) do |i|
-            wordbuf.setbyte(i, word & 0xff)
-            word >>= 8
-          end
-          result << wordbuf
-          count = 0
-          word = 0
-        end
+    # Decode a character from standard base85 and give its index in alphabet
+    # @param [String] char a acharacter from base85 alphabet
+    # @return [Integer] index of this character in alphabet
+    # @raise DecodeError +char+ is not known in alphabet
+    def self.decode_char(char)
+      case char
+      when "!".."u" # rubocop:disable Lint/MixedCaseRange
+        char.ord - BASE_ASCII_VALUE
+      else
+        raise DecodeError, "unknown character '#{char}'"
       end
-
-      return result if count.zero?
-
-      count -= 1
-      word += LUT[count]
-      result << ((word >> 24) & 0xff).chr if count >= 1
-      result << ((word >> 16) & 0xff).chr if count >= 2
-      result << ((word >> 8) & 0xff).chr if count == 3
-      result
     end
   end
 end

data/lib/base85/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Base85
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/base85/z85.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Base85
+  # ZeroMQ (Z85) encoding
+  module Z85
+    extend ModuleMethods
+
+    # Z85 alphabet
+    ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ.-:+=^!/*?&<>()[]{}@%$#"
+
+    # Encode a value (0..84 integer) to a Z85 character
+    # @param [Integer] value
+    # @return [String]
+    def self.encode_value(value)
+      ALPHABET[value]
+    end
+
+    # Decode a character from Z85 and give its index in alphabet
+    # @param [String] char a acharacter from base85 alphabet
+    # @return [Integer] index of this character in alphabet
+    # @raise DecodeError +char+ is not known in alphabet
+    def self.decode_char(char)
+      case char
+      when "0".."9"
+        char.ord - 48
+      when "a".."z"
+        char.ord - 87 # - 97 + 10
+      when "A".."Z"
+        char.ord - 29 # - 65 + 26
+      when "!", "#".."&", "(".."+", "-".."/", ":", "<".."@", "[", "]", "^", "{".."}"
+        ALPHABET.index(char)
+      else
+        raise DecodeError, "unknown character '#{char}'"
+      end
+    end
+  end
+end

data/lib/base85.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "base85/version"
+require_relative "base85/module_methods"
 require_relative "base85/standard"
+require_relative "base85/z85"
+require_relative "base85/rfc1924"
 
 # Provide methods to encode/decode Base85 formatted data
 # @author sd77
@@ -31,6 +34,10 @@ module Base85
     case alphabet
     when :standard
       Standard.encode(data)
+    when :z85
+      Z85.encode(data)
+    when :rfc1924
+      Rfc1924.encode(data)
     else
       raise UnknownAlphabetError.new(alphabet)
     end
@@ -40,6 +47,10 @@ module Base85
     case alphabet
     when :standard
       Standard.decode(data)
+    when :z85
+      Z85.decode(data)
+    when :rfc1924
+      Rfc1924.decode(data)
     else
       raise UnknownAlphabetError.new(alphabet)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: base85
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - sd77
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-14 00:00:00.000000000 Z
+date: 2025-06-15 00:00:00.000000000 Z
 dependencies: []
 description: Encode and decode base85 data. Multiple alphabets are supported (standard,
   Z85 or rfc1924)
@@ -25,8 +25,11 @@ files:
 - README.md
 - Rakefile
 - lib/base85.rb
+- lib/base85/module_methods.rb
+- lib/base85/rfc1924.rb
 - lib/base85/standard.rb
 - lib/base85/version.rb
+- lib/base85/z85.rb
 - sig/base85.rbs
 homepage: https://codeberg.org/sd77/base85
 licenses: