ruby-lzws 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e42a999e18187b07931b4c7127274339f8d6eb61490d2c3bcd504180c674d43
+  data.tar.gz: 8516d4a94686aeeb2587fcb6bd862dc85ff651ac6e71ae0449e3797a85653f78
+SHA512:
+  metadata.gz: 4c8f80f27ac4b2e12bc3628468b94bbebe5b00b688a6dc586013797b5eabb8a1a85da39fdd2ba5d48ed81d71d77df463800f6ef8c285d41bf057c1d306ed2727
+  data.tar.gz: f4ced4337b346873836d004c57ca6411f62ba604d32a69001658db3705c4098f1a938e23c2242092bd76e645792824daeba93680ea3d3da5c4529872279095cc

data/AUTHORS

@@ -0,0 +1 @@
+Andrew Aladjev

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 AUTHORS
+
+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/README.md

@@ -0,0 +1,188 @@
+# Ruby bindings for lzws library
+
+[![Travis build status](https://travis-ci.org/andrew-aladev/ruby-lzws.svg?branch=master)](https://travis-ci.org/andrew-aladev/ruby-lzws)
+[![AppVeyor build status](https://ci.appveyor.com/api/projects/status/github/andrew-aladev/ruby-lzws?branch=master&svg=true)](https://ci.appveyor.com/project/andrew-aladev/ruby-lzws/branch/master)
+
+See [lzws library](https://github.com/andrew-aladev/lzws).
+
+## Installation
+
+Please install lzws library first.
+
+```sh
+gem install ruby-lzws
+```
+
+You can build it from source.
+
+```sh
+rake gem
+gem install pkg/ruby-lzws-*.gem
+```
+
+## Usage
+
+There are simple APIs: `String` and `File`. Also you can use generic streaming API: `Stream::Writer` and `Stream::Reader`.
+
+```ruby
+require "lzws"
+
+data = LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT"
+puts LZWS::String.decompress(data)
+
+LZWS::File.compress "file.txt", "file.txt.Z"
+LZWS::File.decompress "file.txt.Z", "file.txt"
+
+LZWS::Stream::Writer.open("file.txt.Z") { |writer| writer << "TOBEORNOTTOBEORTOBEORNOT" }
+puts LZWS::Stream::Reader.open("file.txt.Z") { |reader| reader.read }
+```
+
+You can create and read `tar.Z` archives with `minitar` for example.
+LZWS is fully compatible with UNIX compress (with default options).
+
+```ruby
+require "lzws"
+require "minitar"
+
+LZWS::Stream::Writer.open "file.tar.Z" do |writer|
+  Minitar::Writer.open writer do |tar|
+    tar.add_file_simple "file", :data => "TOBEORNOTTOBEORTOBEORNOT"
+  end
+end
+
+LZWS::Stream::Reader.open "file.tar.Z" do |reader|
+  Minitar::Reader.open reader do |tar|
+    tar.each_entry do |entry|
+      puts entry.name
+      puts entry.read
+    end
+  end
+end
+```
+
+Each API supports additional options, please read lzws docs for more info.
+
+Compressor:
+
+```
+:max_code_bit_length
+:block_mode
+:buffer_length
+:without_magic_header
+:msb
+:unaligned_bit_groups
+:quiet
+```
+
+Decompressor:
+
+```
+:buffer_length
+:without_magic_header
+:msb
+:unaligned_bit_groups
+:quiet
+```
+
+```ruby
+require "lzws"
+
+data = LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT", :msb => true
+puts LZWS::String.decompress(data, :msb => true)
+```
+
+You can use `Content-Encoding: compress`.
+
+```ruby
+require "lzws"
+require "sinatra"
+
+get "/" do
+  headers["Content-Encoding"] = "compress"
+  LZWS::String.compress "TOBEORNOTTOBEORTOBEORNOT"
+end
+```
+
+## Docs
+
+`LZWS::String`:
+
+```
+::compress(source, options = {})
+::decompress(source, options = {})
+```
+
+`LZWS::File`:
+
+```
+::compress(source, destination, options = {})
+::decompress(source, destination, options = {})
+```
+
+`LZWS::Stream::Writer` and `LZWS::Stream::Reader`:
+
+```
+::open(file_path, options = {}, :external_encoding => nil, :internal_encoding => nil, &block)
+#io
+#stat
+#external_encoding
+#internal_encoding
+#pos
+#tell
+#advise
+#set_encoding(external_encoding, internal_encoding, transcode_options)
+#rewind
+#close
+#closed?
+#to_io
+```
+
+`Stream::Writer`:
+
+```
+::new(destination_io, options = {}, :external_encoding => nil)
+#write(*objects)
+#flush
+#write_nonblock(object, *options)
+#flush_nonblock(*options)
+#rewind_nonblock(*options)
+#close_nonblock(*options)
+#<<(object)
+#print(*objects)
+#printf(*args)
+#putc(object, encoding: ::Encoding::BINARY)
+#puts(*objects)
+```
+
+`Stream::Reader`:
+
+```
+::new(source_io, options = {}, :external_encoding => nil, :internal_encoding => nil)
+#lineno
+#lineno=
+#read(bytes_to_read = nil, out_buffer = nil)
+#readpartial(bytes_to_read = nil, out_buffer = nil)
+#read_nonblock(bytes_to_read, out_buffer = nil, *options)
+#eof?
+#getbyte
+#each_byte(&block)
+#readbyte
+#ungetbyte(byte)
+#getc
+#readchar
+#each_char(&block)
+#ungetc(char)
+#gets(separator = $OUTPUT_RECORD_SEPARATOR, limit = nil)
+#readline
+#readlines
+#each(&block)
+#each_line(&block)
+#ungetline(line)
+```
+
+`LZWS::Stream::Writer` and `LZWS::Stream::Reader` behaviour is the same as builtin [`Zlib::GzipWriter`](https://ruby-doc.org/stdlib-2.6.3/libdoc/zlib/rdoc/Zlib/GzipReader.html), [`Zlib::GzipReader`](https://ruby-doc.org/stdlib-2.6.3/libdoc/zlib/rdoc/Zlib/GzipWriter.html) and [`IO`](https://ruby-doc.org/core-2.6.3/IO.html).
+Please read these method descriptions in ruby doc.
+
+## License
+
+MIT license, see LICENSE and AUTHORS.

data/ext/extconf.rb

@@ -0,0 +1,77 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "mkmf"
+
+def require_header(name)
+  abort "Can't find #{name} header" unless find_header name
+end
+
+require_header "lzws/buffer.h"
+require_header "lzws/compressor/common.h"
+require_header "lzws/compressor/header.h"
+require_header "lzws/compressor/main.h"
+require_header "lzws/compressor/state.h"
+require_header "lzws/decompressor/common.h"
+require_header "lzws/decompressor/header.h"
+require_header "lzws/decompressor/main.h"
+require_header "lzws/decompressor/state.h"
+require_header "lzws/file.h"
+require_header "lzws/string.h"
+
+def require_library(name, functions)
+  functions.each do |function|
+    abort "Can't find #{name} library and #{function} function" unless find_library name, function
+  end
+end
+
+functions = %w[
+  lzws_create_buffer_for_compressor
+  lzws_create_buffer_for_decompressor
+  lzws_resize_buffer
+
+  lzws_compress_string
+  lzws_decompress_string
+
+  lzws_compress_file
+  lzws_decompress_file
+
+  lzws_compressor_write_magic_header
+  lzws_compressor_get_initial_state
+  lzws_compress
+  lzws_flush_compressor
+  lzws_compressor_free_state
+
+  lzws_decompressor_read_magic_header
+  lzws_decompressor_get_initial_state
+  lzws_decompress
+  lzws_decompressor_free_state
+]
+.freeze
+
+require_library "lzws", functions
+
+extension_name = "lzws_ext".freeze
+dir_config extension_name
+
+sources = %w[
+  stream/compressor
+  stream/decompressor
+  error
+  io
+  main
+  option
+  string
+]
+.freeze
+
+# rubocop:disable Style/GlobalVars
+$srcs = sources
+  .map { |name| "src/#{extension_name}/#{name}.c" }
+  .freeze
+
+$CFLAGS << " -Wno-declaration-after-statement"
+$VPATH << "$(srcdir)/#{extension_name}:$(srcdir)/#{extension_name}/stream"
+# rubocop:enable Style/GlobalVars
+
+create_makefile extension_name

data/ext/lzws_ext/common.h

@@ -0,0 +1,9 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_COMMON_H)
+#define LZWS_EXT_COMMON_H
+
+#define LZWS_EXT_MODULE_NAME "LZWS"
+
+#endif // LZWS_EXT_COMMON_H

data/ext/lzws_ext/error.c

@@ -0,0 +1,14 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "ruby.h"
+
+#include "lzws_ext/common.h"
+#include "lzws_ext/error.h"
+
+void lzws_ext_raise_error(const char* name, const char* description)
+{
+  VALUE module = rb_define_module(LZWS_EXT_MODULE_NAME);
+  VALUE error  = rb_const_get(module, rb_intern(name));
+  rb_raise(error, "%s", description);
+}

data/ext/lzws_ext/error.h

@@ -0,0 +1,11 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_ERROR_H)
+#define LZWS_EXT_ERROR_H
+
+#include "ruby.h"
+
+NORETURN(void lzws_ext_raise_error(const char* name, const char* description));
+
+#endif // LZWS_EXT_ERROR_H

data/ext/lzws_ext/io.c

@@ -0,0 +1,92 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include <lzws/file.h>
+
+#include "ruby.h"
+#include "ruby/io.h"
+
+#include "lzws_ext/error.h"
+#include "lzws_ext/io.h"
+#include "lzws_ext/macro.h"
+#include "lzws_ext/option.h"
+
+#define GET_FILE(target)                                          \
+  Check_Type(target, T_FILE);                                     \
+                                                                  \
+  rb_io_t *target##_io;                                           \
+  GetOpenFile(target, target##_io);                               \
+                                                                  \
+  FILE *target##_file = rb_io_stdio_file(target##_io);            \
+  if (target##_file == NULL) {                                    \
+    lzws_ext_raise_error("AccessIOError", "failed to access IO"); \
+  }
+
+VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
+{
+  GET_FILE(source);
+  GET_FILE(destination);
+  LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
+
+  lzws_result_t result = lzws_compress_file(
+    source_file, buffer_length,
+    destination_file, buffer_length,
+    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_FILE_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result == LZWS_FILE_VALIDATE_FAILED) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result == LZWS_FILE_READ_FAILED) {
+    lzws_ext_raise_error("ReadIOError", "failed to read IO");
+  }
+  else if (result == LZWS_FILE_WRITE_FAILED) {
+    lzws_ext_raise_error("WriteIOError", "failed to write IO");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  // Ruby itself won't flush stdio file before closing fd, flush is required.
+  fflush(destination_file);
+
+  return Qnil;
+}
+
+VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE destination, VALUE options)
+{
+  GET_FILE(source);
+  GET_FILE(destination);
+  LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+
+  lzws_result_t result = lzws_decompress_file(
+    source_file, buffer_length,
+    destination_file, buffer_length,
+    without_magic_header, msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_FILE_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result == LZWS_FILE_VALIDATE_FAILED) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result == LZWS_FILE_DECOMPRESSOR_CORRUPTED_SOURCE) {
+    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+  }
+  else if (result == LZWS_FILE_READ_FAILED) {
+    lzws_ext_raise_error("ReadIOError", "failed to read IO");
+  }
+  else if (result == LZWS_FILE_WRITE_FAILED) {
+    lzws_ext_raise_error("WriteIOError", "failed to write IO");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  // Ruby itself won't flush stdio file before closing fd, flush is required.
+  fflush(destination_file);
+
+  return Qnil;
+}

data/ext/lzws_ext/io.h

@@ -0,0 +1,12 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_IO_H)
+#define LZWS_EXT_IO_H
+
+#include "ruby.h"
+
+VALUE lzws_ext_compress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
+VALUE lzws_ext_decompress_io(VALUE self, VALUE source, VALUE destination, VALUE options);
+
+#endif // LZWS_EXT_IO_H

data/ext/lzws_ext/macro.h

@@ -0,0 +1,15 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_MACRO_H)
+#define LZWS_EXT_MACRO_H
+
+#if defined(__GNUC__)
+#define LZWS_EXT_UNUSED(x) x __attribute__((__unused__))
+#else
+#define LZWS_EXT_UNUSED(x) x
+#endif
+
+#define LZWS_EXT_UNUSED_VARIABLE(x) (void)(x)
+
+#endif // LZWS_EXT_MACRO_H

data/ext/lzws_ext/main.c

@@ -0,0 +1,42 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "ruby.h"
+
+#include "lzws_ext/common.h"
+#include "lzws_ext/io.h"
+#include "lzws_ext/stream/compressor.h"
+#include "lzws_ext/stream/decompressor.h"
+#include "lzws_ext/string.h"
+
+void Init_lzws_ext()
+{
+  VALUE root = rb_define_module(LZWS_EXT_MODULE_NAME);
+
+  // It is better to use these functions internally and prepare pretty wrappers for public usage.
+  rb_define_module_function(root, "_native_compress_io", RUBY_METHOD_FUNC(lzws_ext_compress_io), 3);
+  rb_define_module_function(root, "_native_decompress_io", RUBY_METHOD_FUNC(lzws_ext_decompress_io), 3);
+  rb_define_module_function(root, "_native_compress_string", RUBY_METHOD_FUNC(lzws_ext_compress_string), 2);
+  rb_define_module_function(root, "_native_decompress_string", RUBY_METHOD_FUNC(lzws_ext_decompress_string), 2);
+
+  // -----
+
+  VALUE stream = rb_define_module_under(root, "Stream");
+
+  VALUE compressor = rb_define_class_under(stream, "NativeCompressor", rb_cObject);
+  rb_define_alloc_func(compressor, lzws_ext_allocate_compressor);
+  rb_define_method(compressor, "initialize", lzws_ext_initialize_compressor, 1);
+  rb_define_method(compressor, "write_magic_header", lzws_ext_compressor_write_magic_header, 0);
+  rb_define_method(compressor, "write", lzws_ext_compress, 1);
+  rb_define_method(compressor, "flush", lzws_ext_flush_compressor, 0);
+  rb_define_method(compressor, "read_result", lzws_ext_compressor_read_result, 0);
+  rb_define_method(compressor, "close", lzws_ext_compressor_close, 0);
+
+  VALUE decompressor = rb_define_class_under(stream, "NativeDecompressor", rb_cObject);
+  rb_define_alloc_func(decompressor, lzws_ext_allocate_decompressor);
+  rb_define_method(decompressor, "initialize", lzws_ext_initialize_decompressor, 1);
+  rb_define_method(decompressor, "read_magic_header", lzws_ext_decompressor_read_magic_header, 1);
+  rb_define_method(decompressor, "read", lzws_ext_decompress, 1);
+  rb_define_method(decompressor, "read_result", lzws_ext_decompressor_read_result, 0);
+  rb_define_method(decompressor, "close", lzws_ext_decompressor_close, 0);
+}

data/ext/lzws_ext/option.c

@@ -0,0 +1,22 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include "ruby.h"
+
+#include "lzws_ext/option.h"
+
+VALUE lzws_ext_get_option(VALUE options, const char* name)
+{
+  VALUE name_symbol = ID2SYM(rb_intern(name));
+  return rb_funcall(options, rb_intern("[]"), 1, name_symbol);
+}
+
+void lzws_ext_check_bool_type(VALUE option, const char* name)
+{
+  int type = TYPE(option);
+
+  if (type != T_TRUE && type != T_FALSE) {
+    VALUE message = rb_sprintf("wrong value for \"%s\" (expected true or false)", name);
+    rb_exc_raise(rb_exc_new_str(rb_eFatal, message));
+  }
+}

data/ext/lzws_ext/option.h

@@ -0,0 +1,60 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_OPTIONS_H)
+#define LZWS_EXT_OPTIONS_H
+
+#include "ruby.h"
+
+VALUE lzws_ext_get_option(VALUE options, const char* name);
+void  lzws_ext_check_bool_type(VALUE option, const char* name);
+
+#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                           \
+  Check_Type(options, T_HASH);                                                             \
+                                                                                           \
+  VALUE buffer_length_value        = lzws_ext_get_option(options, "buffer_length");        \
+  VALUE without_magic_header_value = lzws_ext_get_option(options, "without_magic_header"); \
+  VALUE max_code_bit_length_value  = lzws_ext_get_option(options, "max_code_bit_length");  \
+  VALUE block_mode_value           = lzws_ext_get_option(options, "block_mode");           \
+  VALUE msb_value                  = lzws_ext_get_option(options, "msb");                  \
+  VALUE unaligned_bit_groups_value = lzws_ext_get_option(options, "unaligned_bit_groups"); \
+  VALUE quiet_value                = lzws_ext_get_option(options, "quiet");                \
+                                                                                           \
+  Check_Type(buffer_length_value, T_FIXNUM);                                               \
+  lzws_ext_check_bool_type(without_magic_header_value, "without_magic_header");            \
+  Check_Type(max_code_bit_length_value, T_FIXNUM);                                         \
+  lzws_ext_check_bool_type(block_mode_value, "block_mode");                                \
+  lzws_ext_check_bool_type(msb_value, "msb");                                              \
+  lzws_ext_check_bool_type(unaligned_bit_groups_value, "unaligned_bit_groups");            \
+  lzws_ext_check_bool_type(quiet_value, "quiet");                                          \
+                                                                                           \
+  size_t       buffer_length        = rb_num2uint(buffer_length_value);                    \
+  bool         without_magic_header = TYPE(without_magic_header_value) == T_TRUE;          \
+  uint_fast8_t max_code_bit_length  = rb_num2uint(max_code_bit_length_value);              \
+  bool         block_mode           = TYPE(block_mode_value) == T_TRUE;                    \
+  bool         msb                  = TYPE(msb_value) == T_TRUE;                           \
+  bool         unaligned_bit_groups = TYPE(unaligned_bit_groups_value) == T_TRUE;          \
+  bool         quiet                = TYPE(quiet_value) == T_TRUE;
+
+#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                         \
+  Check_Type(options, T_HASH);                                                             \
+                                                                                           \
+  VALUE buffer_length_value        = lzws_ext_get_option(options, "buffer_length");        \
+  VALUE without_magic_header_value = lzws_ext_get_option(options, "without_magic_header"); \
+  VALUE msb_value                  = lzws_ext_get_option(options, "msb");                  \
+  VALUE unaligned_bit_groups_value = lzws_ext_get_option(options, "unaligned_bit_groups"); \
+  VALUE quiet_value                = lzws_ext_get_option(options, "quiet");                \
+                                                                                           \
+  Check_Type(buffer_length_value, T_FIXNUM);                                               \
+  lzws_ext_check_bool_type(without_magic_header_value, "without_magic_header");            \
+  lzws_ext_check_bool_type(msb_value, "msb");                                              \
+  lzws_ext_check_bool_type(unaligned_bit_groups_value, "unaligned_bit_groups");            \
+  lzws_ext_check_bool_type(quiet_value, "quiet");                                          \
+                                                                                           \
+  size_t buffer_length        = rb_num2uint(buffer_length_value);                          \
+  bool   without_magic_header = TYPE(without_magic_header_value) == T_TRUE;                \
+  bool   msb                  = TYPE(msb_value) == T_TRUE;                                 \
+  bool   unaligned_bit_groups = TYPE(unaligned_bit_groups_value) == T_TRUE;                \
+  bool   quiet                = TYPE(quiet_value) == T_TRUE;
+
+#endif // LZWS_EXT_OPTIONS_H