ruby-lzws 1.0.0

data/ext/lzws_ext/stream/compressor.c

@@ -0,0 +1,217 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include <lzws/buffer.h>
+#include <lzws/compressor/common.h>
+#include <lzws/compressor/header.h>
+#include <lzws/compressor/main.h>
+#include <lzws/compressor/state.h>
+
+#include "ruby.h"
+
+#include "lzws_ext/error.h"
+#include "lzws_ext/macro.h"
+#include "lzws_ext/option.h"
+#include "lzws_ext/stream/compressor.h"
+
+static void free_compressor(lzws_ext_compressor_t* compressor_ptr)
+{
+  lzws_compressor_state_t* state_ptr = compressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    lzws_compressor_free_state(state_ptr);
+  }
+
+  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(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);
+
+  compressor_ptr->state_ptr                           = NULL;
+  compressor_ptr->destination_buffer                  = NULL;
+  compressor_ptr->destination_buffer_length           = 0;
+  compressor_ptr->remaining_destination_buffer        = NULL;
+  compressor_ptr->remaining_destination_buffer_length = 0;
+
+  return self;
+}
+
+#define GET_COMPRESSOR(self)             \
+  lzws_ext_compressor_t* compressor_ptr; \
+  Data_Get_Struct(self, lzws_ext_compressor_t, compressor_ptr);
+
+VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options)
+{
+  GET_COMPRESSOR(self);
+  LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
+  LZWS_EXT_UNUSED_VARIABLE(without_magic_header);
+
+  lzws_compressor_state_t* compressor_state_ptr;
+
+  lzws_result_t result = lzws_compressor_get_initial_state(
+    &compressor_state_ptr,
+    max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_COMPRESSOR_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result == LZWS_COMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  compressor_ptr->state_ptr = compressor_state_ptr;
+
+  // -----
+
+  uint8_t* destination_buffer;
+  size_t   destination_buffer_length = buffer_length;
+
+  result = lzws_create_buffer_for_compressor(&destination_buffer, &destination_buffer_length, quiet);
+  if (result != 0) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+
+  compressor_ptr->destination_buffer                  = destination_buffer;
+  compressor_ptr->destination_buffer_length           = destination_buffer_length;
+  compressor_ptr->remaining_destination_buffer        = destination_buffer;
+  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return Qnil;
+}
+
+#define DO_NOT_USE_AFTER_CLOSE(compressor_ptr)                                           \
+  if (compressor_ptr->state_ptr == NULL || compressor_ptr->destination_buffer == NULL) { \
+    lzws_ext_raise_error("UsedAfterCloseError", "compressor used after closed");         \
+  }
+
+VALUE lzws_ext_compressor_write_magic_header(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  lzws_result_t result = lzws_compressor_write_magic_header(
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
+
+  if (result == 0) {
+    return Qfalse;
+  }
+  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+    return Qtrue;
+  }
+  else {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+}
+
+#define GET_STRING(source)                         \
+  Check_Type(source, T_STRING);                    \
+                                                   \
+  const char* source_data   = RSTRING_PTR(source); \
+  size_t      source_length = RSTRING_LEN(source);
+
+VALUE lzws_ext_compress(VALUE self, VALUE source)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+  GET_STRING(source);
+
+  uint8_t* remaining_source_data   = (uint8_t*)source_data;
+  size_t   remaining_source_length = source_length;
+
+  lzws_result_t result = lzws_compress(
+    compressor_ptr->state_ptr,
+    &remaining_source_data,
+    &remaining_source_length,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
+
+  VALUE bytes_written = INT2NUM(source_length - remaining_source_length);
+
+  if (result == LZWS_COMPRESSOR_NEEDS_MORE_SOURCE) {
+    return rb_ary_new_from_args(2, bytes_written, Qfalse);
+  }
+  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+    return rb_ary_new_from_args(2, bytes_written, Qtrue);
+  }
+  else {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+}
+
+VALUE lzws_ext_flush_compressor(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  lzws_result_t result = lzws_flush_compressor(
+    compressor_ptr->state_ptr,
+    &compressor_ptr->remaining_destination_buffer,
+    &compressor_ptr->remaining_destination_buffer_length);
+
+  if (result == 0) {
+    return Qfalse;
+  }
+  else if (result == LZWS_COMPRESSOR_NEEDS_MORE_DESTINATION) {
+    return Qtrue;
+  }
+  else {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+}
+
+VALUE lzws_ext_compressor_read_result(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  uint8_t* destination_buffer                  = compressor_ptr->destination_buffer;
+  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_data   = (const char*)destination_buffer;
+  size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
+
+  VALUE result = rb_str_new(result_data, result_length);
+
+  compressor_ptr->remaining_destination_buffer        = destination_buffer;
+  compressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return result;
+}
+
+VALUE lzws_ext_compressor_close(VALUE self)
+{
+  GET_COMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(compressor_ptr);
+
+  lzws_compressor_state_t* state_ptr = compressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    lzws_compressor_free_state(state_ptr);
+
+    compressor_ptr->state_ptr = NULL;
+  }
+
+  uint8_t* destination_buffer = compressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+
+    compressor_ptr->destination_buffer = NULL;
+  }
+
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
+  //   and "remaining_destination_buffer_length" as is.
+
+  return Qnil;
+}

data/ext/lzws_ext/stream/compressor.h

@@ -0,0 +1,27 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_STREAM_COMPRESSOR_H)
+#define LZWS_EXT_STREAM_COMPRESSOR_H
+
+#include <lzws/compressor/state.h>
+
+#include "ruby.h"
+
+typedef struct {
+  lzws_compressor_state_t* state_ptr;
+  uint8_t*                 destination_buffer;
+  size_t                   destination_buffer_length;
+  uint8_t*                 remaining_destination_buffer;
+  size_t                   remaining_destination_buffer_length;
+} lzws_ext_compressor_t;
+
+VALUE lzws_ext_allocate_compressor(VALUE klass);
+VALUE lzws_ext_initialize_compressor(VALUE self, VALUE options);
+VALUE lzws_ext_compressor_write_magic_header(VALUE self);
+VALUE lzws_ext_compress(VALUE self, VALUE source);
+VALUE lzws_ext_flush_compressor(VALUE self);
+VALUE lzws_ext_compressor_read_result(VALUE self);
+VALUE lzws_ext_compressor_close(VALUE self);
+
+#endif // LZWS_EXT_STREAM_COMPRESSOR_H

