binascii 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3e19a8aa182b270cc304d659d9ad8d8decea96ec2e1bec4fd4cdcd81f9af34f
+  data.tar.gz: cd5d28e6e1bae4c736edbba2ba85ccdb9eea43c1e7255cc78c403007da8ea355
+SHA512:
+  metadata.gz: deeb040eb021c8fb261d03146fbfea27103317b978b040826d28f3b39e9ed976bf1dd038489c4b27183c416239c11c15ba7a405985a5a0c0a2e478662f7b2528
+  data.tar.gz: 62cbff23f40de4a92434259d074b60198b4f2dd80f97554b741b737e26ee1211a527776ec13c711e34cb6a689450a86927a05701b0f09d058f10e6e86e90ff97

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 1.0.0
+* Birthday!

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'benchmark-ips'
+  gem 'pry-byebug'
+  gem 'ruby-prof'
+  gem 'rake'
+end
+
+group :test do
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,92 @@
+## binascii [![Build Status](https://secure.travis-ci.org/camertron/binascii.png?branch=master)](http://travis-ci.org/camertron/binascii)
+
+A Ruby version of Python's binascii module.
+
+## Installation
+
+`gem install binascii`
+
+## Usage
+
+```ruby
+require 'binascii'
+```
+
+### Base64
+
+Encodes and decodes text in the base64 format. This differs from Ruby's built-in base64 encoding mechanism in that it removes line breaks from the result and provides the option to append a newline character at the end.
+
+```ruby
+Binascii.b2a_base64('abc')                  # => "YWJj\n"
+Binascii.b2a_base64('abc', newline: false)  # => "YWJj"
+
+Binascii.a2b_base64('YWJj')    # => "abc"
+Binascii.a2b_base64("YWJj\n")  # => "abc"
+```
+
+### CRC32
+
+This is simply a wrapper around the CRC32 functionality present in Ruby's `Zlib` module.
+
+```ruby
+Binascii.crc32('abc')  # => 891568578
+```
+
+### Hexlify
+
+Outputs each byte of the input data as two hexadecimal characters. Produces a string that contains twice as many bytes as the input data.
+
+```ruby
+# aliased as .hexlify
+Binascii.b2a_hex('jkl')  # => "6a6b6c"
+
+# aliased as .unhexlify
+Binascii.a2b_hex('6a6b6c')  # => "jkl"
+```
+
+### HQX and Run-length Encoding
+
+Encodes and decodes bytes in the HQX format. HQX is (apparently) often combined with RLE, or run-length encoding.
+
+```ruby
+rle = Binascii.rlecode_hqx('aaaaabbbbbb')            # => "a\x90\x05b\x90\x06"
+hqx = Binascii.b2a_hqx(rle)                          # => # => "BC!&BT!'"
+
+Binascii.rledecode_hqx(Binascii.a2b_hqx(hqx).first)  # => "aaaaabbbbbb"
+```
+
+`.a2b_hqx` returns an array with two elements. The first is the decoded result, and the second is an integer containing either 1 or 0. 1 indicates decoding was stopped because of the presence of a stop character (ASCII code 58, i.e. a colon, ':'), 0 means no stop character was found.
+
+### Quoted-printable
+
+Encodes and decodes bytes in the quoted-printable format.
+
+```ruby
+Binascii.b2a_qp("some \x12 \x14 data")  # => "some =12 =14 data"
+Binascii.a2b_qp('some =12 =14 data')    # => "some \x12 \x14 data"
+```
+
+### Unix-to-unix
+
+Encodes and decodes bytes in the unix-to-unix format.
+
+```ruby
+Binascii.b2a_uu("abc\n")         # => "$86)C\"@  \n"
+Binascii.a2b_uu("$86)C\"@  \n")  # => "abc\n"
+```
+
+## Running Benchmarks
+
+Benchmarks are provided for most of Binascii's functionality in the bench/ directory. Run each benchmark directly, i.e. `bundle exec ruby bench/hqx_bench.rb`. Binascii's algorithms are compared to native Ruby versions when they are available. However it should be noted that, with the exception of CRC32, all algorithms implemented by this library will not produce exactly the same output as their Ruby counterparts as they accept generally more options and therefore produce more customizable output. It should also be noted that the Ruby equivalents are all implemented in C and will therefore be much faster in most cases.
+
+## Running Tests
+
+`bundle exec rspec` should do the trick :)
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require 'binascii'
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/binascii.gemspec

