Ascii85 0.9.0

data/History.txt

@@ -0,0 +1,5 @@
+=== 0.9.0 / 2009-02-17
+
+* 1 major enhancement
+
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,6 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+lib/ascii85.rb
+spec/ascii85_spec.rb

data/README.txt

@@ -0,0 +1,59 @@
+= Ascii85
+
+* http://ascii85.rubyforge.org
+
+== DESCRIPTION:
+
+Ascii85 is a simple gem that provides methods for encoding/decoding Adobe's
+binary-to-text encoding of the same name.
+
+See http://www.adobe.com/products/postscript/pdfs/PLRM.pdf page 131 and
+http://en.wikipedia.org/wiki/Ascii85 for more information about the format.
+
+
+== SYNOPSIS:
+
+  require 'rubygems'
+  require 'ascii85'
+
+  Ascii85::encode("Ruby")
+  => "<~;KZGo~>"
+
+  Ascii85::decode("<~;KZGo~>")
+  => "Ruby"
+
+In addition, Ascii85::encode can take a second parameter that specifies the
+length of the returned lines. The default is 80; use +false+ for unlimited.
+
+Ascii85::decode expects the input to be enclosed in <~ and ~>. It ignores
+everything outside of these.
+
+
+== INSTALL:
+
+* sudo gem install ascii85
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Johannes Holzfuß
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,43 @@
+
+require 'rubygems'
+
+require 'hoe'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+require 'lib/ascii85.rb'
+
+
+# rspec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ["--color"]
+end
+
+desc "Show specdoc"
+Spec::Rake::SpecTask.new('specdoc') do |t|
+  t.spec_opts = ["--color", "--format=specdoc"]
+end
+
+
+# Hoe
+
+Hoe.new('Ascii85', Ascii85::VERSION) do |p|
+  p.author  = "Johannes Holzfuß"
+  p.email   = "Drangon@gmx.de"
+  p.summary = "Ascii85 encoder/decoder"
+
+  p.description = "Ascii85 provides methods to encode/decode Adobe's binary-to-text encoding of the same name."
+
+  p.remote_rdoc_dir = ''
+
+  p.testlib    = "spec"
+  p.test_globs = "spec/ascii85_spec.rb"
+end
+
+
+# default task is spec
+task :default => :spec

data/lib/ascii85.rb