data/ext/lzws_ext/stream/decompressor.c

@@ -0,0 +1,206 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include <lzws/buffer.h>
+#include <lzws/decompressor/common.h>
+#include <lzws/decompressor/header.h>
+#include <lzws/decompressor/main.h>
+#include <lzws/decompressor/state.h>
+
+#include "ruby.h"
+
+#include "lzws_ext/error.h"
+#include "lzws_ext/macro.h"
+#include "lzws_ext/option.h"
+#include "lzws_ext/stream/decompressor.h"
+
+static void free_decompressor(lzws_ext_decompressor_t* decompressor_ptr)
+{
+  lzws_decompressor_state_t* state_ptr = decompressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    lzws_decompressor_free_state(state_ptr);
+  }
+
+  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+  }
+
+  free(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;
+  decompressor_ptr->destination_buffer                  = NULL;
+  decompressor_ptr->destination_buffer_length           = 0;
+  decompressor_ptr->remaining_destination_buffer        = NULL;
+  decompressor_ptr->remaining_destination_buffer_length = 0;
+
+  return self;
+}
+
+#define GET_DECOMPRESSOR(self)               \
+  lzws_ext_decompressor_t* decompressor_ptr; \
+  Data_Get_Struct(self, lzws_ext_decompressor_t, decompressor_ptr);
+
+VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options)
+{
+  GET_DECOMPRESSOR(self);
+  LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+  LZWS_EXT_UNUSED_VARIABLE(without_magic_header);
+
+  lzws_decompressor_state_t* decompressor_state_ptr;
+
+  lzws_result_t result = lzws_decompressor_get_initial_state(
+    &decompressor_state_ptr,
+    msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_DECOMPRESSOR_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  decompressor_ptr->state_ptr = decompressor_state_ptr;
+
+  // -----
+
+  uint8_t* destination_buffer;
+  size_t   destination_buffer_length = buffer_length;
+
+  result = lzws_create_buffer_for_decompressor(&destination_buffer, &destination_buffer_length, quiet);
+  if (result != 0) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+
+  decompressor_ptr->destination_buffer                  = destination_buffer;
+  decompressor_ptr->destination_buffer_length           = destination_buffer_length;
+  decompressor_ptr->remaining_destination_buffer        = destination_buffer;
+  decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return Qnil;
+}
+
+#define GET_STRING(source)                         \
+  Check_Type(source, T_STRING);                    \
+                                                   \
+  const char* source_data   = RSTRING_PTR(source); \
+  size_t      source_length = RSTRING_LEN(source);
+
+#define DO_NOT_USE_AFTER_CLOSE(decompressor_ptr)                                             \
+  if (decompressor_ptr->state_ptr == NULL || decompressor_ptr->destination_buffer == NULL) { \
+    lzws_ext_raise_error("UsedAfterCloseError", "decompressor used after close");            \
+  }
+
+VALUE lzws_ext_decompressor_read_magic_header(VALUE self, VALUE source)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+  GET_STRING(source);
+
+  uint8_t* remaining_source_data   = (uint8_t*)source_data;
+  size_t   remaining_source_length = source_length;
+
+  lzws_result_t result = lzws_decompressor_read_magic_header(
+    decompressor_ptr->state_ptr,
+    &remaining_source_data,
+    &remaining_source_length);
+
+  VALUE bytes_read = INT2NUM(source_length - remaining_source_length);
+
+  if (result == 0 || result == LZWS_DECOMPRESSOR_NEEDS_MORE_SOURCE) {
+    return bytes_read;
+  }
+  else if (result == LZWS_DECOMPRESSOR_INVALID_MAGIC_HEADER) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+}
+
+VALUE lzws_ext_decompress(VALUE self, VALUE source)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+  GET_STRING(source);
+
+  uint8_t* remaining_source_data   = (uint8_t*)source_data;
+  size_t   remaining_source_length = source_length;
+
+  lzws_result_t result = lzws_decompress(
+    decompressor_ptr->state_ptr,
+    &remaining_source_data,
+    &remaining_source_length,
+    &decompressor_ptr->remaining_destination_buffer,
+    &decompressor_ptr->remaining_destination_buffer_length);
+
+  VALUE bytes_read = INT2NUM(source_length - remaining_source_length);
+
+  if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_SOURCE) {
+    return rb_ary_new_from_args(2, bytes_read, Qfalse);
+  }
+  else if (result == LZWS_DECOMPRESSOR_NEEDS_MORE_DESTINATION) {
+    return rb_ary_new_from_args(2, bytes_read, Qtrue);
+  }
+  else if (result == LZWS_DECOMPRESSOR_INVALID_MAX_CODE_BIT_LENGTH) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result == LZWS_DECOMPRESSOR_CORRUPTED_SOURCE) {
+    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+  }
+  else {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+}
+
+VALUE lzws_ext_decompressor_read_result(VALUE self)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+
+  uint8_t* destination_buffer                  = decompressor_ptr->destination_buffer;
+  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_data   = (const char*)destination_buffer;
+  size_t      result_length = destination_buffer_length - remaining_destination_buffer_length;
+
+  VALUE result = rb_str_new(result_data, result_length);
+
+  decompressor_ptr->remaining_destination_buffer        = destination_buffer;
+  decompressor_ptr->remaining_destination_buffer_length = destination_buffer_length;
+
+  return result;
+}
+
+VALUE lzws_ext_decompressor_close(VALUE self)
+{
+  GET_DECOMPRESSOR(self);
+  DO_NOT_USE_AFTER_CLOSE(decompressor_ptr);
+
+  lzws_decompressor_state_t* state_ptr = decompressor_ptr->state_ptr;
+  if (state_ptr != NULL) {
+    lzws_decompressor_free_state(state_ptr);
+
+    decompressor_ptr->state_ptr = NULL;
+  }
+
+  uint8_t* destination_buffer = decompressor_ptr->destination_buffer;
+  if (destination_buffer != NULL) {
+    free(destination_buffer);
+
+    decompressor_ptr->destination_buffer = NULL;
+  }
+
+  // It is possible to keep "destination_buffer_length", "remaining_destination_buffer"
+  //   and "remaining_destination_buffer_length" as is.
+
+  return Qnil;
+}