@@ -0,0 +1,18 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'binascii/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'binascii'
+  s.version  = ::Binascii::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'https://github.com/camertron/binascii'
+  s.license  = 'MIT'
+  s.description = s.summary = "A Ruby version of Python's binascii module"
+
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+
+  s.require_path = 'lib'
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'CHANGELOG.md', 'README.md', 'Rakefile', 'binascii.gemspec']
+end

data/lib/binascii.rb

@@ -0,0 +1,17 @@
+require 'binascii/qp'
+require 'binascii/uu'
+require 'binascii/base64'
+require 'binascii/hqx'
+require 'binascii/crc32'
+require 'binascii/hex'
+
+module Binascii
+  include Qp
+  include Uu
+  include Base64
+  include Hqx
+  include Crc32
+  include Hex
+
+  extend Binascii
+end

data/lib/binascii/base64.rb

@@ -0,0 +1,13 @@
+module Binascii
+  module Base64
+    def a2b_base64(string)
+      string.unpack('m').first
+    end
+
+    def b2a_base64(data, newline: true)
+      result = [data].pack('m').gsub!("\n", '')
+      result << "\n" if newline
+      result
+    end
+  end
+end

data/lib/binascii/crc32.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'zlib'
+
+module Binascii
+  module Crc32
+    def crc32(data, crc = 0)
+      Zlib.crc32(data, crc)
+    end
+  end
+end

data/lib/binascii/hex.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Binascii
+  module Hex
+    A2B_LO = (('0'..'9').to_a + ('a'..'z').to_a + ('A'..'Z').to_a)
+      .each_with_object({}).with_index { |(chr, ret), idx| ret[chr.ord] = idx }
+      .freeze
+
+    A2B_HI = A2B_LO
+      .each_with_object({}) { |(ord, idx), ret| ret[ord] = idx + (0xF * idx) }
+      .freeze
+
+    B2A = (0...256).each_with_object({}) do |b, ret|
+      ret[b] = b.to_s(16).rjust(2, '0')
+    end.freeze
+
+    def b2a_hex(data)
+      String.new('', encoding: 'ASCII-8BIT').tap do |result|
+        data.each_byte do |byte|
+          result << B2A[byte]
+        end
+      end
+    end
+
+    alias_method :hexlify, :b2a_hex
+
+    def a2b_hex(data)
+      String.new('', encoding: 'ASCII-8BIT').tap do |result|
+        len = data.bytesize
+        pos = 0
+
+        while pos < len
+          result << (A2B_HI[data.getbyte(pos)] | A2B_LO[data.getbyte(pos + 1)])
+          pos += 2
+        end
+      end
+    end
+
+    alias_method :unhexlify, :a2b_hex
+  end
+end