@@ -0,0 +1,205 @@
+#
+# Ascii85 is an implementation of Adobe's binary-to-text encoding of the same
+# name in pure Ruby.
+#
+# See http://www.adobe.com/products/postscript/pdfs/PLRM.pdf page 131 and
+# http://en.wikipedia.org/wiki/Ascii85 for more information about the format.
+#
+# Author::  Johannes Holzfuß (Drangon@gmx.de)
+# License:: Distributed under the MIT License (see README.txt)
+#
+
+
+module Ascii85
+  # The gem version number
+  VERSION = '0.9.0' # :nodoc:
+
+  #
+  # Encodes the given String as Ascii85.
+  #
+  # If +wrap_lines+ evaluates to +false+, the output will be returned as a
+  # single long line. Otherwise #encode formats the output into lines of
+  # length +wrap_lines+ (minimum is 2).
+  #
+  #     Ascii85::encode("Ruby")
+  #     => <~;KZGo~>
+  #
+  #     Ascii85::encode("Supercalifragilisticexpialidocious", 15)
+  #     => <~;g!%jEarNoBkD
+  #        BoB5)0rF*),+AU&
+  #        0.@;KXgDe!L"F`R
+  #        ~>
+  #
+  #     Ascii85::encode("Supercalifragilisticexpialidocious", false)
+  #     => <~;g!%jEarNoBkDBoB5)0rF*),+AU&0.@;KXgDe!L"F`R~>
+  #
+  #
+  def self.encode(str, wrap_lines = 80)
+
+    return '' if str.to_s.empty?
+
+    # Compute number of \0s to pad the message with (0..3)
+    padding_length = (-str.to_s.length) % 4
+
+    # Extract big-endian integers
+    tuples = (str.to_s + ("\0" * padding_length)).unpack('N*')
+
+    # Encode
+    tuples.map! do |tuple|
+      if tuple == 0
+        'z'
+      else
+        tmp = ""
+        5.times do
+          tmp += ((tuple % 85) + 33).chr
+          tuple /= 85
+        end
+        tmp.reverse
+      end
+    end
+
+    # We can't use the z-abbreviation if we're going to cut off padding
+    if (padding_length > 0) and (tuples.last == 'z')
+      tuples[-1] = '!!!!!'
+    end
+
+    # Cut off the padding
+    tuples[-1] = tuples[-1][0..(4 - padding_length)]
+
+    # Add start-marker and join into a String
+    result = '<~' + tuples.join
+
+    # If we don't need to wrap the lines to a certain length, add ~> and return
+    if (!wrap_lines)
+      return result + '~>'
+    end
+
+    # Otherwise we wrap the lines
+
+    line_length = [2, wrap_lines.to_i].max
+
+    wrapped = []
+    0.step(result.length, line_length) do |index|
+      wrapped << result.slice(index, line_length)
+    end
+
+    # Add end-marker -- on a new line if necessary
+    if (wrapped.last.length + 2) > line_length
+      wrapped << '~>'
+    else
+      wrapped[-1] += '~>'
+    end
+
+    return wrapped.join("\n")
+  end
+
+  #
+  # Searches through +str+ and decodes the _first_ Ascii85-String found.
+  #
+  # #decode expects an Ascii85-encoded String enclosed in <~ and ~>. It will
+  # ignore all characters outside these markers.
+  #
+  #     Ascii85::decode("<~;KZGo~>")
+  #     => "Ruby"
+  #
+  #     Ascii85::decode("Foo<~;KZGo~>Bar<~;KZGo~>Baz")
+  #     => "Ruby"
+  #
+  #     Ascii85::decode("No markers")
+  #     => ""
+  #
+  # #decode will raise Ascii85::DecodingError when malformed input is
+  # encountered.
+  #
+  def self.decode(str)
+
+    # Find the Ascii85 encoded data between <~ and ~>
+    input = str.to_s.match(/<~.*?~>/mn)
+
+    return '' if input.nil?
+
+    # Remove the delimiters
+    input = input.to_s[2..-3]
+
+    return '' if input.empty?
+
+    # Decode
+    result = []
+
+    count = 0
+    word = 0
+
+    input.each_byte do |c|
+
+      case c.chr
+      when /[ \t\r\n\f\0]/
+        # Ignore whitespace
+        next
+
+      when 'z'
+        if count == 0
+          # Expand z to 0-word
+          result << 0
+        else
+          raise(Ascii85::DecodingError, "Found 'z' inside Ascii85 5-tuple")
+        end
+
+      when '!'..'u'
+        # Decode 5 characters into a 4-byte word
+        word += (c - 33) * 85**(4 - count)
+        count += 1
+
+        if count == 5
+
+          if word >= 2**32
+            raise(Ascii85::DecodingError,
+                  "Invalid Ascii85 5-tuple (#{word} >= 2**32)")
+          end
+
+          result << word
+          word = 0
+          count = 0
+        end
+
+      else
+        raise(Ascii85::DecodingError,
+              "Illegal character inside Ascii85: #{c.chr.dump}")
+      end
+
+    end
+
+    # Convert result into a String
+    result = result.pack('N*')
+
+    if count > 0
+      # Finish last, partially decoded 32-bit-word
+
+      if count == 1
+        raise(Ascii85::DecodingError,
+              "Last 5-tuple consists of single character")
+      end
+
+      count -= 1
+      word += 85**(4 - count)
+
+      result += ((word >> 24) & 255).chr if count >= 1
+      result += ((word >> 16) & 255).chr if count >= 2
+      result += ((word >>  8) & 255).chr if count == 3
+    end
+
+    return result
+  end
+
+  #
+  # This error is raised when Ascii85::decode encounters one of the following
+  # problems in the input:
+  #
+  # * An invalid character. Valid characters are '!'..'u' and 'z'.
+  # * A 'z' character inside a 5-tuple. 'z's are only valid on their own.
+  # * An invalid 5-tuple that decodes to >= 2**32
+  # * The last tuple consisting of a single character. Valid tuples always have
+  #   at least two characters.
+  #
+  class DecodingError < StandardError; end
+
+end