data/ext/lzws_ext/stream/decompressor.h

@@ -0,0 +1,26 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#if !defined(LZWS_EXT_STREAM_DECOMPRESSOR_H)
+#define LZWS_EXT_STREAM_DECOMPRESSOR_H
+
+#include <lzws/decompressor/state.h>
+
+#include "ruby.h"
+
+typedef struct {
+  lzws_decompressor_state_t* state_ptr;
+  uint8_t*                   destination_buffer;
+  size_t                     destination_buffer_length;
+  uint8_t*                   remaining_destination_buffer;
+  size_t                     remaining_destination_buffer_length;
+} lzws_ext_decompressor_t;
+
+VALUE lzws_ext_allocate_decompressor(VALUE klass);
+VALUE lzws_ext_initialize_decompressor(VALUE self, VALUE options);
+VALUE lzws_ext_decompressor_read_magic_header(VALUE self, VALUE source);
+VALUE lzws_ext_decompress(VALUE self, VALUE source);
+VALUE lzws_ext_decompressor_read_result(VALUE self);
+VALUE lzws_ext_decompressor_close(VALUE self);
+
+#endif // LZWS_EXT_STREAM_DECOMPRESSOR_H

data/ext/lzws_ext/string.c

@@ -0,0 +1,78 @@
+// Ruby bindings for lzws library.
+// Copyright (c) 2019 AUTHORS, MIT License.
+
+#include <lzws/string.h>
+
+#include "ruby.h"
+
+#include "lzws_ext/error.h"
+#include "lzws_ext/macro.h"
+#include "lzws_ext/option.h"
+#include "lzws_ext/string.h"
+
+#define GET_STRING(source)                         \
+  Check_Type(source, T_STRING);                    \
+                                                   \
+  const char* source_data   = RSTRING_PTR(source); \
+  size_t      source_length = RSTRING_LEN(source);
+
+VALUE lzws_ext_compress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE options)
+{
+  GET_STRING(source);
+  LZWS_EXT_GET_COMPRESSOR_OPTIONS(options);
+
+  char*  destination;
+  size_t destination_length;
+
+  lzws_result_t result = lzws_compress_string(
+    (uint8_t*)source_data, source_length,
+    (uint8_t**)&destination, &destination_length, buffer_length,
+    without_magic_header, max_code_bit_length, block_mode, msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_STRING_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result == LZWS_STRING_VALIDATE_FAILED) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  // Ruby copies string on initialization.
+  VALUE result_string = rb_str_new(destination, destination_length);
+  free(destination);
+  return result_string;
+}
+
+VALUE lzws_ext_decompress_string(VALUE LZWS_EXT_UNUSED(self), VALUE source, VALUE options)
+{
+  GET_STRING(source);
+  LZWS_EXT_GET_DECOMPRESSOR_OPTIONS(options);
+
+  char*  destination;
+  size_t destination_length;
+
+  lzws_result_t result = lzws_decompress_string(
+    (uint8_t*)source_data, source_length,
+    (uint8_t**)&destination, &destination_length, buffer_length,
+    without_magic_header, msb, unaligned_bit_groups, quiet);
+
+  if (result == LZWS_STRING_ALLOCATE_FAILED) {
+    lzws_ext_raise_error("AllocateError", "allocate error");
+  }
+  else if (result == LZWS_STRING_VALIDATE_FAILED) {
+    lzws_ext_raise_error("ValidateError", "validate error");
+  }
+  else if (result == LZWS_STRING_DECOMPRESSOR_CORRUPTED_SOURCE) {
+    lzws_ext_raise_error("DecompressorCorruptedSourceError", "decompressor received corrupted source");
+  }
+  else if (result != 0) {
+    lzws_ext_raise_error("UnexpectedError", "unexpected error");
+  }
+
+  // Ruby copies string on initialization.
+  VALUE result_string = rb_str_new(destination, destination_length);
+  free(destination);
+  return result_string;
+}