data/lib/binascii/hqx.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+module Binascii
+  module Hqx
+    class DecodeError < ::StandardError
+    end
+
+    A2B_TABLE = [
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :skip, :fail, :fail, :skip, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, 0x00,  0x01,  0x02,  0x03,  0x04,  0x05,  0x06,
+      0x07,  0x08,  0x09,  0x0A,  0x0B,  0x0C,  :fail, :fail,
+      0x0D,  0x0E,  0x0F,  0x10,  0x11,  0x12,  0x13,  :fail,
+      0x14,  0x15,  :done, :fail, :fail, :fail, :fail, :fail,
+      0x16,  0x17,  0x18,  0x19,  0x1A,  0x1B,  0x1C,  0x1D,
+      0x1E,  0x1F,  0x20,  0x21,  0x22,  0x23,  0x24,  :fail,
+      0x25,  0x26,  0x27,  0x28,  0x29,  0x2A,  0x2B,  :fail,
+      0x2C,  0x2D,  0x2E,  0x2F,  :fail, :fail, :fail, :fail,
+      0x30,  0x31,  0x32,  0x33,  0x34,  0x35,  0x36,  :fail,
+      0x37,  0x38,  0x39,  0x3A,  0x3B,  0x3C,  :fail, :fail,
+      0x3D,  0x3E,  0x3F,  :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail,
+      :fail, :fail, :fail, :fail, :fail, :fail, :fail, :fail
+    ].freeze
+
+    B2A_TABLE = "!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr"
+      .bytes
+      .freeze
+
+    RLE_RUN_CHAR = 0x90
+
+    CRC_TABLE = [
+      0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
+      0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
+      0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
+      0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
+      0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
+      0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
+      0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
+      0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
+      0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
+      0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
+      0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
+      0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
+      0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
+      0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
+      0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
+      0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
+      0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
+      0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
+      0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
+      0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
+      0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
+      0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
+      0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
+      0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
+      0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
+      0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
+      0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
+      0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
+      0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
+      0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
+      0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
+      0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
+    ].freeze
+
+    def a2b_hqx(str)
+      result = String.new('', encoding: 'ASCII-8BIT')
+      bits = 0
+      buffer = 0
+      pos = 0
+      done = 0
+
+      str.each_byte do |byte|
+        ch = A2B_TABLE[byte]
+
+        if ch == :fail
+          raise DecodeError, "Illegal character at position #{pos}"
+        elsif ch == :done
+          done = 1
+          break
+        end
+
+        buffer = (buffer << 6) | ch
+        bits += 6
+
+        if bits >= 8
+          bits -= 8
+          result << ((buffer >> bits) & 0xFF)
+          buffer &= ((1 << bits) - 1)
+        end
+
+        pos += 1
+      end
+
+      if bits > 0 && done == 0
+        raise DecodeError, 'String has incomplete number of bytes'
+      end
+
+      [result, done]
+    end
+
+    def b2a_hqx(data)
+      String.new('', encoding: 'ASCII-8BIT').tap do |result|
+        bits = 0
+        buffer = 0
+
+        data.each_byte do |byte|
+          buffer = (buffer << 8) | byte
+          bits += 8
+
+          while bits >= 6
+            ch = (buffer >> (bits - 6)) & 0x3F
+            result << B2A_TABLE[ch]
+            bits -= 6
+          end
+        end
+
+        if bits > 0
+          buffer <<= (6 - bits)
+          result << B2A_TABLE[buffer & 0x3F]
+        end
+      end
+    end
+
+    def rlecode_hqx(data)
+      String.new('', encoding: 'ASCII-8BIT').tap do |result|
+        len = data.bytesize
+        pos = 0
+
+        while pos < len
+          byte = data.getbyte(pos)
+
+          if byte == RLE_RUN_CHAR
+            result << RLE_RUN_CHAR
+            result << 0
+          else
+            count = 0
+            (len - pos).times do |i|
+              break if count >= 255
+              break if data.getbyte(pos + i) != byte
+              count += 1
+            end
+
+            result << byte
+
+            if count > 3
+              result << RLE_RUN_CHAR
+              result << count
+              pos += count - 1
+            end
+          end
+
+          pos += 1
+        end
+      end
+    end
+
+    def rledecode_hqx(data)
+      String.new('', encoding: 'ASCII-8BIT').tap do |result|
+        len = data.bytesize
+        last_byte = data.getbyte(0)
+
+        if last_byte == RLE_RUN_CHAR
+          raise DecodeError, 'Orphaned RLE code at start'
+        end
+
+        result << last_byte
+        pos = 1
+
+        while pos < len
+          byte = data.getbyte(pos)
+
+          if byte == RLE_RUN_CHAR
+            count = data.getbyte(pos + 1)
+
+            if count == 0
+              # indicates an escaped RLE_RUN_CHAR, so output it
+              result << RLE_RUN_CHAR
+            else
+              # one less than count because we have already outputted the
+              # character once during the previous iteration
+              result << (last_byte.chr * (count - 1))
+            end
+
+            # skip count
+            pos += 1
+          else
+            result << byte
+          end
+
+          last_byte = byte
+          pos += 1
+        end
+      end
+    end
+
+    def crc_hqx(data, crc = 0)
+      crc &= 0xFFFF
+      len = data.bytesize
+
+      data.each_byte do |byte|
+        crc = ((crc << 8) & 0xFF00) ^ CRC_TABLE[(crc >> 8) ^ byte]
+      end
+
+      crc
+    end
+  end
+end

