ruby-lzws 1.1.7 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45c0c7f35addf83d5ba03c70c375c22ffa77033b0e324cda2a30548bfb91a579
-  data.tar.gz: 99d7cb5a5465ce8f6d82e1d727e63eac94be05db3546f3fd6c445769dd1c7cb7
+  metadata.gz: 62d885a3a75f291ea4b808da4ef4e47a68574e74dae8fe39aad61d228a62643c
+  data.tar.gz: 90e5fc29ea554392dcf93bb391a38361707c14306099b6654765e399d111ea9d
 SHA512:
-  metadata.gz: 2a8ccf1146d380093e028f40453f2747e6f67e64e308eac8ee4bb5a0bd8abd6d572d42b4a537813c3edcdb46170292740d52b61e8384b47cac2a92895ec1f0d3
-  data.tar.gz: 2b6deed0dfb579fc16637fab9bb82fe3889e100644b80219aa5dc4a59ab00681f17b59a64b5d1930bcf92551f03f04cff9dc714231ec38dcc3856eaf5aa43b5a
+  metadata.gz: 66c07c08d7094be0e9f2d802c01796529e0c14bcde067752aa629d7e3337218e0d6a08e7cfe08725659097fb0e3be90e7565a872a3c79dc96813afa6b235e4ab
+  data.tar.gz: a1d74a3408881c23f816818931685ec084bd2a0e9c114be212f8a059e37af8da882e9235f3780524e5e67557b3c9945f33b3ecab8535768e4737e972fc724d87

data/README.md

@@ -8,7 +8,7 @@ See [lzws library](https://github.com/andrew-aladev/lzws).
 
 ## Installation
 
-Please install lzws library first, use latest 1.3.0+ version.
+Please install lzws library first, use latest 1.4.0+ version.
 
 ```sh
 gem install ruby-lzws

data/ext/extconf.rb

@@ -13,10 +13,10 @@ end
 
 require_header "lzws/buffer.h"
 require_header "lzws/common.h", %w[lzws_result_t]
-require_header "lzws/compressor/common.h"
+require_header "lzws/compressor/common.h", %w[lzws_compressor_options_t]
 require_header "lzws/compressor/main.h"
 require_header "lzws/compressor/state.h", %w[lzws_compressor_state_t]
-require_header "lzws/decompressor/common.h"
+require_header "lzws/decompressor/common.h", %w[lzws_decompressor_options_t]
 require_header "lzws/decompressor/main.h"
 require_header "lzws/decompressor/state.h", %w[lzws_decompressor_state_t]
 require_header "lzws/file.h"

data/ext/lzws_ext/buffer.c

@@ -16,6 +16,7 @@ VALUE lzws_ext_resize_string_buffer(VALUE args)
 {
   VALUE buffer = rb_ary_entry(args, 0);
   VALUE length = rb_ary_entry(args, 1);
+
   return rb_str_resize(buffer, NUM2SIZET(length));
 }
 
@@ -23,8 +24,21 @@ void lzws_ext_buffer_exports(VALUE root_module)
 {
   VALUE module = rb_define_module_under(root_module, "Buffer");
 
-  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
-  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
-  rb_define_const(module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
-  rb_define_const(module, "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR", SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+  rb_define_const(
+    module, "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR", SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_COMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR",
+    SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_COMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR",
+    SIZET2NUM(LZWS_DEFAULT_SOURCE_BUFFER_LENGTH_FOR_DECOMPRESSOR));
+
+  rb_define_const(
+    module,
+    "DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR",
+    SIZET2NUM(LZWS_DEFAULT_DESTINATION_BUFFER_LENGTH_FOR_DECOMPRESSOR));
 }

data/ext/lzws_ext/error.h

@@ -9,7 +9,8 @@
 
 // Results for errors listed in "lib/lzws/error" used in c extension.
 
-enum {
+enum
+{
   LZWS_EXT_ERROR_ALLOCATE_FAILED = 1,
   LZWS_EXT_ERROR_VALIDATE_FAILED,
 

data/ext/lzws_ext/io.c

@@ -1,16 +1,15 @@
 // Ruby bindings for lzws library.
 // Copyright (c) 2019 AUTHORS, MIT License.
 
-#include "ruby/io.h"
+#include "lzws_ext/io.h"
 
-#include <lzws/common.h>
 #include <lzws/file.h>
 
 #include "lzws_ext/error.h"
-#include "lzws_ext/io.h"
 #include "lzws_ext/macro.h"
 #include "lzws_ext/option.h"
 #include "ruby.h"
+#include "ruby/io.h"
 
 #define GET_FILE(target)                               \
   Check_Type(target, T_FILE);                          \
@@ -58,9 +57,7 @@ VALUE lzws_ext_compress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE dest
   LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_result_t result = lzws_compress_file(
-    source_file, source_buffer_length,
-    destination_file, destination_buffer_length,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+    source_file, source_buffer_length, destination_file, destination_buffer_length, &compressor_options);
 
   if (result != 0) {
     lzws_ext_raise_error(get_file_error(result));
@@ -82,9 +79,7 @@ VALUE lzws_ext_decompress_io(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE de
   LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, destination_buffer_length);
 
   lzws_result_t result = lzws_decompress_file(
-    source_file, source_buffer_length,
-    destination_file, destination_buffer_length,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
+    source_file, source_buffer_length, destination_file, destination_buffer_length, &decompressor_options);
 
   if (result != 0) {
     lzws_ext_raise_error(get_file_error(result));

data/ext/lzws_ext/main.c

@@ -3,6 +3,7 @@
 
 #include "lzws_ext/buffer.h"
 #include "lzws_ext/io.h"
+#include "lzws_ext/option.h"
 #include "lzws_ext/stream/compressor.h"
 #include "lzws_ext/stream/decompressor.h"
 #include "lzws_ext/string.h"
@@ -14,6 +15,7 @@ void Init_lzws_ext()
 
   lzws_ext_buffer_exports(root_module);
   lzws_ext_io_exports(root_module);
+  lzws_ext_option_exports(root_module);
   lzws_ext_compressor_exports(root_module);
   lzws_ext_decompressor_exports(root_module);
   lzws_ext_string_exports(root_module);

data/ext/lzws_ext/option.c

@@ -6,30 +6,38 @@
 #include "lzws_ext/error.h"
 #include "ruby.h"
 
+// -- values --
+
 static inline VALUE get_raw_option_value(VALUE options, const char* name)
 {
   return rb_funcall(options, rb_intern("[]"), 1, ID2SYM(rb_intern(name)));
 }
 
-bool lzws_ext_get_bool_option_value(VALUE options, const char* name)
+void lzws_ext_get_bool_option(VALUE options, bool* option, const char* name)
 {
   VALUE raw_value = get_raw_option_value(options, name);
+  if (raw_value == Qnil) {
+    return;
+  }
 
   int raw_type = TYPE(raw_value);
   if (raw_type != T_TRUE && raw_type != T_FALSE) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_VALIDATE_FAILED);
   }
 
-  return raw_type == T_TRUE;
+  *option = raw_type == T_TRUE;
 }
 
-unsigned int lzws_ext_get_uint_option_value(VALUE options, const char* name)
+void lzws_ext_get_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name)
 {
   VALUE raw_value = get_raw_option_value(options, name);
+  if (raw_value == Qnil) {
+    return;
+  }
 
   Check_Type(raw_value, T_FIXNUM);
 
-  return NUM2UINT(raw_value);
+  *option = NUM2UINT(raw_value);
 }
 
 size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
@@ -40,3 +48,13 @@ size_t lzws_ext_get_size_option_value(VALUE options, const char* name)
 
   return NUM2SIZET(raw_value);
 }
+
+// -- exports --
+
+void lzws_ext_option_exports(VALUE root_module)
+{
+  VALUE module = rb_define_module_under(root_module, "Option");
+
+  rb_define_const(module, "LOWEST_MAX_CODE_BIT_LENGTH", UINT2NUM(LZWS_LOWEST_MAX_CODE_BIT_LENGTH));
+  rb_define_const(module, "BIGGEST_MAX_CODE_BIT_LENGTH", UINT2NUM(LZWS_BIGGEST_MAX_CODE_BIT_LENGTH));
+}

data/ext/lzws_ext/option.h

@@ -4,40 +4,44 @@
 #if !defined(LZWS_EXT_OPTIONS_H)
 #define LZWS_EXT_OPTIONS_H
 
+#include <lzws/compressor/common.h>
+#include <lzws/decompressor/common.h>
 #include <stdbool.h>
 #include <stdlib.h>
 
-#include "lzws_ext/common.h"
 #include "ruby.h"
 
-bool         lzws_ext_get_bool_option_value(VALUE options, const char* name);
-unsigned int lzws_ext_get_uint_option_value(VALUE options, const char* name);
-size_t       lzws_ext_get_size_option_value(VALUE options, const char* name);
+void lzws_ext_get_bool_option(VALUE options, bool* option, const char* name);
+void lzws_ext_get_max_code_bit_length_option(VALUE options, lzws_byte_fast_t* option, const char* name);
 
-#define LZWS_EXT_GET_BOOL_OPTION(options, name) \
-  bool name = lzws_ext_get_bool_option_value(options, #name);
+#define LZWS_EXT_GET_BOOL_OPTION(options, target_options, name) \
+  lzws_ext_get_bool_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_UINT_OPTION(options, type, name) \
-  type name = lzws_ext_get_uint_option_value(options, #name);
+#define LZWS_EXT_GET_MAX_CODE_BIT_LENGTH_OPTION(options, target_options, name) \
+  lzws_ext_get_max_code_bit_length_option(options, &target_options.name, #name);
 
-#define LZWS_EXT_GET_SIZE_OPTION(options, name) \
-  size_t name = lzws_ext_get_size_option_value(options, #name);
+#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                             \
+  lzws_compressor_options_t compressor_options = LZWS_COMPRESSOR_DEFAULT_OPTIONS;            \
+                                                                                             \
+  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, without_magic_header);               \
+  LZWS_EXT_GET_MAX_CODE_BIT_LENGTH_OPTION(options, compressor_options, max_code_bit_length); \
+  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, block_mode);                         \
+  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, msb);                                \
+  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, unaligned_bit_groups);               \
+  LZWS_EXT_GET_BOOL_OPTION(options, compressor_options, quiet);
 
-#define LZWS_EXT_GET_COMPRESSOR_OPTIONS(options)                                \
-  LZWS_EXT_GET_BOOL_OPTION(options, without_magic_header);                      \
-  LZWS_EXT_GET_UINT_OPTION(options, lzws_ext_byte_fast_t, max_code_bit_length); \
-  LZWS_EXT_GET_BOOL_OPTION(options, block_mode);                                \
-  LZWS_EXT_GET_BOOL_OPTION(options, msb);                                       \
-  LZWS_EXT_GET_BOOL_OPTION(options, unaligned_bit_groups);                      \
-  LZWS_EXT_GET_BOOL_OPTION(options, quiet);
+#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)                                      \
+  lzws_decompressor_options_t decompressor_options = LZWS_DECOMPRESSOR_DEFAULT_OPTIONS; \
+                                                                                        \
+  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, without_magic_header);        \
+  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, msb);                         \
+  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, unaligned_bit_groups);        \
+  LZWS_EXT_GET_BOOL_OPTION(options, decompressor_options, quiet);
 
-#define LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options)         \
-  LZWS_EXT_GET_BOOL_OPTION(options, without_magic_header); \
-  LZWS_EXT_GET_BOOL_OPTION(options, msb);                  \
-  LZWS_EXT_GET_BOOL_OPTION(options, unaligned_bit_groups); \
-  LZWS_EXT_GET_BOOL_OPTION(options, quiet);
+size_t lzws_ext_get_size_option_value(VALUE options, const char* name);
 
-#define LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) \
-  LZWS_EXT_GET_SIZE_OPTION(options, name);
+#define LZWS_EXT_GET_BUFFER_LENGTH_OPTION(options, name) size_t name = lzws_ext_get_size_option_value(options, #name);
+
+void lzws_ext_option_exports(VALUE root_module);
 
 #endif // LZWS_EXT_OPTIONS_H

data/ext/lzws_ext/stream/compressor.c

@@ -4,8 +4,6 @@
 #include "lzws_ext/stream/compressor.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/compressor/common.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
 
@@ -31,8 +29,7 @@ static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
 VALUE lzws_ext_allocate_compressor(VALUE klass)
 {
   lzws_ext_compressor_t* compressor_ptr;
-
-  VALUE self = Data_Make_Struct(klass, lzws_ext_compressor_t, NULL, free_compressor, compressor_ptr);
+  VALUE                  self = Data_Make_Struct(klass, lzws_ext_compressor_t, NULL, free_compressor, compressor_ptr);
 
   compressor_ptr->state_ptr                           = NULL;
   compressor_ptr->destination_buffer                  = NULL;
@@ -56,10 +53,7 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 
   lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_compressor_get_initial_state(&state_ptr, &compressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_COMPRESSOR_ALLOCATE_FAILED:
@@ -73,7 +67,9 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
 
   lzws_ext_byte_t* destination_buffer;
 
-  result = lzws_create_destination_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
+  result = lzws_create_destination_buffer_for_compressor(
+    &destination_buffer, &destination_buffer_length, compressor_options.quiet);
+
   if (result != 0) {
     lzws_compressor_free_state(state_ptr);
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
@@ -98,7 +94,7 @@ VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
                                                                         \
   const char*      source                  = RSTRING_PTR(source_value); \
   size_t           source_length           = RSTRING_LEN(source_value); \
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;  \
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
   size_t           remaining_source_length = source_length;
 
 VALUE lzws_ext_compress(VALUE self, VALUE source_value)
@@ -109,12 +105,12 @@ VALUE lzws_ext_compress(VALUE self, VALUE source_value)
 
   lzws_result_t result = lzws_compress(
     compressor_ptr->state_ptr,
-    &remaining_source, &remaining_source_length,
-    &compressor_ptr->remaining_destination_buffer, &compressor_ptr->remaining_destination_buffer_length);
+    &remaining_source,
+    &remaining_source_length,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
@@ -131,17 +127,14 @@ VALUE lzws_ext_compressor_finish(VALUE self)
 
   lzws_result_t result = lzws_compressor_finish(
     compressor_ptr->state_ptr,
-    &compressor_ptr->remaining_destination_buffer, &compressor_ptr->remaining_destination_buffer_length);
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
     lzws_ext_raise_error(LZWS_EXT_ERROR_UNEXPECTED);
   }
 
-  VALUE needs_more_destination = result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
-
-  return needs_more_destination;
+  return result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION ? Qtrue : Qfalse;
 }
 
 VALUE lzws_ext_compressor_read_result(VALUE self)
@@ -153,10 +146,9 @@ VALUE lzws_ext_compressor_read_result(VALUE self)
   size_t           destination_buffer_length           = compressor_ptr->destination_buffer_length;
   size_t           remaining_destination_buffer_length = compressor_ptr->remaining_destination_buffer_length;
 
-  const char* result        = (const char*)destination_buffer;
+  const char* result        = (const char*) destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
-
-  VALUE result_value = rb_str_new(result, result_length);
+  VALUE       result_value  = rb_str_new(result, result_length);
 
   compressor_ptr->remaining_destination_buffer        = destination_buffer;
   compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;

data/ext/lzws_ext/stream/compressor.h

@@ -10,7 +10,8 @@
 #include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_compressor_state_t* state_ptr;
   lzws_ext_byte_t*         destination_buffer;
   size_t                   destination_buffer_length;

data/ext/lzws_ext/stream/decompressor.c

@@ -4,8 +4,6 @@
 #include "lzws_ext/stream/decompressor.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/decompressor/common.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
 
@@ -31,7 +29,6 @@ static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
 VALUE lzws_ext_allocate_decompressor(VALUE klass)
 {
   lzws_ext_decompressor_t* decompressor_ptr;
-
   VALUE self = Data_Make_Struct(klass, lzws_ext_decompressor_t, NULL, free_decompressor, decompressor_ptr);
 
   decompressor_ptr->state_ptr                           = NULL;
@@ -56,10 +53,7 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
 
   lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_decompressor_get_initial_state(&state_ptr, &decompressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
@@ -71,7 +65,9 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
 
   lzws_ext_byte_t* destination_buffer;
 
-  result = lzws_create_destination_buffer_for_decompressor(&destination_buffer, &destination_buffer_length, quiet);
+  result = lzws_create_destination_buffer_for_decompressor(
+    &destination_buffer, &destination_buffer_length, decompressor_options.quiet);
+
   if (result != 0) {
     lzws_decompressor_free_state(state_ptr);
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
@@ -96,7 +92,7 @@ VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
                                                                         \
   const char*      source                  = RSTRING_PTR(source_value); \
   size_t           source_length           = RSTRING_LEN(source_value); \
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;  \
+  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*) source; \
   size_t           remaining_source_length = source_length;
 
 VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
@@ -107,12 +103,12 @@ VALUE lzws_ext_decompress(VALUE self, VALUE source_value)
 
   lzws_result_t result = lzws_decompress(
     decompressor_ptr->state_ptr,
-    &remaining_source, &remaining_source_length,
-    &decompressor_ptr->remaining_destination_buffer, &decompressor_ptr->remaining_destination_buffer_length);
+    &remaining_source,
+    &remaining_source_length,
+    &decompressor_ptr->remaining_destination_buffer,
+    &decompressor_ptr->remaining_destination_buffer_length);
 
-  if (
-    result != 0 &&
-    result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+  if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
     switch (result) {
       case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
       case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
@@ -139,10 +135,9 @@ VALUE lzws_ext_decompressor_read_result(VALUE self)
   size_t           destination_buffer_length           = decompressor_ptr->destination_buffer_length;
   size_t           remaining_destination_buffer_length = decompressor_ptr->remaining_destination_buffer_length;
 
-  const char* result        = (const char*)destination_buffer;
+  const char* result        = (const char*) destination_buffer;
   size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
-
-  VALUE result_value = rb_str_new(result, result_length);
+  VALUE       result_value  = rb_str_new(result, result_length);
 
   decompressor_ptr->remaining_destination_buffer        = destination_buffer;
   decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;

data/ext/lzws_ext/stream/decompressor.h

@@ -10,7 +10,8 @@
 #include "lzws_ext/common.h"
 #include "ruby.h"
 
-typedef struct {
+typedef struct
+{
   lzws_decompressor_state_t* state_ptr;
   lzws_ext_byte_t*           destination_buffer;
   size_t                     destination_buffer_length;

data/ext/lzws_ext/string.c

@@ -4,11 +4,8 @@
 #include "lzws_ext/string.h"
 
 #include <lzws/buffer.h>
-#include <lzws/common.h>
-#include <lzws/compressor/common.h>
 #include <lzws/compressor/main.h>
 #include <lzws/compressor/state.h>
-#include <lzws/decompressor/common.h>
 #include <lzws/decompressor/main.h>
 #include <lzws/decompressor/state.h>
 #include <stdlib.h>
@@ -22,8 +19,10 @@
 // -- buffer --
 
 static inline lzws_ext_result_t increase_destination_buffer(
-  VALUE destination_value, size_t destination_length,
-  size_t* remaining_destination_buffer_length_ptr, size_t destination_buffer_length)
+  VALUE   destination_value,
+  size_t  destination_length,
+  size_t* remaining_destination_buffer_length_ptr,
+  size_t  destination_buffer_length)
 {
   if (*remaining_destination_buffer_length_ptr == destination_buffer_length) {
     // We want to write more data at once, than buffer has.
@@ -52,49 +51,46 @@ static inline lzws_ext_result_t increase_destination_buffer(
 
 // -- compress --
 
-#define BUFFERED_COMPRESS(function, ...)                                                                                               \
-  while (true) {                                                                                                                       \
-    lzws_ext_byte_t* remaining_destination_buffer             = (lzws_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length; \
-    size_t           prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                                   \
-                                                                                                                                       \
-    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);                               \
-                                                                                                                                       \
-    if (                                                                                                                               \
-      result != 0 &&                                                                                                                   \
-      result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                                              \
-      return LZWS_EXT_ERROR_UNEXPECTED;                                                                                                \
-    }                                                                                                                                  \
-                                                                                                                                       \
-    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;                              \
-                                                                                                                                       \
-    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                                            \
-      ext_result = increase_destination_buffer(                                                                                        \
-        destination_value, destination_length,                                                                                         \
-        &remaining_destination_buffer_length, destination_buffer_length);                                                              \
-                                                                                                                                       \
-      if (ext_result != 0) {                                                                                                           \
-        return ext_result;                                                                                                             \
-      }                                                                                                                                \
-                                                                                                                                       \
-      continue;                                                                                                                        \
-    }                                                                                                                                  \
-                                                                                                                                       \
-    break;                                                                                                                             \
+#define BUFFERED_COMPRESS(function, ...)                                                                         \
+  while (true) {                                                                                                 \
+    lzws_ext_byte_t* remaining_destination_buffer =                                                              \
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;                                    \
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;                       \
+                                                                                                                 \
+    result = function(__VA_ARGS__, &remaining_destination_buffer, &remaining_destination_buffer_length);         \
+    if (result != 0 && result != LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                       \
+      return LZWS_EXT_ERROR_UNEXPECTED;                                                                          \
+    }                                                                                                            \
+                                                                                                                 \
+    destination_length += prev_remaining_destination_buffer_length - remaining_destination_buffer_length;        \
+                                                                                                                 \
+    if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {                                                      \
+      ext_result = increase_destination_buffer(                                                                  \
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length); \
+                                                                                                                 \
+      if (ext_result != 0) {                                                                                     \
+        return ext_result;                                                                                       \
+      }                                                                                                          \
+                                                                                                                 \
+      continue;                                                                                                  \
+    }                                                                                                            \
+                                                                                                                 \
+    break;                                                                                                       \
   }
 
 static inline lzws_ext_result_t compress(
   lzws_compressor_state_t* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*              source,
+  size_t                   source_length,
+  VALUE                    destination_value,
+  size_t                   destination_buffer_length)
 {
   lzws_result_t     result;
   lzws_ext_result_t ext_result;
-
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;
-  size_t           remaining_source_length = source_length;
-
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
+  size_t            remaining_source_length             = source_length;
+  size_t            destination_length                  = 0;
+  size_t            remaining_destination_buffer_length = destination_buffer_length;
 
   BUFFERED_COMPRESS(lzws_compress, state_ptr, &remaining_source, &remaining_source_length);
   BUFFERED_COMPRESS(lzws_compressor_finish, state_ptr);
@@ -118,10 +114,7 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
   lzws_compressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_compressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_compressor_get_initial_state(&state_ptr, &compressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_COMPRESSOR_ALLOCATE_FAILED:
@@ -145,10 +138,8 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t ext_result = compress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  lzws_ext_result_t ext_result =
+    compress(state_ptr, source, source_length, destination_value, destination_buffer_length);
 
   lzws_compressor_free_state(state_ptr);
 
@@ -163,30 +154,31 @@ VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value,
 
 static inline lzws_ext_result_t decompress(
   lzws_decompressor_state_t* state_ptr,
-  const char* source, size_t source_length,
-  VALUE destination_value, size_t destination_buffer_length)
+  const char*                source,
+  size_t                     source_length,
+  VALUE                      destination_value,
+  size_t                     destination_buffer_length)
 {
   lzws_result_t     result;
   lzws_ext_result_t ext_result;
-
-  lzws_ext_byte_t* remaining_source        = (lzws_ext_byte_t*)source;
-  size_t           remaining_source_length = source_length;
-
-  size_t destination_length                  = 0;
-  size_t remaining_destination_buffer_length = destination_buffer_length;
+  lzws_ext_byte_t*  remaining_source                    = (lzws_ext_byte_t*) source;
+  size_t            remaining_source_length             = source_length;
+  size_t            destination_length                  = 0;
+  size_t            remaining_destination_buffer_length = destination_buffer_length;
 
   while (true) {
-    lzws_ext_byte_t* remaining_destination_buffer             = (lzws_ext_byte_t*)RSTRING_PTR(destination_value) + destination_length;
-    size_t           prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
+    lzws_ext_byte_t* remaining_destination_buffer =
+      (lzws_ext_byte_t*) RSTRING_PTR(destination_value) + destination_length;
+    size_t prev_remaining_destination_buffer_length = remaining_destination_buffer_length;
 
     result = lzws_decompress(
       state_ptr,
-      &remaining_source, &remaining_source_length,
-      &remaining_destination_buffer, &remaining_destination_buffer_length);
+      &remaining_source,
+      &remaining_source_length,
+      &remaining_destination_buffer,
+      &remaining_destination_buffer_length);
 
-    if (
-      result != 0 &&
-      result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    if (result != 0 && result != LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       switch (result) {
         case LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER:
         case LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH:
@@ -202,8 +194,7 @@ static inline lzws_ext_result_t decompress(
 
     if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
       ext_result = increase_destination_buffer(
-        destination_value, destination_length,
-        &remaining_destination_buffer_length, destination_buffer_length);
+        destination_value, destination_length, &remaining_destination_buffer_length, destination_buffer_length);
 
       if (ext_result != 0) {
         return ext_result;
@@ -234,10 +225,7 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
 
   lzws_decompressor_state_t* state_ptr;
 
-  lzws_result_t result = lzws_decompressor_get_initial_state(
-    &state_ptr,
-    without_magic_header, msb, unaligned_bit_groups, quiet);
-
+  lzws_result_t result = lzws_decompressor_get_initial_state(&state_ptr, &decompressor_options);
   if (result != 0) {
     switch (result) {
       case LZWS_DECOMPRESSOR_ALLOCATE_FAILED:
@@ -259,10 +247,8 @@ VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source_value
     lzws_ext_raise_error(LZWS_EXT_ERROR_ALLOCATE_FAILED);
   }
 
-  lzws_ext_result_t ext_result = decompress(
-    state_ptr,
-    source, source_length,
-    destination_value, destination_buffer_length);
+  lzws_ext_result_t ext_result =
+    decompress(state_ptr, source, source_length, destination_value, destination_buffer_length);
 
   lzws_decompressor_free_state(state_ptr);
 

data/lib/lzws/option.rb

@@ -8,45 +8,37 @@ require_relative "validation"
 
 module LZWS
   module Option
-    # Default options will be compatible with UNIX compress.
-
-    DEFAULT_BUFFER_LENGTH       = 0
-    LOWEST_MAX_CODE_BIT_LENGTH  = 9
-    BIGGEST_MAX_CODE_BIT_LENGTH = 16
-
-    DECOMPRESSOR_DEFAULTS = {
-      :without_magic_header => false,
-      :msb                  => false,
-      :unaligned_bit_groups => false,
-      :quiet                => false
-    }
-    .freeze
-
-    COMPRESSOR_DEFAULTS = DECOMPRESSOR_DEFAULTS.merge(
-      :max_code_bit_length => BIGGEST_MAX_CODE_BIT_LENGTH,
-      :block_mode          => true
-    )
-    .freeze
+    DEFAULT_BUFFER_LENGTH = 0
 
     def self.get_compressor_options(options, buffer_length_names)
       Validation.validate_hash options
 
       buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
-      options                = COMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+      options                = buffer_length_defaults.merge options
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
       max_code_bit_length = options[:max_code_bit_length]
-      Validation.validate_positive_integer max_code_bit_length
+      unless max_code_bit_length.nil?
+        Validation.validate_positive_integer max_code_bit_length
+        raise ValidateError, "invalid max code bit length" if
+          max_code_bit_length < LOWEST_MAX_CODE_BIT_LENGTH || max_code_bit_length > BIGGEST_MAX_CODE_BIT_LENGTH
+      end
 
-      raise ValidateError, "invalid max code bit length" if
-        max_code_bit_length < LOWEST_MAX_CODE_BIT_LENGTH || max_code_bit_length > BIGGEST_MAX_CODE_BIT_LENGTH
+      without_magic_header = options[:without_magic_header]
+      Validation.validate_bool without_magic_header unless without_magic_header.nil?
 
-      Validation.validate_bool options[:without_magic_header]
-      Validation.validate_bool options[:block_mode]
-      Validation.validate_bool options[:msb]
-      Validation.validate_bool options[:unaligned_bit_groups]
-      Validation.validate_bool options[:quiet]
+      block_mode = options[:block_mode]
+      Validation.validate_bool block_mode unless block_mode.nil?
+
+      msb = options[:msb]
+      Validation.validate_bool msb unless msb.nil?
+
+      unaligned_bit_groups = options[:unaligned_bit_groups]
+      Validation.validate_bool unaligned_bit_groups unless unaligned_bit_groups.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
 
       options
     end
@@ -55,14 +47,21 @@ module LZWS
       Validation.validate_hash options
 
       buffer_length_defaults = buffer_length_names.each_with_object({}) { |name, defaults| defaults[name] = DEFAULT_BUFFER_LENGTH }
-      options                = DECOMPRESSOR_DEFAULTS.merge(buffer_length_defaults).merge options
+      options                = buffer_length_defaults.merge options
 
       buffer_length_names.each { |name| Validation.validate_not_negative_integer options[name] }
 
-      Validation.validate_bool options[:without_magic_header]
-      Validation.validate_bool options[:msb]
-      Validation.validate_bool options[:unaligned_bit_groups]
-      Validation.validate_bool options[:quiet]
+      without_magic_header = options[:without_magic_header]
+      Validation.validate_bool without_magic_header unless without_magic_header.nil?
+
+      msb = options[:msb]
+      Validation.validate_bool msb unless msb.nil?
+
+      unaligned_bit_groups = options[:unaligned_bit_groups]
+      Validation.validate_bool unaligned_bit_groups unless unaligned_bit_groups.nil?
+
+      quiet = options[:quiet]
+      Validation.validate_bool quiet unless quiet.nil?
 
       options
     end

data/lib/lzws/version.rb

@@ -2,5 +2,5 @@
 # Copyright (c) 2019 AUTHORS, MIT License.
 
 module LZWS
-  VERSION = "1.1.7".freeze
+  VERSION = "1.2.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lzws
 version: !ruby/object:Gem::Version
-  version: 1.1.7
+  version: 1.2.0
 platform: ruby
 authors:
 - Andrew Aladjev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-09 00:00:00.000000000 Z
+date: 2020-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codecov
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.12'
+        version: '5.14'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.12'
+        version: '5.14'
 - !ruby/object:Gem::Dependency
   name: ocg
   requirement: !ruby/object:Gem::Requirement
@@ -100,28 +100,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.75'
+        version: '0.93'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.75'
+        version: '0.93'
 - !ruby/object:Gem::Dependency
   name: rubocop-performance
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.5'
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement