ascii85_native 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29b779e3fe160aeafcecd06d79f661f9a4b0a992dd053af39515eacfa7e2f367
-  data.tar.gz: bbc6085d316adaea46f93095dbf738aea1441fb682c32736152c0674c33f7df2
+  metadata.gz: 5fbe80d98b9dc9e8d4a04542b578609ce16839be238ad35dd238a001dc02aaa8
+  data.tar.gz: 817069f8f96a4b699f0e8f31bc66ece1f79b190678334dcad478aac0fa910590
 SHA512:
-  metadata.gz: 0a4267955d024d17a5a540961e583bb498c4c70eddc9073d680925e3a8b9c10aeaed73a9ea07dbef6455c6dec62d308c61e465739312e67c5ff575f75de3bc4e
-  data.tar.gz: af7a04720ee115222ad4897af241ee305486bc2494aa9925acdddaefcb10aa8c5be8bcc723e92818237c04385207137a678cef777a8362dd8b7b9dff8db9c359
+  metadata.gz: 4b6161b062e5a9641c394d31331a79f6fa4bf96d6fc9e65460f3025c71a0eb09fa5b43faf06f7e973920a0454e864672b2ce395a4afd621899ee95752627ebae
+  data.tar.gz: db9217c98eca4134c50c2d9a01f509dbbc089610165bc062ccbe54d347488b54a9269831d7f3fa8761bfb4e6662fa0dd98be93bfb16cb54e2fc98b39659d613c

data/ext/ascii85_native/ascii85_native.c

@@ -1,77 +1,94 @@
-// a85.cpp
-//
-// Ascii85 C++ implementation pulled from https://github.com/larskholte/a85
-// Original C++ Code License: Copy and use as you please. No attribution necessary.
-//
-// Adapted to C language
+// ascii85_native.c
 
+#include "stdlib.h"
 #include "ascii85_native.h"
 