data/lib/binascii/qp.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require 'binascii/utils'
+
+module Binascii
+  module Qp
+    LINE_MAX = 76
+
+    def a2b_qp(str, header: false)
+      return '' if str == '='
+      str = Utils.render_string(str) if str.index("\r")
+      first_byte = str.getbyte(0)
+
+      str = if first_byte == 95 || first_byte == 61
+        str
+      else
+        idx = str.index("\n")
+        idx ? str[(idx + 1)..-1] : ''
+      end
+
+      str = str.unpack('M').first
+
+      str.gsub!('==', '=')
+      str.gsub!('_', ' ') if header
+
+      str
+    end
+
+    def b2a_qp(data, header: false, quote_tabs: false, is_text: true)
+      @byte_cache ||= {}
+
+      String.new.tap do |result|
+        data_size = data.bytesize
+        line_len = 0
+        cr_lf = false
+
+        # This code is obtusely procedural for performance reasons.
+        # The python C version isn't much better.
+        Utils.each_byte_quad(data) do |leading, byte, trailing1, trailing2|
+          repl = nil
+          repl_size = 1
+
+          if byte == 13  # linefeed, \r
+            if is_text
+              repl = byte
+            else
+              repl = '=0D'
+            end
+          elsif byte == 10  # carriage return, \n
+            if is_text
+              cr_lf = true if leading == 13
+
+              if cr_lf && leading != 13
+                repl = "\r\n"
+                repl_size = 2
+              else
+                repl = byte
+              end
+            else
+              repl = '=0A'
+            end
+          elsif byte == 95  # underscore
+            repl = header ? '=5F' : '_'
+            repl_size = repl.bytesize
+          elsif byte == 32  # space
+            if (!trailing1 || trailing1 == 10 || (trailing1 == 13 && trailing2 == 10) || quote_tabs) && is_text
+              repl = "=20"
+              repl_size = 3
+            else
+              repl = header ? '_' : ' '
+            end
+          elsif byte == 9  # tab
+            if (!trailing1 || trailing1 == 10 || (trailing1 == 13 && trailing2 == 10) || quote_tabs) && is_text
+              repl = "=09"
+              repl_size = 3
+            else
+              repl = "\t"
+            end
+          elsif byte == 46  # period
+            # I don't understand these rules, but whatever
+            if line_len == 0 && (!trailing1 || trailing1 == 10 || trailing1 == 13 || trailing1 == 0)
+              repl = '=2E'
+              repl_size = 3
+            else
+              repl = '.'
+            end
+          elsif (byte >= 33 && byte <= 126) && byte != 61  # all printable ascii characters except '='
+            repl = byte
+          else
+            repl = (@byte_cache[byte] ||= "=#{byte.to_s(16).rjust(2, '0').upcase}")
+            repl_size = 3
+          end
+
+          if (line_len + repl_size) > LINE_MAX - 1
+            line_len = 0
+            result << "=\r\n"
+            result << repl
+          else
+            result << repl
+          end
+
+          line_len += repl_size
+        end
+      end
+    end
+  end
+end

data/lib/binascii/utils.rb

@@ -0,0 +1,54 @@
+module Binascii
+  module Utils
+    class << self
+      def each_byte_quad(data, &block)
+        data.force_encoding('ASCII-8BIT')
+        yield [nil, data.getbyte(0), data.getbyte(1), data.getbyte(2)]
+        return if data.bytesize == 1
+
+        data.each_byte.each_cons(4, &block)
+
+        if data.bytesize > 2
+          yield [data.getbyte(-3), data.getbyte(-2), data.getbyte(-1), nil]
+        end
+
+        yield [data.getbyte(-2), data.getbyte(-1), nil, nil]
+      end
+
+      def each_byte_pair(data, &block)
+        data.force_encoding('ASCII-8BIT')
+        data.each_byte.each_cons(2, &block)
+        yield [data.getbyte(-1), nil]
+      end
+
+      def render_string(data)
+        read_pos = 0
+        write_pos = 0
+        line_start_pos = 0
+        result = ''
+
+        each_byte_pair(data) do |current, trailing|
+          if current == 13
+            if trailing != 10
+              write_pos = line_start_pos
+              next
+            end
+          elsif current == 10
+            line_start_pos = read_pos
+          end
+
+          if write_pos >= result.bytesize
+            result << current
+          else
+            result.setbyte(write_pos, current)
+          end
+
+          read_pos += 1
+          write_pos += 1
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/binascii/uu.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Binascii
+  module Uu
+    def b2a_uu(data, backtick: false)
+      if data.bytesize == 0
+        backtick ? "`\n" : " \n"
+      else
+        result = [data].pack('u')
+        backtick ? result : result.gsub!('`', ' ')
+      end
+    end
+
+    def a2b_uu(str)
+      str.force_encoding('ASCII-8BIT')
+      len = (str.getbyte(0) - 32) & 077
+      str.unpack('u').first.rjust(len, "\0")
+    end
+  end
+end

