mspack_rb 0.1.7 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ca23ebbd613db3fe80bd92522255ba960a7b039
-  data.tar.gz: a9f7f8bb5d4be741d535d3c6c4b03ae2430c80d5
+  metadata.gz: 7344a42572aaac8736edceaa4b344f7ae61125bf
+  data.tar.gz: 05fcde6d525e3e7814212b00cd7987dcd8d7e94d
 SHA512:
-  metadata.gz: 413f41de3155794d82dcfb7d0e4e5f58319cd4026f652dcaa333ea0b62a300008aa4f27e3edf8d428c3d0d83000becc008b602ad65d98206dc7ab89f6daea72c
-  data.tar.gz: 91758d054375b7d19a7de6e6551b5627161e6eb14744858dbf73394f18b7255f115dfe47260ab20cf32312a984fcb1faf44e7e45f45714409fa75d710a79c955
+  metadata.gz: e43ac5361052d84ec4d166c202022dfd4938c95595856e1b8215ca3e29dd69541e3e266e6bcd58db7c4e0a908cd29a84bc523d633c3396fa496fb126fea49aa2
+  data.tar.gz: c47aa65dc8dba1e5a632090d1f1c9e6a9358bca907ea36899df79b594380ae5c72315ca8ff7152decdaf3989777a88b0f0fa95511df70f639af660d76d9a8743

data/ext/mspack_native/chm_decompressor.c

@@ -1,10 +1,19 @@
 #include "chm_decompressor.h"
+
 #include "mspack_native.h"
+
 #include "chm_decompressor_header.h"
 #include "chm_decompressor_file.h"
 
+#include "io_system.h"
+
 #include <mspack.h>
 
+struct decom_wrapper {
+  struct mschm_decompressor *decom;
+  struct mspack_system *system;
+};
+
 /*
  * utility methods
  */
