multi_compress 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 404264c1ba462057374ad7a6a2a72565a16e1da607e47b1d3d91b727b4e74351
-  data.tar.gz: d23f9c3af016742a7aef3880209a2e68ba5ed2107c6c3eb3943a30802606c6ac
+  metadata.gz: 23ab6bacd75b21b5cfbf5b7b3121428c18060bd9e097f815438af6c8bafd8883
+  data.tar.gz: 90321202358a43bb732077aa1f28b8a9e5d756e27067df851671883a21eb1470
 SHA512:
-  metadata.gz: 91091ad2e184758916b7c79aa0ec82a3216f5d87798a7c597b43afe25b8eaa091fd7094c5de71e4eac5e01804f7b9928734514224cd0312edd1f60187d04c91b
-  data.tar.gz: 275044013ecacca6ee300ce8b980c252048f021acc2cf51e169722830add7301dbc4e9f6942c07845ea672c5e1dd9fe8074c7840b155096c3b40b2b1e3d5ebdc
+  metadata.gz: 431921d63b8757216df9179dfd5d792103777dbf597d52cfafeb2e593ee8ab52ce12f374499826b0eba45a164bfde0f4adaa3aa3ba9ee811c6d9f44ed2ccdb7d
+  data.tar.gz: 2e1d3bf4455fd627696c7ff7a500e6424497df012939487d39896b8e50dad421c8acd8b427f10fc3de6a51b799ca5b1532cda5508485440e4f633a5ac5677a1d

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.3.2]
+
+### Changed
+- Micro-optimization
+
 ## [0.3.1]
 
 ### Fixed

data/README.md

@@ -106,9 +106,9 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 │ Medium JSON (~370KB, no GC) │    8.5% │   15.7% │    6.7% │    5.5% │
 │ Medium logs (~168KB, no GC) │    8.6% │   17.2% │    5.4% │    3.2% │
 │ Large JSON (~1.6MB, GC)     │    8.1% │   15.1% │    6.1% │    5.6% │
-│ Large logs (~600KB, GC)     │    7.6% │   16.0% │    2.8% │    2.1% │
+│ Large logs (~600KB, GC)     │    7.6% │   16.0% │    2.9% │    2.0% │
 │ Large JSON (~1.6MB, no GC)  │    8.1% │   15.1% │    6.1% │    5.6% │
-│ Large logs (~600KB, no GC)  │    7.6% │   16.0% │    2.8% │    2.1% │
+│ Large logs (~600KB, no GC)  │    7.6% │   16.0% │    2.9% │    2.0% │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 
@@ -117,18 +117,18 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 ┌─────────────────────────────┬─────────┬─────────┬─────────┬─────────┐
 │ Configuration               │  zlib   │   lz4   │  zstd   │ brotli  │
 ├─────────────────────────────┼─────────┼─────────┼─────────┼─────────┤
-│ Small JSON (~10KB, GC)      │    0.05 │    0.01 │    0.02 │    0.14 │
-│ Small text (~10KB, GC)      │    0.04 │    0.00 │    0.01 │    0.11 │
+│ Small JSON (~10KB, GC)      │    0.05 │    0.01 │    0.02 │    0.12 │
+│ Small text (~10KB, GC)      │    0.03 │    0.00 │    0.01 │    0.09 │
 │ Small JSON (~10KB, no GC)   │    0.06 │    0.01 │    0.02 │    0.13 │
-│ Small text (~10KB, no GC)   │    0.04 │    0.00 │    0.01 │    0.11 │
-│ Medium JSON (~370KB, GC)    │    2.73 │    0.29 │    0.42 │    2.36 │
-│ Medium logs (~168KB, GC)    │    1.23 │    0.14 │    0.18 │    0.92 │
-│ Medium JSON (~370KB, no GC) │    2.72 │    0.28 │    0.41 │    2.41 │
-│ Medium logs (~168KB, no GC) │    1.26 │    0.13 │    0.18 │    0.96 │
-│ Large JSON (~1.6MB, GC)     │   12.44 │    1.38 │    1.96 │   12.44 │
-│ Large logs (~600KB, GC)     │    4.29 │    0.46 │    0.49 │    2.85 │
-│ Large JSON (~1.6MB, no GC)  │   12.22 │    1.28 │    1.86 │   11.83 │
-│ Large logs (~600KB, no GC)  │    4.39 │    0.42 │    0.44 │    2.86 │
+│ Small text (~10KB, no GC)   │    0.03 │    0.00 │    0.01 │    0.11 │
+│ Medium JSON (~370KB, GC)    │    2.62 │    0.28 │    0.39 │    2.31 │
+│ Medium logs (~168KB, GC)    │    1.23 │    0.13 │    0.18 │    0.88 │
+│ Medium JSON (~370KB, no GC) │    2.65 │    0.27 │    0.40 │    2.31 │
+│ Medium logs (~168KB, no GC) │    1.27 │    0.13 │    0.18 │    0.95 │
+│ Large JSON (~1.6MB, GC)     │   11.70 │    1.36 │    1.93 │   11.95 │
+│ Large logs (~600KB, GC)     │    4.10 │    0.45 │    0.45 │    2.62 │
+│ Large JSON (~1.6MB, no GC)  │   11.47 │    1.27 │    1.88 │   11.47 │
+│ Large logs (~600KB, no GC)  │    4.06 │    0.41 │    0.45 │    2.79 │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 
@@ -137,18 +137,18 @@ Performance comparison against Ruby's built-in zlib compression (200 iterations
 ┌─────────────────────────────┬─────────┬─────────┬─────────┬─────────┐
 │ Configuration               │  zlib   │   lz4   │  zstd   │ brotli  │
 ├─────────────────────────────┼─────────┼─────────┼─────────┼─────────┤
-│ Small JSON (~10KB, GC)      │   1.00x │   5.00x │   2.50x │   0.36x │
-│ Small text (~10KB, GC)      │   1.00x │     N/A │   4.00x │   0.36x │
+│ Small JSON (~10KB, GC)      │   1.00x │   5.00x │   2.50x │   0.42x │
+│ Small text (~10KB, GC)      │   1.00x │     N/A │   3.00x │   0.33x │
 │ Small JSON (~10KB, no GC)   │   1.00x │   6.00x │   3.00x │   0.46x │