data/lib/binascii/version.rb

@@ -0,0 +1,3 @@
+module Binascii
+  VERSION = '1.0.0'
+end

data/spec/crc32_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Binascii do
+  describe '#crc32' do
+    it do
+      crc = described_class.crc32("Test the CRC-32 of")
+      crc = described_class.crc32(" this string.", crc)
+      expect(crc).to eq(1571220330)
+    end
+  end
+end

data/spec/hex_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Binascii do
+  let(:s) { "{s\005\000\000\000worldi\002\000\000\000s\005\000\000\000helloi\001\000\000\0000" }
+  let(:t) { described_class.b2a_hex(s) }
+  let(:u) { described_class.a2b_hex(t) }
+
+  it do
+    expect(s).to eq(u)
+  end
+
+  describe '#b2a_hex' do
+    it do
+      expect(described_class.b2a_hex(s)).to eq(t)
+    end
+  end
+
+  describe '#a2b_hex' do
+    it do
+      expect(described_class.a2b_hex(t)).to eq(u)
+    end
+  end
+end

data/spec/hqx_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Binascii do
+  def ascii8(str)
+    str.force_encoding('ASCII-8BIT')
+  end
+
+  describe 'rle' do
+    it do
+      data = ('a' * 100) + 'b' + ('c' * 300)
+      encoded = described_class.rlecode_hqx(data)
+      expect(encoded).to eq(ascii8("a\x90dbc\x90\xffc\x90-"))
+      decoded = described_class.rledecode_hqx(encoded)
+      expect(decoded).to eq(data)
+    end
+  end
+
+  describe 'hqx' do
+    it do
+      data = "The quick brown fox jumps over the lazy dog.\r\n" +
+        (0...256).to_a.pack('C*') +
+        "\r\nHello world.\n"
+
+      rle = described_class.rlecode_hqx(data)
+      a = described_class.b2a_hqx(rle)
+
+      b, _ = described_class.a2b_hqx(a)
+      res = described_class.rledecode_hqx(b)
+      expect(res).to eq(data)
+    end
+  end
+
+  describe '#crc_hqx' do
+    it do
+      crc = described_class.crc_hqx('Test the CRC-32 of', 0)
+      crc = described_class.crc_hqx(" this string.", crc)
+      expect(crc).to eq(14290)
+
+      [0, 1, 0x1234, 0x12345, 0x12345678, -1].each do |crc|
+        expect(described_class.crc_hqx('', crc)).to eq(crc & 0xffff)
+      end
+    end
+  end
+end

data/spec/qp_spec.rb

