Implement snappy compression in userland code

README.md

@@ -8,7 +8,7 @@ Compression streams
 [![Supports PHP 8.0+](https://raw.githubusercontent.com/xp-framework/web/master/static/php-8_0plus.svg)](http://php.net/)
 [![Latest Stable Version](https://poser.pugx.org/xp-forge/compression/version.svg)](https://packagist.org/packages/xp-forge/compression)
 
-Compressing output and decompressing input streams including GZip, BZip2, ZStandard and Brotli.
+Compressing output and decompressing input streams including GZip, BZip2, Brotli, Snappy and ZStandard.
 
 Examples
 --------
@@ -39,11 +39,12 @@ $out->close();
 
 Dependencies
 ------------
-Compression algorithms are implemented in C and thus require a specific PHP extension:
+Compression algorithms might require a specific PHP extension:
 
 * **GZip** - requires PHP's ["zlib" extension](https://www.php.net/zlib)
 * **Bzip2** - requires PHP's ["bzip2" extension](https://www.php.net/bzip2)
 * **Brotli** - requires https://github.com/kjdev/php-ext-brotli
+* **Snappy** - *no dependencies, implemented in userland*
 * **ZStandard** - requires https://github.com/kjdev/php-ext-zstd
 
 Accessing these algorithms can be done via the `Compression` API:
@@ -97,6 +98,7 @@ io.streams.compress.Algorithms@{
   io.streams.compress.Gzip(token: gzip, extension: .gz, supported: true, levels: 1..9)
   io.streams.compress.Bzip2(token: bzip2, extension: .bz2, supported: false, levels: 1..9)
   io.streams.compress.Brotli(token: br, extension: .br, supported: true, levels: 1..11)
+  io.streams.compress.Snappy(token: snappy, extension: .sn, supported: true, levels: 0..0)
   io.streams.compress.ZStandard(token: zstd, extension: .zstd, supported: true, levels: 1..22)
 }
 ```
@@ -137,4 +139,5 @@ $in->close();
 
 See also
 --------
-* The PHP RFC [Modern Compression](https://wiki.php.net/rfc/modern_compression) suggests adding *zstd* and *brotli* into PHP.
+* The PHP RFC [Modern Compression](https://wiki.php.net/rfc/modern_compression) suggests adding *zstd* and *brotli* into PHP.
+* Snappy *does not aim for maximum compression, or compatibility with any other compression library; instead, it aims for very high speeds and reasonable compression*, quoting [its Wikipedia page](https://en.wikipedia.org/wiki/Snappy_(compression))

src/main/php/io/streams/Compression.class.php

@@ -1,6 +1,6 @@
 <?php namespace io\streams;
 
-use io\streams\compress\{Algorithm, Algorithms, None, Brotli, Bzip2, Gzip, ZStandard};
+use io\streams\compress\{Algorithm, Algorithms, None, Brotli, Bzip2, Gzip, Snappy, ZStandard};
 use lang\MethodNotImplementedException;
 
 /**
@@ -22,7 +22,13 @@ static function __static() {
     self::$NONE= new None();
 
     // Register known algorithms included in this library
-    self::$algorithms= (new Algorithms())->add(new Gzip(), new Bzip2(), new Brotli(), new ZStandard());
+    self::$algorithms= (new Algorithms())->add(
+      new Gzip(),
+      new Bzip2(),
+      new Brotli(),
+      new Snappy(),
+      new ZStandard()
+    );
   }
 
   /**

src/main/php/io/streams/compress/BufferedInputStream.class.php

@@ -0,0 +1,78 @@
+<?php namespace io\streams\compress;
+
+use io\streams\InputStream;
+use lang\IllegalArgumentException;
+
+/** @test io.streams.compress.unittest.BufferedInputStreamTest */
+class BufferedInputStream implements InputStream {
+  private $in, $decompress;
+  private $buffer= null, $position= 0;
+
+  /**
+   * Creates a new decompressing input stream
+   *
+   * @param  io.streams.InputStream $in The stream to read from
+   * @param  io.streams.compress.Algorithm|function(string): string $decompress
+   * @throws lang.IllegalArgumentException
+   */
+  public function __construct(InputStream $in, $decompress) {
+    if ($decompress instanceof Algorithm) {
+      $this->decompress= [$decompress, 'decompress'];
+    } else if (is_callable($decompress)) {
+      $this->decompress= $decompress;
+    } else {
+      throw new IllegalArgumentException('Expected an Algorithm or a callable, have '.typeof($decompress));
+    }
+    $this->in= $in;
+  }
+
+  /** @return string */
+  private function buffer() {
+    if (null === $this->buffer) {
+      $compressed= '';
+      while ($this->in->available()) {
+        $compressed.= $this->in->read();
+      }
+
+      $this->buffer= ($this->decompress)($compressed);
+    }
+    return $this->buffer;
+  }
+
+  /**
+   * Read a string
+   *
+   * @param   int limit default 8192
+   * @return  string
+   */
+  public function read($limit= 8192) {
+    $chunk= substr($this->buffer(), $this->position, $limit);
+    $this->position+= strlen($chunk);
+    return $chunk;
+  }
+
+  /**
+   * Returns the number of bytes that can be read from this stream 
+   * without blocking.
+   *
+   * @return int
+   */
+  public function available() {
+    return strlen($this->buffer()) - $this->position;
+  }
+
+  /**
+   * Close this buffer.
+   *
+   * @return void
+   */
+  public function close() {
+    $this->buffer= null;
+    $this->in->close();
+  }
+
+  /** Ensures input stream is closed */
+  public function __destruct() {
+    $this->close();
+  }
+}

src/main/php/io/streams/compress/BufferedOutputStream.class.php

@@ -0,0 +1,67 @@
+<?php namespace io\streams\compress;
+
+use io\streams\OutputStream;
+use lang\IllegalArgumentException;
+
+/** @test io.streams.compress.unittest.BufferedOutputStreamTest */
+class BufferedOutputStream implements OutputStream {
+  private $out, $compress;
+  private $buffer= '';
+
+  /**
+   * Creates a new compressing output stream
+   *
+   * @param  io.streams.OutputStream $out The stream to write to
+   * @param  io.streams.compress.Algorithm|function(string): string $compress
+   * @throws lang.IllegalArgumentException
+   */
+  public function __construct(OutputStream $out, $compress) {
+    if ($compress instanceof Algorithm) {
+      $this->compress= [$compress, 'compress'];
+    } else if (is_callable($compress)) {
+      $this->compress= $compress;
+    } else {
+      throw new IllegalArgumentException('Expected an Algorithm or a callable, have '.typeof($compress));
+    }
+    $this->out= $out;
+  }
+
+  /**
+   * Write a string
+   *
+   * @param  var $arg
+   * @return void
+   */
+  public function write($arg) {
+    $this->buffer.= $arg;
+  }
+
+  /**
+   * Flush this buffer
+   *
+   * @return void
+   */
+  public function flush() {
+    // NOOP
+  }
+
+  /**
+   * Closes this object. May be called more than once, which may
+   * not fail - that is, if the object is already closed, this 
+   * method should have no effect.
+   *
+   * @return void
+   */
+  public function close() {
+    if (null !== $this->buffer) {
+      $this->out->write(($this->compress)($this->buffer));
+      $this->buffer= null;
+    }
+    $this->out->close();
+  }
+
+  /** Ensures output stream is closed */
+  public function __destruct() {
+    $this->close();
+  }
+}