-int size_for_a85(int binlen, bool append_null) {
-    return (binlen * 5 + 3) / 4 + !!append_null;
+int a85_encoded_size(int input_length, bool append_null) {
+    return (input_length * 5 + 3) / 4 + !!append_null;
 }
 
-void to_a85(const u8* data, int binlen, char* text, bool append_null) {
-    // Go to end of data and text buffers
-    data += binlen;
-    text += size_for_a85(binlen,append_null);
+void a85_encode(const u8* input, int input_length, char* output, bool append_null) {
+    // Go to end of input and output buffers
+    input += input_length;
+    output += a85_encoded_size(input_length,append_null);
     // Append null if requested
     if (append_null) {
-        *(--text) = 0;
+        *(--output) = 0;
     }
     // If number of bytes is not divisible by 4, act as if null bytes were added to end of buffer
-    int rem = binlen & 3;
+    int rem = input_length & 3;
     if (rem) {
         u32 val = 0;
         for (int i = 4 - rem; i < 4; i++) {
-            val |= *(--data) << (8 * i);
+            val |= *(--input) << (8 * i);
         }
         int i;
         for (i = 0; i < 4 - rem; i++) {
             val /= 85;
         }
         for (; i <= 4; i++) {
-            *(--text) = val % 85 + 33;
+            *(--output) = val % 85 + 33;
             val /= 85;
         }
-        binlen &= ~3;
+        input_length &= ~3;
     }
-    while (binlen) {
+    while (input_length) {
         // Process chunks of 4 bytes as 32-bit values
-        u32 val = *(--data);
-        val |= *(--data) << 8;
-        val |= *(--data) << 16;
-        val |= *(--data) << 24;
+        u32 val = *(--input);
+        val |= *(--input) << 8;
+        val |= *(--input) << 16;
+        val |= *(--input) << 24;
         // Convert to base 85
-        *(--text) = val % 85 + 33;
+        *(--output) = val % 85 + 33;
         val /= 85;
-        *(--text) = val % 85 + 33;
+        *(--output) = val % 85 + 33;
         val /= 85;
-        *(--text) = val % 85 + 33;
+        *(--output) = val % 85 + 33;
         val /= 85;
-        *(--text) = val % 85 + 33;
+        *(--output) = val % 85 + 33;
         val /= 85;
-        *(--text) = val % 85 + 33;
-        binlen -= 4;
+        *(--output) = val % 85 + 33;
+        input_length -= 4;
     }
 }
 
-int size_for_bin(int textlen) {
-    return (textlen * 4) / 5;
+int a85_decoded_size(int input_length) {
+    return ((input_length * 4) / 5);
 }
 
-void from_a85(const char* text, int textlen, u8* data) {
-    while (textlen) {
+void a85_filter_before_decode(const char* input, int input_length, char* output) {
+	int input_remaining = input_length;
+	while (input_remaining) {
+        if ( !(*input == 0 || (*input >= 10 && *input <= 13)) ) {
+			*output = *input;
+			output++;
+		}
+		input++;
+		input_remaining--;
+	}
+	//*output = '\0';
+}
+
+void a85_decode(const char* input, int input_length, u8* output) {
+	// this is now done from the ruby side
+	//char* filtered_input;
+	//filtered_input = (char*)malloc(input_length*sizeof(char));
+	//a85_filter_before_decode(input, input_length, filtered_input);
+	//int filtered_length = strlen(filtered_input);
+
+    while (input_length) {
+
+		if (*input == 0) { break; }
 
-        while (*text == 0 || (*text >= 10 && *text <= 13)) { text++; textlen--; }
+        if (*input >= 10 && *input <= 13) { input++; input_length--; continue; }
 
-        if (textlen < 5) {
+        if (input_length < 5) {
             // Determine represented value in base 85
             u32 val = 0;
             int factor = 52200625; // 85^4
             int i;
-            for (i = 0; i < textlen; i++) {
-                val += (*(text++) - 33) * factor;
+            for (i = 0; i < input_length; i++) {
+                val += (*(input++) - 33) * factor;
                 factor /= 85;
             }
             for (; i < 5; i++) {
@@ -79,25 +96,25 @@ void from_a85(const char* text, int textlen, u8* data) {
                 factor /= 85;
             }
             int shift = 24;
-            for (i = 0; i < textlen - 1; i++) {
-                *(data++) = val >> shift;
+            for (i = 0; i < input_length - 1; i++) {
+                *(output++) = val >> shift;
                 shift -= 8;
             }
             break;
         }
 
         // Determine represented value in base 85
-        u32 val = (*(text++) - 33) * 52200625; // 85^4
-        val += (*(text++) - 33) * 614125; // 85^3
-        val += (*(text++) - 33) * 7225; // 85^2
-        val += (*(text++) - 33) * 85; // 85^1
-        val += (*(text++) - 33); // 85^0
+        u32 val = (*(input++) - 33) * 52200625; // 85^4
+        val += (*(input++) - 33) * 614125; // 85^3
+        val += (*(input++) - 33) * 7225; // 85^2
+        val += (*(input++) - 33) * 85; // 85^1
+        val += (*(input++) - 33); // 85^0
 
         // Write out in big-endian order
-        *(data++) = val >> 24;
-        *(data++) = val >> 16;
-        *(data++) = val >> 8;
-        *(data++) = val;
-        textlen -= 5;
+        *(output++) = val >> 24;
+        *(output++) = val >> 16;
+        *(output++) = val >> 8;
+        *(output++) = val;
+        input_length -= 5;
     }
 }

data/ext/ascii85_native/ascii85_native.h

@@ -1,9 +1,4 @@
-// a85.h
-//
-// Ascii85 C++ implementation pulled from https://github.com/larskholte/a85
-// Original C++ Code License: Copy and use as you please. No attribution necessary.
-//
-// Adapted to C language
+// ascii85_native.h
 
 #include <stdint.h>
 
@@ -11,17 +6,23 @@ typedef _Bool bool;
 typedef uint8_t u8;
 typedef uint32_t u32;
 
-// Returns size of buffer required for to_a85 function.
-int size_for_a85(int binlen, bool append_null);
+// Returns size of char buffer required for output of a85_encode().
+int a85_encoded_size(int input_length, bool append_null);
 
 // Translates the given binary data of the given size to Ascii85.
 // Can translate in-place.
 // Optionally appends a null character.
-void to_a85(const u8* data, int binlen, char* text, bool append_null);
+void a85_encode(const u8* input, int input_length, char* output, bool append_null);
 
-// Returns the size of buffer required for from_a85 function.
-int size_for_bin(int textlen);
+// Returns the size of u8 buffer required for the output of a85_decode().
+// In reality, the number of decoded characters could be far less due to
+// ignored characters being thrown out (see a85_filter_before_decode())
+int a85_decoded_size(int input_length);
 
-// Translates the given Ascii85 text to binary data.
+// Translates the given Ascii85 input to binary output.
 // Can translate in-place.
-void from_a85(const char* text, int textlen, u8* data);
+void a85_decode(const char* input, int input_length, u8* output);
+
+// Removes unused / ignored characters from the ascii85 input
+// TODO: identify and remove <~ and ~> delimiters
+void a85_filter_before_decode(const char* input, int input_length, char* output);

data/lib/ascii85_native.rb

@@ -5,23 +5,28 @@ require 'ffi'
 module Ascii85Native
   extend FFI::Library
 
+  ffi_lib 'c'
   ffi_lib File.join(File.dirname(__FILE__), 'ascii85_native.so')
 
-  #void to_a85(const u8* data, int binlen, char* text, bool append_null);
-  attach_function :to_a85, [:buffer_in, :int, :buffer_out, :bool], :void
+  #void a85_encode(const u8* data, int binlen, char* text, bool append_null);
+  attach_function :a85_encode, [:buffer_in, :int, :buffer_out, :bool], :void
 
-  #int size_for_a85(int binlen, bool append_null);
-  attach_function :size_for_a85, [:int, :bool], :int
+  #int a85_encoded_size(int binlen, bool append_null);
+  attach_function :a85_encoded_size, [:int, :bool], :int
 
-  #void from_a85(const char* text, int textlen, u8* data);
-  attach_function :from_a85, [:buffer_in, :int, :buffer_out], :void
+  #int a85_decoded_size(int textlen)
+  attach_function :a85_decoded_size, [:int], :int
 
-  #int size_for_bin(int textlen)
-  attach_function :size_for_bin, [:int], :int
+  #void a85_decode(const char* text, int textlen, u8* data);
+  attach_function :a85_filter_before_decode, [:buffer_in, :int, :buffer_out], :void
 
+  #void a85_decode(const char* text, int textlen, u8* data);
+  attach_function :a85_decode, [:buffer_in, :int, :buffer_out], :void
+
+  attach_function :strlen, [:string], :int
 
   def self.encode(input, include_delimiter=false)
-    if input.nil?
+    if input.nil? || input.size == 0 
       return '<~~>' if include_delimiter
       return ''
     end
@@ -35,10 +40,10 @@ module Ascii85Native
 
     FFI::MemoryPointer.new(:uint8, input_data.size) do |in_uint8|
       in_uint8.write_array_of_type(FFI::TYPE_UINT8, :put_uint8, input_data)
-      out_size = self.size_for_a85(input_data.size, true)
+      out_size = self.a85_encoded_size(input_data.size, true)
 
       FFI::MemoryPointer.new(:uint8, out_size) do |output|
-        self.to_a85(in_uint8, input_data.size, output, true)
+        self.a85_encode(in_uint8, input_data.size, output, true)
         if include_delimiter
           return '<~' + (output.read_string() || '') + '~>'
         else
@@ -49,21 +54,70 @@ module Ascii85Native
   end
 
 
-  def self.decode(input)
-    return "" if input.nil?
+  def self.decode(input, force_delimiter=true)
+    return "" if input.nil? || input.size == 0
 
-    if input[0] == '<' && input[1] == '~' && input[-2] == '~' && input[-1] == '>'
+    if force_delimiter
       input = input[2..-3]
+    else
+      start_slice = find_start_slice(input)
+      end_slice = find_end_slice(input)
+      input = input[start_slice..end_slice] if start_slice != 0 || end_slice != -1
     end
 
     FFI::MemoryPointer.new(:char, input.size) do |in_char|
-      in_char.write_string(input)
-      out_size = self.size_for_bin(input.size)
+      FFI::MemoryPointer.new(:char, input.size) do |filtered_char|
+        in_char.write_string(input)
 
-      FFI::MemoryPointer.new(:uint8, out_size) do |output|
-        self.from_a85(in_char, input.size, output)
-        return output.read_string()
+        self.a85_filter_before_decode(in_char, input.size, filtered_char)
+        filtered_length = self.strlen(filtered_char.read_string())
+        puts "filtered_length: #{filtered_length}"
+
+        out_size = self.a85_decoded_size(filtered_length)
+
+        FFI::MemoryPointer.new(:uint8, out_size) do |output|
+          self.a85_decode(filtered_char, filtered_length, output)
+          return output.read_string()
+        end
       end
     end
   end
+
+  def self.find_start_slice(input)
+    start_slice = 0
+    cursor = 0 
+
+    input.size.times do |i|
+      if ['\n', '\r', ' '].include?(input[cursor])
+        cursor += 1
+        next
+      elsif input[cursor] == '<' && input[cursor+1] == '~'
+        start_slice = cursor + 2
+        break
+      else
+        break # input is not delimited
+      end
+    end
+
+    return start_slice
+  end
+
+  def self.find_end_slice(input)
+    end_slice = -1
+    cursor = -1
+
+    input.size.times do |i|
+      if ['\n', '\r', ' '].include?(input[cursor])
+        cursor -= 1
+        next
+      elsif input[cursor] == '>' && input[cursor-1] == '~'
+        end_slice = cursor - 2
+        break
+      else
+        break # input is not delimited
+      end
+    end
+
+    return end_slice
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ascii85_native
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Jason Crossfield
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.2.15
 signing_key:
 specification_version: 4
 summary: Ascii85 Encoder / Decoder with Native C Extensions