@@ -0,0 +1,268 @@
+require 'spec_helper'
+
+describe Binascii do
+  def ascii8(str)
+    str.force_encoding('ASCII-8BIT')
+  end
+
+  describe '#a2b_qp' do
+    def a2b_qp(str, options = {})
+      described_class.a2b_qp(str, **options)
+    end
+
+    it do
+      expect(a2b_qp('=')).to eq('')
+    end
+
+    it do
+      expect(a2b_qp('= ')).to eq('= ')
+    end
+
+    it do
+      expect(a2b_qp('==')).to eq('=')
+    end
+
+    it do
+      expect(a2b_qp("=\nAB")).to eq('AB')
+    end
+
+    it do
+      expect(a2b_qp("=\r\nAB")).to eq('AB')
+    end
+
+    it do
+      expect(a2b_qp("=\rAB")).to eq('')
+    end
+
+    it do
+      expect(a2b_qp("=\rAB\nCD")).to eq('CD')
+    end
+
+    it do
+      expect(a2b_qp('=AB')).to eq(ascii8("\xab"))
+    end
+
+    it do
+      expect(a2b_qp('=ab')).to eq(ascii8("\xab"))
+    end
+
+    it do
+      expect(a2b_qp('=AX')).to eq('=AX')
+    end
+
+    it do
+      expect(a2b_qp('=XA')).to eq('=XA')
+    end
+
+    it do
+      expect(a2b_qp('=A')).to eq('=A')
+    end
+
+    it do
+      expect(a2b_qp('_')).to eq('_')
+    end
+
+    it do
+      expect(a2b_qp('_', header: true)).to eq(' ')
+    end
+
+    # @TODO
+    # self.assertRaises(TypeError, b2a_qp, foo="bar")
+
+    it do
+      expect(a2b_qp("=00\r\n=00")).to eq("\x00\r\n\x00")
+    end
+  end
+
+  describe '#b2a_qp' do
+    def b2a_qp(str, options = {})
+      described_class.b2a_qp(str, **options)
+    end
+
+    it do
+      expect(b2a_qp("\xff\r\n\xff\n\xff")).to eq("=FF\r\n=FF\r\n=FF")
+    end
+
+    it do
+      expect(b2a_qp(('0' * 75) + "\xff\r\n\xff\r\n\xff")).to eq(
+        ('0' * 75) + "=\r\n=FF\r\n=FF\r\n=FF"
+      )
+    end
+
+    it do
+      expect(b2a_qp("\x7f")).to eq('=7F')
+    end
+
+    it do
+      expect(b2a_qp('=')).to eq('=3D')
+    end
+
+    it do
+      expect(b2a_qp('_')).to eq('_')
+    end
+
+    it do
+      expect(b2a_qp('_', header: true)).to eq('=5F')
+    end
+
+    it do
+      expect(b2a_qp('x y', header: true)).to eq('x_y')
+    end
+
+    it do
+      expect(b2a_qp('x ', header: true)).to eq('x=20')
+    end
+
+    it do
+      expect(b2a_qp('x y', header: true, quote_tabs: true)).to eq('x=20y')
+    end
+
+    it do
+      expect(b2a_qp("x\ty", header: true)).to eq("x\ty")
+    end
+
+    it do
+      expect(b2a_qp(' ')).to eq('=20')
+    end
+
+    it do
+      expect(b2a_qp("\t")).to eq('=09')
+    end
+
+    it do
+      expect(b2a_qp(' x')).to eq(' x')
+    end
+
+    it do
+      expect(b2a_qp("\tx")).to eq("\tx")
+    end
+
+    it do
+      expect(b2a_qp(" ")).to eq("=20")
+    end
+
+    it do
+      expect(b2a_qp("\t")).to eq("=09")
+    end
+
+    it do
+      expect(b2a_qp("\0")).to eq("=00")
+    end
+
+    it do
+      expect(b2a_qp("\0\n")).to eq("=00\n")
+    end
+
+    it do
+      expect(b2a_qp("\0\n", quote_tabs: true)).to eq("=00\n")
+    end
+
+    it do
+      expect(b2a_qp("x y\tz")).to eq("x y\tz")
+    end
+
+    it do
+      expect(b2a_qp("x y\tz", quote_tabs: true)).to eq('x=20y=09z')
+    end
+
+    it do
+      expect(b2a_qp("x y\tz", is_text: false)).to eq("x y\tz")
+    end
+
+    it do
+      expect(b2a_qp("x \ny\t\n")).to eq("x=20\ny=09\n")
+    end
+
+    it do
+      expect(b2a_qp("x \ny\t\n", quote_tabs: true)).to eq("x=20\ny=09\n")
+    end
+
+    it do
+      expect(b2a_qp("x \ny\t\n", is_text: false)).to eq("x =0Ay\t=0A")
+    end
+
+    it do
+      expect(b2a_qp("x \ry\t\r")).to eq("x \ry\t\r")
+    end
+
+    it do
+      expect(b2a_qp("x \ry\t\r", quote_tabs: true)).to eq("x=20\ry=09\r")
+    end
+
+    it do
+      expect(b2a_qp("x \ry\t\r", is_text: false)).to eq("x =0Dy\t=0D")
+    end
+
+    it do
+      expect(b2a_qp("x \r\ny\t\r\n")).to eq("x=20\r\ny=09\r\n")
+    end
+
+    it do
+      expect(b2a_qp("x \r\ny\t\r\n", quote_tabs: true)).to eq("x=20\r\ny=09\r\n")
+    end
+
+    it do
+      expect(b2a_qp("x \r\ny\t\r\n", is_text: false)).to eq("x =0D=0Ay\t=0D=0A")
+    end
+
+    it do
+      expect(b2a_qp("x \r")).to eq("x \r")
+    end
+
+    it do
+      expect(b2a_qp("x\t\r")).to eq("x\t\r")
+    end
+
+    it do
+      expect(b2a_qp("x \r", quote_tabs: true)).to eq("x=20\r")
+    end
+
+    it do
+      expect(b2a_qp("x\t\r", quote_tabs: true)).to eq("x=09\r")
+    end
+
+    it do
+      expect(b2a_qp("x \r", is_text: false)).to eq('x =0D')
+    end
+
+    it do
+      expect(b2a_qp("x\t\r", is_text: false)).to eq("x\t=0D")
+    end
+
+    it do
+      expect(b2a_qp('.')).to eq('=2E')
+    end
+
+    it do
+      expect(b2a_qp(".\n")).to eq("=2E\n")
+    end
+
+    it do
+      expect(b2a_qp(".\r")).to eq("=2E\r")
+    end
+
+    it do
+      expect(b2a_qp(".\0")).to eq('=2E=00')
+    end
+
+    it do
+      expect(b2a_qp("a.\n")).to eq("a.\n")
+    end
+
+    it do
+      french = "J'interdis aux marchands de vanter trop leur marchandises. "\
+        "Car ils se font vite pédagogues et t'enseignent comme but ce qui n'est "\
+        "par essence qu'un moyen, et te trompant ainsi sur la route à suivre les "\
+        "voilà bientôt qui te dégradent, car si leur musique est vulgaire ils te "\
+        "fabriquent pour te la vendre une âme vulgaire."
+
+      expect(b2a_qp(french)).to eq(<<~END.gsub(/\r?\n/, "\r\n").strip)
+        J'interdis aux marchands de vanter trop leur marchandises. Car ils se font =
+        vite p=C3=A9dagogues et t'enseignent comme but ce qui n'est par essence qu'=
+        un moyen, et te trompant ainsi sur la route =C3=A0 suivre les voil=C3=A0 bi=
+        ent=C3=B4t qui te d=C3=A9gradent, car si leur musique est vulgaire ils te f=
+        abriquent pour te la vendre une =C3=A2me vulgaire.
+      END
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$:.push(File.dirname(__FILE__))
+
+require 'rspec'
+require 'binascii'
+require 'pry-byebug'
+
+RSpec.configure do |config|
+  # configure me here
+end