@@ -59,16 +68,16 @@ static inline VALUE _error_code_sym(int code) {
 static inline VALUE _open(VALUE self, VALUE path, int fast_bool) {
   Check_Type(path, T_STRING);
 
-  struct mschm_decompressor *decom;
-  Data_Get_Struct(self, struct mschm_decompressor, decom);
+  struct decom_wrapper *wrapper;
+  Data_Get_Struct(self, struct decom_wrapper, wrapper);
 
   struct mschmd_header *header;
 
   if (fast_bool) {
-    header = decom->fast_open(decom, StringValueCStr(path));
+    header = wrapper->decom->fast_open(wrapper->decom, StringValueCStr(path));
   }
   else {
-    header = decom->open(decom, StringValueCStr(path));
+    header = wrapper->decom->open(wrapper->decom, StringValueCStr(path));
   }
 
   if (!header) {
@@ -86,13 +95,17 @@ static inline VALUE _open(VALUE self, VALUE path, int fast_bool) {
  * decompressor
  */
 
-void chmd_deallocate(void *decom) {
-  mspack_destroy_chm_decompressor(decom);
+void chmd_deallocate(void *wrapper) {
+  mspack_destroy_chm_decompressor(((struct decom_wrapper *)wrapper)->decom);
+  free(((struct decom_wrapper *)wrapper)->system);
+  free((struct decom_wrapper *)wrapper);
 }
 
 VALUE chmd_allocate(VALUE self) {
-  struct mschm_decompressor *decom = mspack_create_chm_decompressor(NULL);
-  return Data_Wrap_Struct(self, NULL, chmd_deallocate, decom);
+  struct decom_wrapper *wrapper = malloc(sizeof(struct decom_wrapper));
+  wrapper->system = io_system();
+  wrapper->decom = mspack_create_chm_decompressor(wrapper->system);    
+  return Data_Wrap_Struct(self, NULL, chmd_deallocate, wrapper);
 }
 
 VALUE chmd_open(VALUE self, VALUE path) {
@@ -104,39 +117,65 @@ VALUE chmd_close(VALUE self, VALUE header) {
     rb_raise(rb_eTypeError, "Parameter must be a CHM decompression header");
   }
 
-  struct mschm_decompressor *decom;
-  Data_Get_Struct(self, struct mschm_decompressor, decom);
+  struct decom_wrapper *wrapper;
+  Data_Get_Struct(self, struct decom_wrapper, wrapper);
 
   struct mschmd_header *headerPtr;
   Data_Get_Struct(header, struct mschmd_header, headerPtr);
 
-  decom->close(decom, headerPtr);
+  wrapper->decom->close(wrapper->decom, headerPtr);
   return Qnil;
 }
 
-VALUE chmd_extract_to_path(VALUE self, VALUE file, VALUE outputPath) {
+/*
+ * Form 1:
+ * extract_to_path(file, outputPath)
+ *
+ * Form 2:
+ * extract_to_path(file) { |data_chunk| do_something(data_chunk) }
+ */
+VALUE chmd_extract_to_path(int argc, VALUE* argv, VALUE self) {
+  VALUE file;
+  VALUE outputPath;
+  rb_scan_args(argc, argv, "11", &file, &outputPath);
+  const char *pathStr;
+
   if (!CLASS_OF(file) == ChmDFile) {
     rb_raise(rb_eTypeError, "First parameter must be a CHM decompression file");
   }
 
-  Check_Type(outputPath, T_STRING);
+  if (argc == 1) {
+    rb_need_block();
 
-  struct mschm_decompressor *decom;
-  Data_Get_Struct(self, struct mschm_decompressor, decom);
+    VALUE block;
+    block = rb_block_proc();
 
-  struct chmd_file_wrapper *wrapper;
-  Data_Get_Struct(file, struct chmd_file_wrapper, wrapper);
-  const char *pathStr = StringValueCStr(outputPath);
+    VALUE blockName = rb_funcall(block, rb_intern("to_s"), 0);
+    pathStr = StringValueCStr(blockName);
+    add_block(&blockName, &block);
+  }
+  else {
+    Check_Type(outputPath, T_STRING);
+    pathStr = StringValueCStr(outputPath);
+  }
+
+  struct decom_wrapper *wrapper;
+  Data_Get_Struct(self, struct decom_wrapper, wrapper);
+
+  struct chmd_file_wrapper *headerWrapper;
+  Data_Get_Struct(file, struct chmd_file_wrapper, headerWrapper);
+
+  int result = 
+    wrapper->decom->extract(wrapper->decom, headerWrapper->file, pathStr);
 
-  int result = decom->extract(decom, wrapper->file, pathStr);
   return result == MSPACK_ERR_OK ? Qtrue : Qfalse;
 }
 
 VALUE chmd_last_error(VALUE self) {
-  struct mschm_decompressor *decom;
-  Data_Get_Struct(self, struct mschm_decompressor, decom);
+  struct decom_wrapper *wrapper;
+  Data_Get_Struct(self, struct decom_wrapper, wrapper);
 
-  int error = decom->last_error(decom);
+  int error = wrapper->decom->last_error(wrapper->decom);
   return _error_code_sym(error);
 }
 
@@ -145,8 +184,8 @@ VALUE chmd_fast_open(VALUE self, VALUE path) {
 }
 
 VALUE chmd_fast_find(VALUE self, VALUE header, VALUE filename) {
-  struct mschm_decompressor *decom;
-  Data_Get_Struct(self, struct mschm_decompressor, decom);
+  struct decom_wrapper *wrapper;
+  Data_Get_Struct(self, struct decom_wrapper, wrapper);
 
   struct mschmd_header *headerPtr;
   Data_Get_Struct(header, struct mschmd_header, headerPtr);
@@ -156,8 +195,8 @@ VALUE chmd_fast_find(VALUE self, VALUE header, VALUE filename) {
   int structSize = sizeof(struct mschmd_file);
   struct mschmd_file *file = malloc(structSize);
 
-  int result = 
-    decom->fast_find(decom, headerPtr, filenameStr, file, structSize);
+  int result = wrapper->decom->fast_find(
+    wrapper->decom, headerPtr, filenameStr, file, structSize);
 
   if (result != MSPACK_ERR_OK || file->length == 0) {
     free(file);
@@ -167,11 +206,12 @@ VALUE chmd_fast_find(VALUE self, VALUE header, VALUE filename) {
   file->filename = malloc(sizeof(char) * strlen(filenameStr) + 1);
   strcpy(file->filename, filenameStr);
 
-  struct chmd_file_wrapper *wrapper = malloc(sizeof(struct chmd_file_wrapper));
-  wrapper->is_fast_find = 1;
-  wrapper->file = file;
+  struct chmd_file_wrapper *fileWrapper = 
+    malloc(sizeof(struct chmd_file_wrapper));
+  fileWrapper->is_fast_find = 1;
+  fileWrapper->file = file;
 
-  return Data_Wrap_Struct(ChmDFile, NULL, chmd_file_free, wrapper);
+  return Data_Wrap_Struct(ChmDFile, NULL, chmd_file_free, fileWrapper);
 }
 
 void Init_chm_decompressor() {
@@ -179,7 +219,7 @@ void Init_chm_decompressor() {
   rb_define_alloc_func(ChmDecom, chmd_allocate);
   rb_define_method(ChmDecom, "open", chmd_open, 1);
   rb_define_method(ChmDecom, "close", chmd_close, 1);
-  rb_define_method(ChmDecom, "extract_to_path", chmd_extract_to_path, 2);
+  rb_define_method(ChmDecom, "extract_to_path", chmd_extract_to_path, -1);
   rb_define_method(ChmDecom, "last_error", chmd_last_error, 0);
   rb_define_method(ChmDecom, "fast_open", chmd_fast_open, 1);
   rb_define_method(ChmDecom, "fast_find", chmd_fast_find, 2);

data/ext/mspack_native/chm_decompressor_file.c

@@ -39,12 +39,19 @@ VALUE chmd_file_next(VALUE self) {
 
   struct chmd_file_wrapper *next_wrapper = 
     malloc(sizeof(struct chmd_file_wrapper));
+    
   next_wrapper->is_fast_find = 0;
   next_wrapper->file = next;
 
   return Data_Wrap_Struct(ChmDFile, NULL, chmd_file_free, next_wrapper);
 }
 
+VALUE chmd_file_length(VALUE self) {
+  struct chmd_file_wrapper *wrapper;
+  Data_Get_Struct(self, struct chmd_file_wrapper, wrapper);
+  return LONG2FIX(wrapper->file->length);
+}
+
 VALUE chmd_file_is_fast_find(VALUE self) {
   struct chmd_file_wrapper *wrapper;
   Data_Get_Struct(self, struct chmd_file_wrapper, wrapper);
@@ -55,5 +62,6 @@ void Init_chm_decompressor_file() {
   ChmDFile = rb_define_class_under(ChmDecom, "File", rb_cObject);
   rb_define_method(ChmDFile, "filename", chmd_file_filename, 0);
   rb_define_method(ChmDFile, "next", chmd_file_next, 0);
+  rb_define_method(ChmDFile, "length", chmd_file_length, 0);
   rb_define_method(ChmDFile, "fast_find?", chmd_file_is_fast_find, 0);
 }

data/ext/mspack_native/io_system.c

@@ -0,0 +1,176 @@
+#include "io_system.h"
+#include "chm_decompressor.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <string.h>
+
+#define IO_SYSTEM_MAX_BLOCKS 5
+
+union io_file_value {
+  FILE *file;
+  VALUE *block;
+};
+
+struct io_file {
+  char *name; // only used for block handle
+  union io_file_value value;
+};
+
+struct io_file *blocks[IO_SYSTEM_MAX_BLOCKS];
+
+inline struct io_file *pop_block(const char *name) {
+  for (int i = 0; i < IO_SYSTEM_MAX_BLOCKS - 1; ++i) {
+    struct io_file *block = blocks[i];
+
+    if (block) {
+      if (strcmp(name, block->name) == 0) {
+        blocks[i] = NULL;
+        return block;
+      }
+    }
+  }
+
+  return NULL;
+}
+
+struct mspack_file *
+io_open(struct mspack_system *self, const char *filename, int mode) {
+  struct io_file *block = NULL;
+
+  if (mode != MSPACK_SYS_OPEN_READ) {
+    block = pop_block(filename);
+  }
+
+  if (block) {
+    return (struct mspack_file *)block;
+  }
+  else {
+    const char *modeStr;
+
+    switch (mode) {
+    case MSPACK_SYS_OPEN_READ:
+      modeStr = "r";
+      break;
+    case MSPACK_SYS_OPEN_WRITE:
+      modeStr = "w";
+      break;
+    case MSPACK_SYS_OPEN_UPDATE:
+      modeStr = "w+";
+      break;
+    case MSPACK_SYS_OPEN_APPEND:
+      modeStr = "a+";
+      break;
+    default:
+      return NULL;
+    }
+
+    struct io_file *file = malloc(sizeof(struct io_file));
+    file->value.file = fopen(filename, modeStr);
+    file->name = NULL;
+
+    if (file->value.file) {
+      return (struct mspack_file *)file;
+    }
+    else {
+      free(file);
+      return NULL;
+    }
+  }
+}
+
+void io_close(struct mspack_file *file) {
+  if (!((struct io_file *)file)->name) {
+    fclose(((struct io_file *)file)->value.file);
+  }
+  else {
+    free(((struct io_file *)file)->name);
+  }
+
+  free(file);
+}
+
+int io_read(struct mspack_file *file, void *buffer, int bytes) {
+  return (int)fread(buffer, 1, bytes, ((struct io_file *)file)->value.file);
+}
+
+int io_write(struct mspack_file *file, void *buffer, int bytes) {
+  if (!((struct io_file *)file)->name) {
+    return (int)fwrite(buffer, 1, bytes, ((struct io_file *)file)->value.file);
+  }
+  else {
+    VALUE fixnum;
+    int *intBuffer = buffer;
+    VALUE data = rb_ary_new2(bytes);
+
+    for (int i = 0; i < bytes; ++i) {
+      fixnum = LONG2FIX(intBuffer[i]);
+      rb_ary_push(data, fixnum);
+    }
+
+    VALUE *block;
+    block = ((struct io_file *)file)->value.block;
+    rb_funcall(*block, rb_intern("yield"), 1, data);
+    return bytes;
+  }
+}
+
+int io_seek(struct mspack_file *file, off_t offset, int mode) {
+  return fseek(((struct io_file *)file)->value.file, offset, mode);
+}
+
+off_t io_tell(struct mspack_file *file) {
+  return ftell(((struct io_file *)file)->value.file);
+}
+
+void io_message(struct mspack_file *file, const char *format, ...) {
+  va_list args;
+  va_start(args, format);
+  vprintf(format, args);
+  va_end(args);
+}
+
+void *io_alloc(struct mspack_system *self, size_t bytes) {
+  return malloc(bytes);
+}
+
+void io_free(void *ptr) {
+  free(ptr);
+}
+
+void io_copy(void *src, void *dest, size_t bytes) {
+  memcpy(dest, src, bytes);
+}
+
+struct mspack_system *io_system() {
+  struct mspack_system *system = malloc(sizeof(struct mspack_system));
+  system->open = io_open;
+  system->close = io_close;
+  system->read = io_read;
+  system->write = io_write;
+  system->seek = io_seek;
+  system->tell = io_tell;
+  system->message = io_message;
+  system->alloc = io_alloc;
+  system->free = io_free;
+  system->copy = io_copy;
+  system->null_ptr = NULL;
+  return system;
+}
+
+// TODO: chuck an error if we're full
+void add_block(VALUE *name, VALUE *block) {
+  for (int i = 0; i < IO_SYSTEM_MAX_BLOCKS - 1; ++i) {
+
+    if (!blocks[i]) {
+      struct io_file *file = malloc(sizeof(struct io_file));
+      file->value.block = block;
+
+      const char *nameStr = StringValueCStr(*name);
+      file->name = malloc(sizeof(char) * strlen(nameStr) + 1);
+      strcpy(file->name, nameStr);
+
+      blocks[i] = file;
+    }
+  }
+}

data/ext/mspack_native/io_system.h

@@ -0,0 +1,33 @@
+#ifndef IO_SYSTEM_H
+#define IO_SYSTEM_H
+
+#include <mspack.h>
+#include <ruby.h>
+
+struct mspack_file *
+io_open(struct mspack_system *self, const char *filename, int mode);
+
+void io_close(struct mspack_file *file);
+
+int io_read(struct mspack_file *file, void *buffer, int bytes);
+
+int io_write(struct mspack_file *file, void *buffer, int bytes);
+
+int io_seek(struct mspack_file *file, off_t offset, int mode);
+
+off_t io_tell(struct mspack_file *file);
+
+void io_message(struct mspack_file *file, const char *format, ...);
+
+void *io_alloc(struct mspack_system *self, size_t bytes);
+
+void io_free(void *ptr);
+
+void io_copy(void *src, void *dest, size_t bytes);
+
+
+struct mspack_system *io_system();
+
+void add_block(VALUE *name, VALUE *block);
+
+#endif

data/lib/mspack/version.rb

@@ -1,3 +1,3 @@
 module Mspack
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mspack_rb
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.2.0
 platform: ruby
 authors:
 - Ben Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-21 00:00:00.000000000 Z
+date: 2017-03-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,6 +118,8 @@ files:
 - ext/mspack_native/chm_decompressor_header.c
 - ext/mspack_native/chm_decompressor_header.h
 - ext/mspack_native/extconf.rb
+- ext/mspack_native/io_system.c
+- ext/mspack_native/io_system.h
 - ext/mspack_native/mspack_native.c
 - ext/mspack_native/mspack_native.h
 - lib/mspack.rb