data/spec/ascii85_spec.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'ascii85'
+
+describe Ascii85 do
+
+  TEST_CASES = {
+
+    ""          => "",
+    " "         => "<~+9~>",
+
+    "\0" * 1    => "<~!!~>",
+    "\0" * 2    => "<~!!!~>",
+    "\0" * 3    => "<~!!!!~>",
+    "\0" * 4    => "<~z~>",
+    "\0" * 5    => "<~z!!~>",
+    "A\0\0\0\0" => "<~5l^lb!!~>", # No z-abbreviation!
+
+    "A"         => "<~5l~>",
+    "AB"        => "<~5sb~>",
+    "ABC"       => "<~5sdp~>",
+    "ABCD"      => "<~5sdq,~>",
+    "ABCDE"     => "<~5sdq,70~>",
+    "ABCDEF"    => "<~5sdq,77I~>",
+    "ABCDEFG"   => "<~5sdq,77Kc~>",
+    "ABCDEFGH"  => "<~5sdq,77Kd<~>",
+    "ABCDEFGHI" => "<~5sdq,77Kd<8H~>",
+    "Ascii85"   => "<~6$$OMBfIs~>",
+
+    'Antidisestablishmentarianism' => '<~6#LdYA8-*rF*(i"Ch[s(D.RU,@<-\'jDJ=0/~>',
+
+    # Dōmo arigatō, Mr. Roboto (according to Wikipedia)
+    'どうもありがとうミスターロボット' =>
+        "<~j+42iJVN3:K&_E6j+<0KJW/W?W8iG`j+EuaK\"9on^Z0sZj+FJoK:LtSKB%T?~>",
+
+    [Math::PI].pack('G') => "<~5RAV2<(&;T~>",
+    [Math::E].pack('G')  => "<~5R\"n0M\\K6,~>"
+  }
+
+  it "#decode should be the inverse of #encode" do
+
+    # Generate a random string
+    test_str = ""
+    (1 + rand(255)).times do
+      test_str += rand(256).chr
+    end
+
+    encoded = Ascii85::encode(test_str)
+    decoded = Ascii85::decode(encoded)
+
+    decoded.should == test_str
+  end
+
+  describe "#encode" do
+
+    it "should encode all specified test-cases correctly" do
+      TEST_CASES.each_pair do |input, encoded|
+        Ascii85::encode(input).should == encoded
+      end
+    end
+
+    it "should produce output lines no longer than specified" do
+      test_str = '0123456789' * 30
+
+      #
+      # No wrap
+      #
+      Ascii85::encode(test_str, false).count("\n").should == 0
+
+      #
+      # x characters per line, except for the last one
+      #
+      x = 2 + rand(255) # < test_str.length
+      encoded = Ascii85::encode(test_str, x)
+
+      # Determine the length of all lines
+      count_arr = []
+      encoded.each_line do |line|
+        count_arr << line.chomp.length
+      end
+
+      # The last line is allowed to be shorter than x, so remove it
+      count_arr.pop if count_arr.last <= x
+
+      # If the end-marker is on a line of its own, the next-to-last line is
+      # allowed to be shorter than specified by exactly one character
+      count_arr.pop if (encoded[-3].chr =~ /[\r\n]/) and (count_arr.last == x-1)
+
+      # Remove all line-lengths that are of length x from count_arr
+      count_arr.delete_if { |len| len == x }
+
+      # Now count_arr should be empty
+      count_arr.should be_empty
+    end
+
+    it "should not split the end-marker to achieve correct line length" do
+      Ascii85::encode("\0" * 4, 4).should == "<~z\n~>"
+    end
+
+  end
+
+  describe "#decode" do
+
+    it "should decode all specified test-cases correctly" do
+      TEST_CASES.each_pair do |decoded, input|
+        Ascii85::decode(input).should == decoded
+      end
+    end
+
+    it "should ignore everything before/after the delimiter-pairs" do
+      Ascii85::decode("Doesn't contain delimiters").should == ''
+      Ascii85::decode("FooBar<~z~>BazQux").should == ("\0" * 4)
+    end
+
+    it "should ignore whitespace" do
+      decoded = Ascii85::decode("<~6   #LdYA\r\08\n  \n\n- *rF*(i\"Ch[s \t(D.RU,@ <-\'jDJ=0\f/~>")
+      decoded.should == 'Antidisestablishmentarianism'
+    end
+
+    describe "Error conditions" do
+
+      it "should raise DecodingError if it encounters a word >= 2**32" do
+        lambda {
+          Ascii85::decode('<~s8W-#~>')
+        }.should raise_error Ascii85::DecodingError
+      end
+
+      it "should raise DecodingError if it encounters an invalid character" do
+        lambda {
+          Ascii85::decode('<~!!y!!~>')
+        }.should raise_error Ascii85::DecodingError
+      end
+
+      it "should raise DecodingError if the last tuple consists of a single character" do
+        lambda {
+          Ascii85::decode('<~!~>')
+        }.should raise_error Ascii85::DecodingError
+      end
+
+      it "should raise DecodingError if a z is found inside a 5-tuple" do
+        lambda {
+          Ascii85::decode('<~!!z!!~>')
+        }.should raise_error Ascii85::DecodingError
+      end
+
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: Ascii85
+version: !ruby/object:Gem::Version 
+  version: 0.9.0
+platform: ruby
+authors: 
+- "Johannes Holzfu\xC3\x9F"
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDKjCCAhKgAwIBAgIBADANBgkqhkiG9w0BAQUFADA7MRAwDgYDVQQDDAdfcmFu
+  Z29uMRMwEQYKCZImiZPyLGQBGRYDZ214MRIwEAYKCZImiZPyLGQBGRYCZGUwHhcN
+  MDkwMjE0MTgxNDM5WhcNMTAwMjE0MTgxNDM5WjA7MRAwDgYDVQQDDAdfcmFuZ29u
+  MRMwEQYKCZImiZPyLGQBGRYDZ214MRIwEAYKCZImiZPyLGQBGRYCZGUwggEiMA0G
+  CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDa7HRW1pPBbx8k9GLOzYBwHNLAOvHc
+  kWfq5E99plLhxKobF7xSValm2csTPQqF8549JJUADGrmeSyFx4z241JtDATjFdYI
+  5LaBXqvxR/c6BfPqPOIuZqc6o1VEpMEVsgKqcL0wjmOaNXMDL7vWj2+LyizWqMXJ
+  Y2Hj6GlR6kYzoUyOoAPO+FG363YT++tFvOaOmba314dL40r/Spc730gr1utS8pHA
+  t8Gl+Z0EC5gmcUvfDT2sVAF8k9qQhGGqOuOM2HDP+ZrJ368UJznVBxp9YhUveGc2
+  MPXvntkrN2XLfGjV2Tr418v7OBP+0IgnZVBM8O7q+iMJmuv/yt2M53H/AgMBAAGj
+  OTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBT83GfQpOoJZm8B
+  gY6lweCTOsu0QTANBgkqhkiG9w0BAQUFAAOCAQEAAT33NPbPZVy3tgPsl1TicU9q
+  eBen2WkXfrCO8jP1ivuFQqMHl5b+MpG2LIwEB45QLLnoXmcW+C4ihGdkYG078uor
+  ZskHRETlHJ791l6PyGw5j1oFSwbeYwYIFBWcRrq0KdcZO4CZb7rln2S06ZJWQIMg
+  930O6/WuJyRQLr1PaTJcUGoHUC9cd4CE7ARuck3V38vNR4azjAznCa01mgSkp9UQ
+  xPVAMuP9qOp6+OFiuL7DDCHgGI52vDFlUSU+hMcsSSDbYSFcilSPlZ3WLTlOhM4d
+  5FGhYN16QZS8VKLApBtxxP9XmwFASMyJLNizTN2q6hCCy/MjoTzHWzodPaWm0Q==
+  -----END CERTIFICATE-----
+
+date: 2009-02-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: Ascii85 provides methods to encode/decode Adobe's binary-to-text encoding of the same name.
+email: Drangon@gmx.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- lib/ascii85.rb
+- spec/ascii85_spec.rb
+has_rdoc: true
+homepage: http://ascii85.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ascii85
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Ascii85 encoder/decoder
+test_files: 
+- spec/ascii85_spec.rb