data/spec/uu_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Binascii do
+  def ascii8(str)
+    str.force_encoding('ASCII-8BIT')
+  end
+
+  describe '#a2b_uu' do
+    def a2b_uu(str)
+      described_class.a2b_uu(str)
+    end
+
+    it do
+      expect(a2b_uu("\x7f")).to eq(ascii8("\x00") * 31)
+    end
+
+    it do
+      expect(a2b_uu("\x80")).to eq(ascii8("\x00") * 32)
+    end
+
+    it do
+      expect(a2b_uu("\xff")).to eq(ascii8("\x00") * 31)
+    end
+
+    it do
+      expect(a2b_uu(" \n")).to eq('')
+    end
+
+    it do
+      expect(a2b_uu("`\n")).to eq('')
+    end
+
+    it do
+      expect(a2b_uu("$`$-A=```\n")).to eq(a2b_uu("$ $-A=   \n"))
+    end
+  end
+
+  describe '#b2a_uu' do
+    def b2a_uu(str, options = {})
+      described_class.b2a_uu(str, **options)
+    end
+
+    it do
+      expect(b2a_uu('x')).to eq("!>   \n")
+    end
+
+    it do
+      expect(b2a_uu('')).to eq(" \n")
+    end
+
+    it do
+      expect(b2a_uu('', backtick: true)).to eq("`\n")
+    end
+
+    it do
+      expect(b2a_uu("\x00Cat")).to eq("$ $-A=   \n")
+    end
+
+    it do
+      expect(b2a_uu("\x00Cat", backtick: true)).to eq("$`$-A=```\n")
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: binascii
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-16 00:00:00.000000000 Z
+dependencies: []
+description: A Ruby version of Python's binascii module
+email:
+- camertron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- README.md
+- Rakefile
+- binascii.gemspec
+- lib/binascii.rb
+- lib/binascii/base64.rb
+- lib/binascii/crc32.rb
+- lib/binascii/hex.rb
+- lib/binascii/hqx.rb
+- lib/binascii/qp.rb
+- lib/binascii/utils.rb
+- lib/binascii/uu.rb
+- lib/binascii/version.rb
+- spec/crc32_spec.rb
+- spec/hex_spec.rb
+- spec/hqx_spec.rb
+- spec/qp_spec.rb
+- spec/spec_helper.rb
+- spec/uu_spec.rb
+homepage: https://github.com/camertron/binascii
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A Ruby version of Python's binascii module
+test_files: []