crockford32 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f6e7d5926825497887afa8a356c29d3d858c8fd77c8885b926899b69e110b5d2
+  data.tar.gz: 1d012996acd856eed31ec4aa096c6f1c2ee193b2df081138670201546811363d
+SHA512:
+  metadata.gz: 4027fea38aa6aeb2f627e203d09345afd53a0e7120a25aec1d52ac5b1a1d0e626a8c37a02677a8eb47d5bed0b45db3264f2c4e33a6d7175bddd9b0e09e0efafa
+  data.tar.gz: 7af4989d8267bef92f06347af2bdd8cfaa668bf15c4e142111549939bcd4b8b4fa97c845d7cc29e23d48a8c386734600858689d02877e84c9bef3e3712277ac6

data/.standard.yml

@@ -0,0 +1,2 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# Changelog
+
+## v1.0.0 - 2022-02-19
+- Initial release

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", "~> 13.0"
+gem "minitest", "~> 5.0"
+gem "benchmark-ips", "~> 2.10"
+gem "debug", "~> 1.4"
+gem "standard", "~> 1.3"
+gem "yard", "~> 0.9.27"

data/Gemfile.lock

@@ -0,0 +1,63 @@
+PATH
+  remote: .
+  specs:
+    crockford32 (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    benchmark-ips (2.10.0)
+    debug (1.4.0)
+      irb (>= 1.3.6)
+      reline (>= 0.2.7)
+    io-console (0.5.11)
+    irb (1.4.1)
+      reline (>= 0.3.0)
+    minitest (5.15.0)
+    parallel (1.21.0)
+    parser (3.1.0.0)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.2.1)
+    reline (0.3.1)
+      io-console (~> 0.5)
+    rexml (3.2.5)
+    rubocop (1.25.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.15.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.15.2)
+      parser (>= 3.0.1.1)
+    rubocop-performance (1.13.2)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.7.2)
+      rubocop (= 1.25.1)
+      rubocop-performance (= 1.13.2)
+    unicode-display_width (2.1.0)
+    webrick (1.7.0)
+    yard (0.9.27)
+      webrick (~> 1.7.0)
+
+PLATFORMS
+  x86_64-darwin-19
+
+DEPENDENCIES
+  benchmark-ips (~> 2.10)
+  crockford32!
+  debug (~> 1.4)
+  minitest (~> 5.0)
+  rake (~> 13.0)
+  standard (~> 1.3)
+  yard (~> 0.9.27)
+
+BUNDLED WITH
+   2.3.3

data/README.md

@@ -0,0 +1,167 @@
+# Crockford32
+A fast little-endian implementation of [Douglas Crockford's Base32 specification](https://www.crockford.com/base32.html).
+
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'crockford32'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install crockford32
+
+
+## Usage
+Encode data with the `encode` method:
+
+```ruby
+encoded = Crockford32.encode(1234) # encoded = "J61"
+```
+See the [the encode API documentation for error details](https://tinychameleon.github.io/crockford32/Crockford32.html#encode-class_method).
+
+---
+
+Decode a value with the `decode` method:
+
+```ruby
+decoded = Crockford32.decode("J61") # decoded = 1234
+```
+See the [the decode API documentation for error details](https://tinychameleon.github.io/crockford32/Crockford32.html#decode-class_method).
+
+
+### Strings
+You can also encode and decode strings by providing the `:string` value as the `into:` argument to `decode`.
+Encoding a string requires no special consideration.
+
+```ruby
+encoded = Crockford32.encode("abc") # encoded = "1KR66"
+decoded = Crockford32.decode(encoded, into: :string) # decoded = "abc"
+```
+
+When decoding you may receive a byte string if the encoded value is not alphanumeric:
+
+```ruby
+decoded = Crockford32.decode("J61", into: :string) # decoded = "\xD2\x04"
+```
+
+### Padding to a Length
+You can ensure your encoded values are a specific length by specifying a `length:` on `encode`:
+
+```ruby
+encoded = Crockford32.encode(1234, length: 5) # encoded = "J6100"
+```
+
+The padding is always "0" values and is always appended to the end of the encoded string.
+Whatever you specify as the `length:` will be the length of the encoded string you receive.
+
+### Check Symbols
+If you wish to append a check symbol for simple modulus-based error detection both `encode` and `decode` support it with the `check:` keyword.
+
+```ruby
+encoded = Crockford32.encode(1234, check: true) # encoded = "J61D". "D" is the checksum symbol.
+decoded = Crockford32.decode(encoded, check: true) # decoded = 1234. Checksum is tested.
+```
+
+An error will be raised if the decoding process does not pass the checksum:
+
+```ruby
+decoded = Crockford32.decode("J71D", check: true) # Notice the 6 changed to a 7.
+~/.../crockford32/lib/crockford32.rb:43:in `decode': Value J71 has checksum 8 but requires 13 (Crockford32::ChecksumError)
+	from (irb):2:in `<main>'
+	from bin/console:8:in `<main>'
+```
+
+If you specify a `length:` and `check: true` when encoding, the checksum will be included as part of the `length:`.
+
+### Encoding Type Support
+This library currently supports encoding `Integer` and `String` values.
+
+### Little-Endian Encoding
+The encoding example above shows the little-endian results of encoding a number.
+Some libraries encode using big-endian and will return `"16J"` when the number `1234` is encoded.
+
+This library _always_ uses little-endian.
+
+### More Information
+For more detailed information about the library [see the API documentation](https://tinychameleon.github.io/crockford32/).
+
+
+## Development
+To get started development on this gem run the `bin/setup` command. This will install dependencies and run the tests and linting tasks to ensure everything is working.
+
+For an interactive console with the gem loaded run `bin/console`.
+
+
+## Testing
+Use the `bundle exec rake test` command to run unit tests. To install the gem onto your local machine for general integration testing use `bundle exec rake install`.
+
+
+## Releases
+Do the following to release a new version of this gem:
+
+- Update the version number in [lib/crockford32/version.rb](./lib/crockford32/version.rb)
+- Ensure necessary documentation changes are complete
+- Ensure changes are in the [CHANGELOG.md](./CHANGELOG.md)
+- Create the new release using `bundle exec rake release`
+
+After this is done the following side-effects should be visible:
+
+- A new git tag for the version number should exist
+- Commits for the new version should be pushed to GitHub
+- The new gem should be available on [rubygems.org](https://rubygems.org).
+
+Finally, update the documentation hosted on GitHub Pages:
+
+- Check-out the `gh-pages` branch
+- Merge `main` into the `gh-pages` branch
+- Generate the documentation with `bundle exec rake yard`
+- Commit the documentation on the `gh-pages` branch
+- Push the new documentation so GitHub Pages can deploy it
+
+
+## Benchmarks
+Benchmarking is tricky and the goal of a benchmark should be clear before attempting performance improvements. The goal of this library for performance is as follows:
+
+> This library should be capable of encoding and decoding IDs at a rate which does not make it a bottleneck for the majority of web APIs.
+
+Given the above goal statement, these benchmarks run on the following environment:
+
+| Attribute | Value |
+|:--|--:|
+| Ruby Version | 3.1.0 |
+| MacOS Version | Catalina 10.15.7 (19H1615) |
+| MacOS Model Identifier | MacBookPro10,1 |
+| MacOS Processor Name | Quad-Core Intel Core i7 |
+| MacOS Processor Speed | 2.7 GHz |
+| MacOS Number of Processors | 1 |
+| MacOS Total Number of Cores | 4 |
+| MacOS L2 Cache (per Core) | 256 KB |
+| MacOS L3 Cache | 6 MB |
+| MacOS Hyper-Threading Technology | Enabled |
+| MacOS Memory | 16 GB |
+
+When run using a constant 16 bytes of data in the above environment the performance is approximately as follows:
+
+```
+~/…/crockford32› date && ruby test/benchmarks/current.rb
+Fri Feb 18 15:35:49 PST 2022
+Warming up --------------------------------------
+              encode    11.498k i/100ms
+              decode    10.550k i/100ms
+       encode string     7.686k i/100ms
+       decode string     6.798k i/100ms
+Calculating -------------------------------------
+              encode    117.614k (± 3.5%) i/s -    597.896k in   5.090119s
+              decode    108.253k (± 3.2%) i/s -    548.600k in   5.073326s
+       encode string     78.690k (± 3.1%) i/s -    399.672k in   5.084255s
+       decode string     69.707k (± 3.5%) i/s -    353.496k in   5.077700s
+```
+
+Being conservative in estimation 30k i/s round trip decoding and encoding cycles should be possible. This achieves the performance goal.

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+require "standard/rake"
+require "yard"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+YARD::Rake::YardocTask.new do |t|
+  t.files = ["lib/**/*.rb", "-", "CHANGELOG.md"]
+  t.options = ["--private", "-o", "./docs"]
+end
+
+task default: %i[test standard]
+
+desc "Benchmark the current implementation"
+task benchmark: [] do |t|
+  sh "date; ruby test/benchmarks/current.rb"
+end

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "crockford32"
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+bundle install
+bundle exec rake test standard

data/crockford32.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/crockford32/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "crockford32"
+  spec.version = Crockford32::VERSION
+  spec.authors = ["Stephan Tarulli"]
+  spec.email = ["srt@tinychameleon.com"]
+
+  spec.summary = "A fast little-endian implementation of Crockford's Base32 specification."
+  spec.description = "A fast little-endian implementation of Crockford's Base32 specification."
+  spec.homepage = "https://github.com/tinychameleon/crockford32"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = File.join(spec.homepage, "blob/main/CHANGELOG.md")
+  spec.metadata["bug_tracker_uri"] = File.join(spec.homepage, "issues")
+  spec.metadata["documentation_uri"] = "https://tinychameleon.github.io/crockford32/"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/crockford32/errors.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Crockford32
+  # The base error for all possible errors from {Crockford32}
+  class Error < StandardError; end
+
+  # The base error for all errors from {Crockford32.encode}
+  class EncodeError < Error; end
+
+  # The base error for all errors from {Crockford32.decode}
+  class DecodeError < Error; end
+
+  # An error representing the length of an encoded value being larger than the
+  # requested maximum length.
+  class LengthTooSmallError < EncodeError
+    # @param value [Integer, String] the value to be encoded.
+    # @param needed [Integer] the needed length to encode the value.
+    # @param given [Integer] the specified length to encode the value.
+    def initialize(value, needed, given)
+      super("Encoding #{value} requires a minimum length of #{needed}, but received #{given}")
+    end
+  end
+
+  # An error representing an attmept to encode an unsupported type.
+  class UnsupportedEncodingTypeError < EncodeError
+    # @param type [Type] the unsupported type of the encode attempt.
+    def initialize(type)
+      super("Encoding #{type} not supported")
+    end
+  end
+
+  # An error representing a decode operation finding an illegal symbol within a
+  # provided value.
+  class InvalidCharacterError < DecodeError
+    # @param string [String] the string to decode.
+    # @param index [Integer] the index within the string of the invalid character.
+    def initialize(string, index)
+      super("Invalid character '#{string[index]}' in '#{string}' at index #{index}")
+    end
+  end
+
+  # An error representing an unsupported destination type for a decode operation.
+  class UnsupportedDecodingTypeError < DecodeError
+    # @param type [Symbol] the supplied destination type.
+    def initialize(type)
+      super("Decoding as :#{type} not supported")
+    end
+  end
+
+  # An error representing a checksum mismatch between the decoded value and the
+  # supplied check symbol.
+  class ChecksumError < DecodeError
+    # @param value [String] the Base32 value to decode.
+    # @param checksum [Integer] the checksum of the decoded value.
+    # @param checksum_required [Integer] the required checksum of the decoded value.
+    def initialize(value, checksum, checksum_required)
+      super("Value #{value} has checksum #{checksum} but requires #{checksum_required}")
+    end
+  end
+end

data/lib/crockford32/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Crockford32
+  # The library version.
+  VERSION = "1.0.0"
+end

data/lib/crockford32.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+require_relative "crockford32/version"
+require_relative "crockford32/errors"
+
+# A fast little-endian implementation of {https://www.crockford.com/base32.html Douglas Crockford’s Base32 specification}.
+#
+# @since 1.0.0
+module Crockford32
+  # The number of bits encoded per symbol.
+  ENCODED_BITS = 0x05
+
+  # The minimum value of a check symbol.
+  CHECK_SYMBOL_MIN_VALUE = 0x20
+
+  # The prime number used to implement error detection.
+  CHECKSUM_PRIME = 0x25
+
+  # The ordinal value of an ASCII dash character.
+  DASH = "-".ord.freeze
+
+  # standard:disable Layout/ExtraSpacing,Layout/ArrayAlignment
+
+  # Symbol values in order by encoded ASCII ordinal values.
+  DECODE_ORDINALS = [
+    nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+    nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+    nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
+     34, nil, nil, nil, nil, nil,  32, nil, nil, nil, nil, nil,
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9, nil, nil,
+    nil,  35, nil, nil, nil,  10,  11,  12,  13,  14,  15,  16,
+     17,   1,  18,  19,   1,  20,  21,   0,  22,  23,  24,  25,
+     26,  36,  27,  28,  29,  30,  31, nil, nil, nil, nil, nil,
+    nil,  10,  11,  12,  13,  14,  15,  16,  17,   1,  18,  19,
+      1,  20,  21,   0,  22,  23,  24,  25,  26,  36,  27,  28,
+     29,  30,  31, nil, nil, nil,  33
+  ].freeze
+
+  # Encoding symbols ordered by bit value.
+  ENCODE_SYMBOLS = [
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F",
+    "G", "H", "J", "K", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z",
+    "*", "~", "$", "=", "U"
+  ].freeze
+
+  # standard:enable Layout/ExtraSpacing,Layout/ArrayAlignment
+
+  # @!group Public Methods
+
+  # Decode a Base32 value.
+  #
+  # @since 1.0.0
+  #
+  # @param value [String] the Base32 value to decode.
+  # @param into [Symbol] the destination type to decode into. Can be +:integer+ or +:string+.
+  # @param check [Boolean] whether to validate the check symbol.
+  #
+  # @return [Integer, String] the decoded value.
+  #
+  # @raise [ChecksumError] when the check symbol does not match the decoded checksum.
+  # @raise [InvalidCharacterError] when the value being decoded has a character outside the
+  #   Base32 symbol set or a misplaced check symbol.
+  # @raise [UnsupportedDecodingTypeError] when the requested +into:+ type is not supported.
+  def self.decode(value, into: :integer, check: false)
+    checksum = check ? value[-1] : nil
+    value = check ? value[0...-1] : value
+
+    result = le_decode_number value
+
+    if check
+      actual = result % CHECKSUM_PRIME
+      required = DECODE_ORDINALS[checksum.ord]
+      raise ChecksumError.new(value, actual, required) if actual != required
+    end
+
+    convert result, into
+  end
+
+  # Encode a value as Base32.
+  #
+  # @since 1.0.0
+  #
+  # @param value [Integer, String] the value to encode.
+  # @param length [Integer] the exact length of the Base32 string. Will be padded with "0" to meet length.
+  # @param check [Boolean] whether to include a check symbol. This symbol is included in the length.
+  #
+  # @return [String] the encoded value.
+  #
+  # @raise [LengthTooSmallError] when the requested +length:+ is not large enough to fit the encoded result.
+  # @raise [UnsupportedEncodingTypeError] when the value to encode is an unsupported type.
+  def self.encode(value, length: nil, check: false)
+    le_encode_number(raw_value_to_number(value), length, check)
+  end
+
+  # @!endgroup
+
+  # @!group Private Methods
+  # @!visibility private
+
+  # Decode a value with the expectation that it is in little-endian order.
+  #
+  # @param encoded_value [String] the value to decode.
+  # @return [Integer] the decoded value.
+  def self.le_decode_number(encoded_value)
+    symbol = -1
+    bits = -ENCODED_BITS
+    encoded_value.bytes.reduce(0) do |result, ch|
+      symbol += 1
+      next result if ch == DASH
+      val = DECODE_ORDINALS[ch.ord]
+      raise InvalidCharacterError.new(encoded_value, symbol) if val.nil? || val >= CHECK_SYMBOL_MIN_VALUE
+      bits += ENCODED_BITS
+      result | (val << bits)
+    end
+  end
+
+  # Convert a decoded result into the destination type.
+  #
+  # @param result [Integer] the decoded value.
+  # @param type [Symbol] the destination type for the value. Can be +:integer+ or +:string+.
+  # @return [Integer, String] the decoded value converted to the destination type.
+  def self.convert(result, type)
+    case type
+    when :integer
+      result
+    when :string
+      into_string result
+    else
+      raise UnsupportedDecodingTypeError.new(type)
+    end
+  end
+
+  # Convert an Integer into a String.
+  #
+  # Each 8-bit sequence is packed into a String in little-endian order.
+  #
+  # @param result [Integer] the decoded value.
+  # @return [String] the decoded value as a String.
+  def self.into_string(result)
+    q, r = result.bit_length.divmod(0x08)
+    q += 1 if r > 0
+    bytes = Array.new(q)
+    q.times do |i|
+      bytes[i] = result & 0xff
+      result >>= 0x08
+    end
+    bytes.pack("C*")
+  end
+
+  # Convert a raw value into an Integer for encoding.
+  #
+  # @param value [Integer, String] the value being encoded.
+  # @return [Integer] the value converte to an Integer.
+  def self.raw_value_to_number(value)
+    case value
+    when String
+      q, r = value.bytesize.divmod(8)
+      if r == 0
+        string_to_integer_unrolled value, q
+      else
+        string_to_integer value
+      end
+    when Integer
+      value
+    else
+      raise UnsupportedEncodingTypeError.new value.class
+    end
+  end
+
+  # Convert a String to an Integer one byte per iteration.
+  #
+  # @param s [String] the String to convert.
+  # @return [Integer] the String converted to an Integer in little-endian order.
+  def self.string_to_integer(s)
+    shift = -0x08
+    s.each_byte.reduce(0) do |n, b|
+      shift += 0x08
+      n + (b << shift)
+    end
+  end
+
+  # Convert a String to an Integer 8 bytes per iteration.
+  # @param s [String] the String to convert.
+  # @param iterations [Integer] the number of iterations to perform.
+  # @return [Integer] the String converted to an Integer in little-endian order.
+  def self.string_to_integer_unrolled(s, iterations)
+    n = 0
+    bytes = s.bytes
+    while iterations > 0
+      o = (iterations - 1) * 0x40
+      i = iterations * 0x08
+      n += bytes[i - 1] << (o + 0x38)
+      n += bytes[i - 2] << (o + 0x30)
+      n += bytes[i - 3] << (o + 0x28)
+      n += bytes[i - 4] << (o + 0x20)
+      n += bytes[i - 5] << (o + 0x18)
+      n += bytes[i - 6] << (o + 0x10)
+      n += bytes[i - 7] << (o + 0x08)
+      n += bytes[i - 8] << (o + 0x00)
+      iterations -= 1
+    end
+    n
+  end
+
+  # Encode an Integer as a Base32 value.
+  #
+  # @see encode
+  # @return [String]
+  def self.le_encode_number(number, length, check)
+    result = +""
+    n = number
+    loop do
+      chunk = n & 0x1F
+      result << ENCODE_SYMBOLS[chunk]
+      n >>= ENCODED_BITS
+      break if n == 0
+    end
+
+    rlen = result.length + (check ? 1 : 0)
+    if length
+      raise LengthTooSmallError.new(number, rlen, length) if rlen > length
+      result << "0" * (length - rlen)
+    end
+
+    result << ENCODE_SYMBOLS[number % CHECKSUM_PRIME] if check
+    result.freeze
+  end
+
+  private_class_method [:le_decode_number, :convert, :into_string, :raw_value_to_number,
+    :string_to_integer, :string_to_integer_unrolled, :le_encode_number]
+
+  # @!endgroup
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: crockford32
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Stephan Tarulli
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-02-20 00:00:00.000000000 Z
+dependencies: []
+description: A fast little-endian implementation of Crockford's Base32 specification.
+email:
+- srt@tinychameleon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- crockford32.gemspec
+- lib/crockford32.rb
+- lib/crockford32/errors.rb
+- lib/crockford32/version.rb
+homepage: https://github.com/tinychameleon/crockford32
+licenses: []
+metadata:
+  homepage_uri: https://github.com/tinychameleon/crockford32
+  source_code_uri: https://github.com/tinychameleon/crockford32
+  changelog_uri: https://github.com/tinychameleon/crockford32/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/tinychameleon/crockford32/issues
+  documentation_uri: https://tinychameleon.github.io/crockford32/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: A fast little-endian implementation of Crockford's Base32 specification.
+test_files: []