data/ext/lzws_ext/string.h

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

data/lib/lzws/error.rb

@@ -0,0 +1,20 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+module LZWS
+  class BaseError < ::StandardError; end
+
+  class ValidateError   < BaseError; end
+  class AllocateError   < BaseError; end
+  class UnexpectedError < BaseError; end
+
+  class NotEnoughDestinationError < BaseError; end
+  class UsedAfterCloseError       < BaseError; end
+
+  class DecompressorCorruptedSourceError < BaseError; end
+
+  class OpenFileError < BaseError; end
+  class AccessIOError < BaseError; end
+  class ReadIOError   < BaseError; end
+  class WriteIOError  < BaseError; end
+end

data/lib/lzws/file.rb

@@ -0,0 +1,56 @@
+# Ruby bindings for lzws library.
+# Copyright (c) 2019 AUTHORS, MIT License.
+
+require "lzws_ext"
+
+require_relative "error"
+require_relative "option"
+require_relative "validation"
+
+module LZWS
+  module File
+    def self.compress(source, destination, options = {})
+      Validation.validate_string source
+      Validation.validate_string destination
+
+      options = Option.get_compressor_options options
+
+      open_files(source, destination) do |source_io, destination_io|
+        LZWS._native_compress_io source_io, destination_io, options
+      end
+    end
+
+    def self.decompress(source, destination, options = {})
+      Validation.validate_string source
+      Validation.validate_string destination
+
+      options = Option.get_decompressor_options options
+
+      open_files(source, destination) do |source_io, destination_io|
+        LZWS._native_decompress_io source_io, destination_io, options
+      end
+    end
+
+    private_class_method def self.open_files(source, destination, &_block)
+      open_file(source, "rb") do |source_io|
+        open_file(destination, "wb") do |destination_io|
+          yield source_io, destination_io
+        end
+      end
+    end
+
+    private_class_method def self.open_file(path, mode, &_block)
+      begin
+        io = ::File.open path, mode
+      rescue ::StandardError
+        raise OpenFileError, "open file failed"
+      end
+
+      begin
+        yield io
+      ensure
+        io.close
+      end
+    end
+  end
+end