-│ Small text (~10KB, no GC)   │   1.00x │     N/A │   4.00x │   0.36x │
-│ Medium JSON (~370KB, GC)    │   1.00x │   9.41x │   6.50x │   1.16x │
-│ Medium logs (~168KB, GC)    │   1.00x │   8.79x │   6.83x │   1.34x │
-│ Medium JSON (~370KB, no GC) │   1.00x │   9.71x │   6.63x │   1.13x │
-│ Medium logs (~168KB, no GC) │   1.00x │   9.69x │   7.00x │   1.31x │
-│ Large JSON (~1.6MB, GC)     │   1.00x │   9.01x │   6.35x │   1.00x │
-│ Large logs (~600KB, GC)     │   1.00x │   9.33x │   8.76x │   1.51x │
-│ Large JSON (~1.6MB, no GC)  │   1.00x │   9.55x │   6.57x │   1.03x │
-│ Large logs (~600KB, no GC)  │   1.00x │  10.45x │   9.98x │   1.53x │
+│ Small text (~10KB, no GC)   │   1.00x │     N/A │   3.00x │   0.27x │
+│ Medium JSON (~370KB, GC)    │   1.00x │   9.36x │   6.72x │   1.13x │
+│ Medium logs (~168KB, GC)    │   1.00x │   9.46x │   6.83x │   1.40x │
+│ Medium JSON (~370KB, no GC) │   1.00x │   9.81x │   6.62x │   1.15x │
+│ Medium logs (~168KB, no GC) │   1.00x │   9.77x │   7.06x │   1.34x │
+│ Large JSON (~1.6MB, GC)     │   1.00x │   8.60x │   6.06x │   0.98x │
+│ Large logs (~600KB, GC)     │   1.00x │   9.11x │   9.11x │   1.56x │
+│ Large JSON (~1.6MB, no GC)  │   1.00x │   9.03x │   6.10x │   1.00x │
+│ Large logs (~600KB, no GC)  │   1.00x │   9.90x │   9.02x │   1.46x │
 └─────────────────────────────┴─────────┴─────────┴─────────┴─────────┘
 ```
 

data/ext/multi_compress/multi_compress.c

@@ -137,12 +137,94 @@ static void init_id_cache(void) {
     sym_cache.max_ratio = ID2SYM(id_cache.max_ratio);
 }
 
-static inline VALUE opt_get(VALUE opts, VALUE sym) {
-    return NIL_P(opts) ? Qnil : rb_hash_aref(opts, sym);
+typedef struct {
+    VALUE algo;
+    VALUE level;
+    VALUE dictionary;
+    VALUE size;
+    VALUE format;
+    VALUE max_output_size;
+    VALUE max_ratio;
+    int saw_algorithm_keyword;
+} mc_opts_t;
+
+static inline void mc_opts_init(mc_opts_t *opts) {
+    opts->algo = Qnil;
+    opts->level = Qnil;
+    opts->dictionary = Qnil;
+    opts->size = Qnil;
+    opts->format = Qnil;
+    opts->max_output_size = Qundef;
+    opts->max_ratio = Qundef;
+    opts->saw_algorithm_keyword = 0;
+}
+
+static int mc_opts_parse_i(VALUE key, VALUE value, VALUE arg) {
+    mc_opts_t *opts = (mc_opts_t *)arg;
+
+    if (!SYMBOL_P(key))
+        return ST_CONTINUE;
+
+    ID id = SYM2ID(key);
+    if (id == id_cache.algo) {
+        opts->algo = value;
+    } else if (id == id_cache.level) {
+        opts->level = value;
+    } else if (id == id_cache.dictionary) {
+        opts->dictionary = value;
+    } else if (id == id_cache.size) {
+        opts->size = value;
+    } else if (id == id_cache.format) {
+        opts->format = value;
+    } else if (id == id_cache.max_output_size) {
+        opts->max_output_size = value;
+    } else if (id == id_cache.max_ratio) {
+        opts->max_ratio = value;
+    } else if (id == id_cache.algorithm) {
+        opts->saw_algorithm_keyword = 1;
+    }
+
+    return ST_CONTINUE;
+}
+
+static inline void mc_parse_opts(VALUE opts_hash, mc_opts_t *opts) {
+    mc_opts_init(opts);
+    if (NIL_P(opts_hash))
+        return;
+    Check_Type(opts_hash, T_HASH);
+    rb_hash_foreach(opts_hash, mc_opts_parse_i, (VALUE)opts);
+}
+
+static inline void scan_one_required_keywords(int argc, VALUE *argv, VALUE *arg, VALUE *opts) {
+    if (argc == 1) {
+        *arg = argv[0];
+        *opts = Qnil;
+        return;
+    }
+
+    if (argc == 2 && rb_keyword_given_p()) {
+        *arg = argv[0];
+        *opts = argv[1];
+        Check_Type(*opts, T_HASH);
+        return;
+    }
+
+    rb_error_arity(argc, 1, 1);
 }
 
-static inline VALUE opt_lookup2(VALUE opts, VALUE sym, VALUE default_value) {
-    return NIL_P(opts) ? default_value : rb_hash_lookup2(opts, sym, default_value);
+static inline void scan_zero_required_keywords(int argc, VALUE *argv, VALUE *opts) {
+    if (argc == 0) {
+        *opts = Qnil;
+        return;
+    }
+
+    if (argc == 1 && rb_keyword_given_p()) {
+        *opts = argv[0];
+        Check_Type(*opts, T_HASH);
+        return;
+    }
+
+    rb_error_arity(argc, 0, 0);
 }
 
 enum { LZ4_FRAME_MAGIC_LEN = 4 };
@@ -152,8 +234,9 @@ static inline int is_lz4_frame_magic(const uint8_t *data, size_t len) {
     return len >= LZ4_FRAME_MAGIC_LEN && memcmp(data, LZ4_FRAME_MAGIC, LZ4_FRAME_MAGIC_LEN) == 0;
 }
 
-static lz4_format_t parse_lz4_format(VALUE opts, compress_algo_t algo, int explicit_algo) {
-    VALUE format_val = opt_lookup2(opts, sym_cache.format, Qundef);
+static lz4_format_t parse_lz4_format(const mc_opts_t *opts, compress_algo_t algo,
+                                     int explicit_algo) {
+    VALUE format_val = opts->format;
     if (format_val == Qundef || NIL_P(format_val))
         return LZ4_FORMAT_BLOCK;
     if (explicit_algo && algo != ALGO_LZ4)
@@ -169,10 +252,8 @@ static lz4_format_t parse_lz4_format(VALUE opts, compress_algo_t algo, int expli
     return LZ4_FORMAT_BLOCK;
 }
 
-static inline void reject_algorithm_keyword(VALUE opts) {
-    if (NIL_P(opts))
-        return;
-    if (rb_hash_lookup2(opts, sym_cache.algorithm, Qundef) != Qundef) {
+static inline void reject_algorithm_keyword(const mc_opts_t *opts) {
+    if (opts->saw_algorithm_keyword) {
         rb_raise(rb_eArgError, "unknown keyword: :algorithm (use :algo)");
     }
 }
@@ -383,11 +464,8 @@ static void limits_config_init(limits_config_t *limits) {
     limits->max_ratio = DEFAULT_MAX_RATIO;
 }
 
-static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
-    if (NIL_P(opts))
-        return;
-
-    VALUE val = opt_lookup2(opts, sym_cache.max_output_size, Qundef);
+static void limits_config_apply_parsed(const mc_opts_t *opts, limits_config_t *limits) {
+    VALUE val = opts->max_output_size;
     if (val != Qundef && !NIL_P(val)) {
         size_t max_output_size = NUM2SIZET(val);
         if (max_output_size == 0)
@@ -395,7 +473,7 @@ static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
         limits->max_output_size = max_output_size;
     }
 
-    val = opt_lookup2(opts, sym_cache.max_ratio, Qundef);
+    val = opts->max_ratio;
     if (val == Qundef)
         return;
     if (NIL_P(val)) {
@@ -411,9 +489,9 @@ static void limits_config_apply_opts(VALUE opts, limits_config_t *limits) {
     limits->max_ratio = max_ratio;
 }
 
-static void parse_limits_from_opts(VALUE opts, limits_config_t *limits) {
+static void parse_limits_from_parsed_opts(const mc_opts_t *opts, limits_config_t *limits) {
     limits_config_init(limits);
-    limits_config_apply_opts(opts, limits);
+    limits_config_apply_parsed(opts, limits);
 }
 
 static inline size_t checked_add_size(size_t left, size_t right, const char *message) {
@@ -1107,20 +1185,20 @@ static void *zstd_fiber_compress_nogvl(void *arg) {
 
 static VALUE compress_compress(int argc, VALUE *argv, VALUE self) {
     VALUE data, opts;
-    rb_scan_args(argc, argv, "1:", &data, &opts);
+    scan_one_required_keywords(argc, argv, &data, &opts);
     StringValue(data);
-    reject_algorithm_keyword(opts);
 
-    VALUE algo_sym = Qnil, level_val = Qnil, dict_val = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        level_val = opt_get(opts, sym_cache.level);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE level_val = parsed_opts.level;
+    VALUE dict_val = parsed_opts.dictionary;
 
     int explicit_algo = !NIL_P(algo_sym);
     compress_algo_t algo = explicit_algo ? sym_to_algo(algo_sym) : ALGO_ZSTD;
-    lz4_format_t lz4_format = parse_lz4_format(opts, algo, explicit_algo);
+    lz4_format_t lz4_format = parse_lz4_format(&parsed_opts, algo, explicit_algo);
     int level = resolve_level(algo, level_val);
 
     dictionary_t *dict = NULL;
@@ -1406,17 +1484,17 @@ static VALUE compress_compress(int argc, VALUE *argv, VALUE self) {
 
 static VALUE compress_decompress(int argc, VALUE *argv, VALUE self) {
     VALUE data, opts;
-    rb_scan_args(argc, argv, "1:", &data, &opts);
+    scan_one_required_keywords(argc, argv, &data, &opts);
     StringValue(data);
-    reject_algorithm_keyword(opts);
 
-    VALUE algo_sym = Qnil, dict_val = Qnil;
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE dict_val = parsed_opts.dictionary;
     limits_config_t limits;
-    parse_limits_from_opts(opts, &limits);
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    parse_limits_from_parsed_opts(&parsed_opts, &limits);
 
     const uint8_t *src = (const uint8_t *)RSTRING_PTR(data);
     size_t slen = RSTRING_LEN(data);
@@ -1428,7 +1506,7 @@ static VALUE compress_decompress(int argc, VALUE *argv, VALUE self) {
     } else {
         algo = sym_to_algo(algo_sym);
     }
-    lz4_format_t lz4_format = parse_lz4_format(opts, algo, explicit_algo);
+    lz4_format_t lz4_format = parse_lz4_format(&parsed_opts, algo, explicit_algo);
 
     const algo_policy_t *policy = algo_policy(algo);
 
@@ -2009,18 +2087,18 @@ static VALUE deflater_alloc(VALUE klass) {
 
 static VALUE deflater_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE opts;
-    rb_scan_args(argc, argv, "0:", &opts);
-    reject_algorithm_keyword(opts);
+    scan_zero_required_keywords(argc, argv, &opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     deflater_t *d;
     TypedData_Get_Struct(self, deflater_t, &deflater_type, d);
 
-    VALUE algo_sym = Qnil, level_val = Qnil, dict_val = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        level_val = opt_get(opts, sym_cache.level);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE level_val = parsed_opts.level;
+    VALUE dict_val = parsed_opts.dictionary;
 
     d->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
     d->level = resolve_level(d->algo, level_val);
@@ -2663,19 +2741,19 @@ static VALUE inflater_alloc(VALUE klass) {
 
 static VALUE inflater_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE opts;
-    rb_scan_args(argc, argv, "0:", &opts);
-    reject_algorithm_keyword(opts);
+    scan_zero_required_keywords(argc, argv, &opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     inflater_t *inf;
     TypedData_Get_Struct(self, inflater_t, &inflater_type, inf);
 
-    VALUE algo_sym = Qnil, dict_val = Qnil;
+    VALUE algo_sym = parsed_opts.algo;
+    VALUE dict_val = parsed_opts.dictionary;
     limits_config_t limits;
-    parse_limits_from_opts(opts, &limits);
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-        dict_val = opt_get(opts, sym_cache.dictionary);
-    }
+    parse_limits_from_parsed_opts(&parsed_opts, &limits);
 
     inf->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
     inf->closed = 0;
@@ -3088,17 +3166,17 @@ static VALUE inflater_closed_p(VALUE self) {
 
 static VALUE dict_initialize(int argc, VALUE *argv, VALUE self) {
     VALUE raw, opts;
-    rb_scan_args(argc, argv, "1:", &raw, &opts);
+    scan_one_required_keywords(argc, argv, &raw, &opts);
     StringValue(raw);
-    reject_algorithm_keyword(opts);
+
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
     dictionary_t *d;
     TypedData_Get_Struct(self, dictionary_t, &dictionary_type, d);
 
-    VALUE algo_sym = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-    }
+    VALUE algo_sym = parsed_opts.algo;
     d->algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
 
     if (d->algo == ALGO_LZ4)
@@ -3183,32 +3261,34 @@ static VALUE train_dictionary_internal(VALUE samples, VALUE size_val, compress_a
 
 static VALUE zstd_train_dictionary(int argc, VALUE *argv, VALUE self) {
     VALUE samples, opts;
-    rb_scan_args(argc, argv, "1:", &samples, &opts);
-    reject_algorithm_keyword(opts);
-    VALUE size_val = opt_get(opts, sym_cache.size);
-    return train_dictionary_internal(samples, size_val, ALGO_ZSTD);
+    scan_one_required_keywords(argc, argv, &samples, &opts);
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+    return train_dictionary_internal(samples, parsed_opts.size, ALGO_ZSTD);
 }
 
 static VALUE brotli_train_dictionary(int argc, VALUE *argv, VALUE self) {
     VALUE samples, opts;
-    rb_scan_args(argc, argv, "1:", &samples, &opts);
-    reject_algorithm_keyword(opts);
-    VALUE size_val = opt_get(opts, sym_cache.size);
+    scan_one_required_keywords(argc, argv, &samples, &opts);
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
 
-    return train_dictionary_internal(samples, size_val, ALGO_BROTLI);
+    return train_dictionary_internal(samples, parsed_opts.size, ALGO_BROTLI);
 }
 
 static VALUE dict_load(int argc, VALUE *argv, VALUE self) {
     VALUE path, opts;
-    rb_scan_args(argc, argv, "1:", &path, &opts);
+    scan_one_required_keywords(argc, argv, &path, &opts);
     StringValue(path);
-    reject_algorithm_keyword(opts);
     raise_if_path_has_null_byte(path);
 
-    VALUE algo_sym = Qnil;
-    if (!NIL_P(opts)) {
-        algo_sym = opt_get(opts, sym_cache.algo);
-    }
+    mc_opts_t parsed_opts;
+    mc_parse_opts(opts, &parsed_opts);
+    reject_algorithm_keyword(&parsed_opts);
+
+    VALUE algo_sym = parsed_opts.algo;
     compress_algo_t algo = NIL_P(algo_sym) ? ALGO_ZSTD : sym_to_algo(algo_sym);
 
     if (algo == ALGO_LZ4)

data/lib/multi_compress/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MultiCompress
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: multi_compress
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Roman Haydarov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-18 00:00:00.000000000 Z
+date: 2026-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler