htslib 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44b02c34b18d412043b9063ef1d8da5f9f9f88bd4bdfcf7c8537e0a1dbcebe14
-  data.tar.gz: cc76ea23d6fa215755a9c0ccaab3de11e5e2465b877e3481565b9586d9a730d8
+  metadata.gz: eb6716391f6e8aa27cb4859140deb80073a7b02e149f17704a4b08e125567cb9
+  data.tar.gz: 20ec9fc316dd378bd869d590360fc8d50a9b2be075871e76a1b4148292614cf6
 SHA512:
-  metadata.gz: 726b1885741d8091cac5810a1522523cdc2dda959f244fe00a34a02a12ef73b6cfa5b1f5982538a4ca18bfb0b94e5d9e3ec30699ab2f4cd33f6206e68d01061b
-  data.tar.gz: 47055c773ce723e100e775528d77db8e6755f2f0b167f0d20037c461009453f3979260f010bb54a9e177a1a51ffa624dea7bda3d9ad04f8efd441b5d13d58c07
+  metadata.gz: ed55104f781970f32e5918d15fbe2d0cf5c08e01524c29cf95656b6da902a1528f7630152ae8eb9adee815442230e74868707d348bc7947a871b9576d44bcf0d
+  data.tar.gz: c21d82a89b123e25e135486844d09ba83734fb1149269a158b1f2b81be94708ba3e55f95ee94d3a54e78b40a40db7ebcc71fdce969ecc16950802f84bee79461

data/README.md

@@ -122,12 +122,12 @@ bcf = HTS::Bcf.open("test/fixtures/test.bcf")
 
 bcf.each do |r|
   p chrom:  r.chrom,
-    pos:    r.pos,
+    pos:    r.pos + 1, # VCF POS is 1-based; Record#pos is 0-based.
     id:     r.id,
     qual:   r.qual.round(2),
     ref:    r.ref,
     alt:    r.alt,
-    filter: r.filter,
+    filters: r.filter,
     info:   r.info.to_h,
     format: r.format.to_h
 end
@@ -157,6 +157,7 @@ fa.close
 
 ```ruby
 tb = HTS::Tabix.open("test/fixtures/test.vcf.gz")
+# Numeric coordinates are 0-based, half-open: [2000, 3000).
 tb.query("poo", 2000, 3000) do |line|
   puts line.join("\t")
 end
@@ -191,7 +192,8 @@ silently returning overwritten data. `genotype_strings`, `get`, and `[]` remain
 the allocating convenience APIs. Use `unpack: :site_only` when FORMAT columns
 are not needed.
 
-Tabix likewise separates raw and materialized access:
+Tabix likewise lets callers avoid splitting unused columns. All yielded Ruby
+strings and arrays below are owning values:
 
 ```ruby
 tb.each_line("chr1:1-1000") { |line| }

data/TUTORIAL.md

@@ -331,12 +331,12 @@ bcf = HTS::Bcf.open("b.bcf")
 
 bcf.each do |r|
   p chrom:  r.chrom,
-    pos:    r.pos,
+    pos:    r.pos + 1, # VCF POS is 1-based; Record#pos is 0-based.
     id:     r.id,
     qual:   r.qual.round(2),
     ref:    r.ref,
     alt:    r.alt,
-    filter: r.filter,
+    filters: r.filter,
     info:   r.info.to_h,
     format: r.format.to_h
 end

data/ext/htslib_native/native_bam.c

@@ -242,21 +242,25 @@ static VALUE native_record_replace(VALUE self, VALUE qname, VALUE flag, VALUE ti
     bam1_t *record = get_record(self)->pointer;
     long cigar_count, i;
     uint32_t *cigar = NULL;
+    VALUE cigar_storage = 0;
     const char *quality_data = NULL;
     int result;
 
     StringValue(qname);
     StringValue(sequence);
+    if (memchr(RSTRING_PTR(qname), '\0', RSTRING_LEN(qname))) {
+        rb_raise(rb_eArgError, "qname must not contain NUL bytes");
+    }
     Check_Type(cigar_value, T_ARRAY);
     cigar_count = RARRAY_LEN(cigar_value);
     if (cigar_count > 0) {
-        cigar = ALLOC_N(uint32_t, cigar_count);
+        cigar = ALLOCV_N(uint32_t, cigar_storage, cigar_count);
         for (i = 0; i < cigar_count; i++) cigar[i] = NUM2UINT(rb_ary_entry(cigar_value, i));
     }
     if (!NIL_P(qualities)) {
         StringValue(qualities);
         if (RSTRING_LEN(qualities) != RSTRING_LEN(sequence)) {
-            if (cigar) xfree(cigar);
+            ALLOCV_END(cigar_storage);
             rb_raise(rb_eArgError, "qualities length must match sequence length");
         }
         quality_data = RSTRING_PTR(qualities);
@@ -264,12 +268,12 @@ static VALUE native_record_replace(VALUE self, VALUE qname, VALUE flag, VALUE ti
 
     errno = 0;
     result = bam_set1(record,
-                      (size_t)RSTRING_LEN(qname) + 1, RSTRING_PTR(qname),
+                      (size_t)RSTRING_LEN(qname), RSTRING_PTR(qname),
                       NUM2UINT(flag), NUM2INT(tid), NUM2LL(pos), NUM2UINT(mapq),
                       (size_t)cigar_count, cigar,
                       NUM2INT(mtid), NUM2LL(mpos), NUM2LL(isize),
                       (size_t)RSTRING_LEN(sequence), RSTRING_PTR(sequence), quality_data, 0);
-    if (cigar) xfree(cigar);
+    ALLOCV_END(cigar_storage);
     if (result < 0) {
         if (errno) rb_sys_fail("bam_set1");
         rb_raise(rb_eRuntimeError, "bam_set1 failed: %d", result);
@@ -282,6 +286,9 @@ static VALUE native_record_set_qname(VALUE self, VALUE name) {
     if (result < 0) rb_raise(rb_eRuntimeError, "bam_set_qname failed: %d", result);
     return name;
 }
+static void native_record_update_bin(bam1_t *record) {
+    record->core.bin = hts_reg2bin(record->core.pos, bam_endpos(record), 14, 5);
+}
 static VALUE native_record_core_get(VALUE self, VALUE field) {
     bam1_core_t *core = &get_record(self)->pointer->core;
     ID id = SYM2ID(field);
@@ -297,7 +304,8 @@ static VALUE native_record_core_get(VALUE self, VALUE field) {
     rb_raise(rb_eArgError, "unknown BAM core field");
 }
 static VALUE native_record_core_set(VALUE self, VALUE field, VALUE new_value) {
-    bam1_core_t *core = &get_record(self)->pointer->core;
+    bam1_t *record = get_record(self)->pointer;
+    bam1_core_t *core = &record->core;
     ID id = SYM2ID(field);
     if (id == rb_intern("tid")) core->tid = NUM2INT(new_value);
     else if (id == rb_intern("mtid")) core->mtid = NUM2INT(new_value);
@@ -308,6 +316,7 @@ static VALUE native_record_core_set(VALUE self, VALUE field, VALUE new_value) {
     else if (id == rb_intern("mapq")) core->qual = NUM2UINT(new_value);
     else if (id == rb_intern("flag")) core->flag = NUM2UINT(new_value);
     else rb_raise(rb_eArgError, "unknown or read-only BAM core field");
+    if (id == rb_intern("pos") || id == rb_intern("flag")) native_record_update_bin(record);
     return new_value;
 }
 static VALUE native_record_endpos(VALUE self) { return LL2NUM(bam_endpos(get_record(self)->pointer)); }
@@ -320,8 +329,10 @@ static VALUE native_record_cigar_values(VALUE self) {
     return result;
 }
 static VALUE native_record_set_cigar(VALUE self, VALUE text) {
-    int result = bam_parse_cigar(StringValueCStr(text), NULL, get_record(self)->pointer);
+    bam1_t *record = get_record(self)->pointer;
+    int result = bam_parse_cigar(StringValueCStr(text), NULL, record);
     if (result < 0) rb_raise(rb_eRuntimeError, "bam_parse_cigar failed: %d", result);
+    native_record_update_bin(record);
     return text;
 }
 static VALUE native_record_qlen(VALUE self) {
@@ -390,31 +401,47 @@ static VALUE native_record_to_s(VALUE self, VALUE header_value) {
     free(string.s);
     return value;
 }
+typedef struct { uint32_t *cigar; long count; } cigar_result_t;
+static VALUE native_cigar_result_to_array(VALUE data) {
+    cigar_result_t *result = (cigar_result_t *)(uintptr_t)data;
+    VALUE array = rb_ary_new_capa(result->count);
+    long i;
+    for (i = 0; i < result->count; i++) rb_ary_push(array, UINT2NUM(result->cigar[i]));
+    return array;
+}
+static VALUE native_cigar_result_free(VALUE data) {
+    cigar_result_t *result = (cigar_result_t *)(uintptr_t)data;
+    free(result->cigar);
+    result->cigar = NULL;
+    return Qnil;
+}
 static VALUE native_cigar_parse(VALUE klass, VALUE text) {
     uint32_t *cigar = NULL;
     size_t capacity = 0;
-    long result = sam_parse_cigar(StringValueCStr(text), NULL, &cigar, &capacity), i;
-    VALUE array;
+    long result = sam_parse_cigar(StringValueCStr(text), NULL, &cigar, &capacity);
+    cigar_result_t parsed;
     if (result < 0) { free(cigar); rb_raise(rb_eRuntimeError, "sam_parse_cigar failed: %ld", result); }
-    array = rb_ary_new_capa(result);
-    for (i = 0; i < result; i++) rb_ary_push(array, UINT2NUM(cigar[i]));
-    free(cigar);
-    return array;
+    parsed.cigar = cigar;
+    parsed.count = result;
+    return rb_ensure(native_cigar_result_to_array, (VALUE)(uintptr_t)&parsed,
+                     native_cigar_result_free, (VALUE)(uintptr_t)&parsed);
 }
 static VALUE native_cigar_qlen(VALUE klass, VALUE array) {
     long count = RARRAY_LEN(array), i;
-    uint32_t *values = ALLOC_N(uint32_t, count ? count : 1);
+    VALUE storage = 0;
+    uint32_t *values = ALLOCV_N(uint32_t, storage, count ? count : 1);
     for (i = 0; i < count; i++) values[i] = NUM2UINT(rb_ary_entry(array, i));
     hts_pos_t result = bam_cigar2qlen(count, values);
-    xfree(values);
+    ALLOCV_END(storage);
     return LL2NUM(result);
 }
 static VALUE native_cigar_rlen(VALUE klass, VALUE array) {
     long count = RARRAY_LEN(array), i;
-    uint32_t *values = ALLOC_N(uint32_t, count ? count : 1);
+    VALUE storage = 0;
+    uint32_t *values = ALLOCV_N(uint32_t, storage, count ? count : 1);
     for (i = 0; i < count; i++) values[i] = NUM2UINT(rb_ary_entry(array, i));
     hts_pos_t result = bam_cigar2rlen(count, values);
-    xfree(values);
+    ALLOCV_END(storage);
     return LL2NUM(result);
 }
 
@@ -484,9 +511,10 @@ static VALUE native_record_aux_update_array(VALUE self, VALUE key, VALUE type_va
     long count = RARRAY_LEN(array), i;
     size_t width;
     uint8_t *buffer;
+    VALUE buffer_storage = 0;
     int result;
     switch (type) { case 'c': case 'C': width = 1; break; case 's': case 'S': width = 2; break; default: width = 4; }
-    buffer = ALLOC_N(uint8_t, count * width + 1);
+    buffer = ALLOCV_N(uint8_t, buffer_storage, count * width + 1);
     for (i = 0; i < count; i++) {
         VALUE item = rb_ary_entry(array, i);
         if (type == 'c') { int8_t v = NUM2INT(item); memcpy(buffer + i, &v, 1); }
@@ -496,10 +524,10 @@ static VALUE native_record_aux_update_array(VALUE self, VALUE key, VALUE type_va
         else if (type == 'i') { int32_t v = NUM2INT(item); memcpy(buffer + i * 4, &v, 4); }
         else if (type == 'I') { uint32_t v = NUM2UINT(item); memcpy(buffer + i * 4, &v, 4); }
         else if (type == 'f') { float v = (float)NUM2DBL(item); memcpy(buffer + i * 4, &v, 4); }
-        else { xfree(buffer); rb_raise(rb_eArgError, "invalid AUX array type"); }
+        else { ALLOCV_END(buffer_storage); rb_raise(rb_eArgError, "invalid AUX array type"); }
     }
     result = bam_aux_update_array(get_record(self)->pointer, StringValueCStr(key), type, count, buffer);
-    xfree(buffer);
+    ALLOCV_END(buffer_storage);
     return INT2NUM(result);
 }
 static VALUE native_record_aux_delete(VALUE self, VALUE key) {
@@ -514,6 +542,13 @@ static VALUE native_record_aux_key(VALUE self, VALUE key) {
 }
 
 /* File and iterator */
+static void raise_bam_open_error(VALUE path_value, int error) {
+    if (error) rb_syserr_fail_str(error, path_value);
+    VALUE hts=rb_const_get(rb_cObject,rb_intern("HTS"));
+    VALUE bam=rb_const_get(hts,rb_intern("Bam"));
+    VALUE klass=rb_const_get(bam,rb_intern("OpenError"));
+    rb_raise(klass,"Failed to open %"PRIsVALUE": HTSlib could not recognize or open the input",path_value);
+}
 static VALUE native_bam_open(VALUE klass, VALUE path_value, VALUE mode_value) {
     ruby_bam_file_t *value;
     VALUE object = TypedData_Make_Struct(klass, ruby_bam_file_t, &bam_file_type, value);
@@ -521,16 +556,18 @@ static VALUE native_bam_open(VALUE klass, VALUE path_value, VALUE mode_value) {
     value->active_io = 0;
     value->path = rb_str_dup(StringValue(path_value));
     RB_OBJ_WRITE(object, &value->path, value->path);
+    errno = 0;
     value->file = hts_open(StringValueCStr(value->path), StringValueCStr(mode_value));
-    if (!value->file) rb_syserr_fail_str(ENOENT, path_value);
+    if (!value->file) raise_bam_open_error(path_value, errno);
     return object;
 }
 static VALUE native_bam_close(VALUE self) {
     ruby_bam_file_t *value = get_file(self, 1);
+    int result = 0;
     if (value->active_io) rb_raise(rb_eIOError, "cannot close BAM during active I/O");
     if (value->index) { hts_idx_destroy(value->index); value->index = NULL; }
-    if (value->file) { hts_close(value->file); value->file = NULL; }
-    return Qnil;
+    if (value->file) { result = hts_close(value->file); value->file = NULL; }
+    return INT2NUM(result);
 }
 static VALUE native_bam_closed(VALUE self) { return get_file(self, 1)->file ? Qfalse : Qtrue; }
 typedef struct { htsFile *file; sam_hdr_t *header; bam1_t *record; hts_itr_t *iterator; int result; } bam_io_args_t;
@@ -541,22 +578,29 @@ static void *bam_read_without_gvl(void *data) { bam_io_args_t *args=data; args->
 static void *bam_write_without_gvl(void *data) { bam_io_args_t *args=data; args->result=sam_write1(args->file,args->header,args->record); return NULL; }
 static void *bam_iterator_without_gvl(void *data) { bam_io_args_t *args=data; args->result=sam_itr_next(args->file,args->iterator,args->record); return NULL; }
 static void bam_io_begin(ruby_bam_file_t *file) { if(file->active_io)rb_raise(rb_eIOError,"concurrent BAM I/O is not supported"); file->active_io=1; }
+typedef struct { ruby_bam_file_t *file; void *(*operation)(void *); void *arguments; } bam_io_call_t;
+static VALUE bam_io_call_without_gvl(VALUE data) { bam_io_call_t *call=(bam_io_call_t *)(uintptr_t)data;rb_thread_call_without_gvl(call->operation,call->arguments,RUBY_UBF_IO,NULL);return Qnil; }
+static VALUE bam_io_end(VALUE data) { bam_io_call_t *call=(bam_io_call_t *)(uintptr_t)data;call->file->active_io=0;return Qnil; }
+/* Async Ruby exceptions are delivered after the native operation regains the GVL.
+ * rb_ensure therefore keeps active_io and the stack-backed arguments valid until
+ * the HTSlib call has returned or its RUBY_UBF_IO cancellation has completed. */
+static void bam_io_run(ruby_bam_file_t *file,void *(*operation)(void *),void *arguments) { bam_io_call_t call={file,operation,arguments};bam_io_begin(file);rb_ensure(bam_io_call_without_gvl,(VALUE)(uintptr_t)&call,bam_io_end,(VALUE)(uintptr_t)&call); }
 static VALUE native_bam_read_header(VALUE self) {
     ruby_bam_file_t *file=get_file(self,0); bam_header_read_args_t args={file->file,NULL};
-    bam_io_begin(file); rb_thread_call_without_gvl(bam_read_header_without_gvl,&args,RUBY_UBF_IO,NULL); file->active_io=0;
+    bam_io_run(file,bam_read_header_without_gvl,&args);
     return wrap_header(args.result);
 }
 static VALUE native_bam_write_header(VALUE self, VALUE header) {
     ruby_bam_file_t *file=get_file(self,0); bam_io_args_t args={file->file,get_header(header)->pointer,NULL,NULL,0};
-    bam_io_begin(file); rb_thread_call_without_gvl(bam_write_header_without_gvl,&args,RUBY_UBF_IO,NULL); file->active_io=0; return INT2NUM(args.result);
+    bam_io_run(file,bam_write_header_without_gvl,&args); return INT2NUM(args.result);
 }
 static VALUE native_bam_read(VALUE self, VALUE header, VALUE record) {
     ruby_bam_file_t *file=get_file(self,0); bam_io_args_t args={file->file,get_header(header)->pointer,get_record(record)->pointer,NULL,0};
-    bam_io_begin(file); rb_thread_call_without_gvl(bam_read_without_gvl,&args,RUBY_UBF_IO,NULL); file->active_io=0; return INT2NUM(args.result);
+    bam_io_run(file,bam_read_without_gvl,&args); return INT2NUM(args.result);
 }
 static VALUE native_bam_write(VALUE self, VALUE header, VALUE record) {
     ruby_bam_file_t *file=get_file(self,0); bam_io_args_t args={file->file,get_header(header)->pointer,get_record(record)->pointer,NULL,0};
-    bam_io_begin(file); rb_thread_call_without_gvl(bam_write_without_gvl,&args,RUBY_UBF_IO,NULL); file->active_io=0; return INT2NUM(args.result);
+    bam_io_run(file,bam_write_without_gvl,&args); return INT2NUM(args.result);
 }
 static VALUE native_bam_set_fai(VALUE self, VALUE path) {
     return INT2NUM(hts_set_fai_filename(get_file(self, 0)->file, StringValueCStr(path)));
@@ -622,9 +666,7 @@ static VALUE native_bam_iterator_next(VALUE self, VALUE record) {
     ruby_bam_iterator_t *iterator = get_iterator(self);
     ruby_bam_file_t *file = get_file(iterator->file, 0);
     bam_io_args_t args={file->file,NULL,get_record(record)->pointer,iterator->iterator,0};
-    bam_io_begin(file);
-    rb_thread_call_without_gvl(bam_iterator_without_gvl,&args,RUBY_UBF_IO,NULL);
-    file->active_io=0;
+    bam_io_run(file,bam_iterator_without_gvl,&args);
     return INT2NUM(args.result);
 }
 static VALUE native_bam_iterator_close(VALUE self) {
@@ -697,24 +739,37 @@ static VALUE base_mod_array(const hts_base_mod *mods, int count) {
     }
     return result;
 }
+static void raise_base_mod_error(const char *operation) {
+    VALUE hts = rb_const_get(rb_cObject, rb_intern("HTS"));
+    VALUE bam = rb_const_get(hts, rb_intern("Bam"));
+    VALUE base_mod = rb_const_get(bam, rb_intern("BaseMod"));
+    VALUE error = rb_const_get(base_mod, rb_intern("Error"));
+    rb_raise(error, "%s failed", operation);
+}
 static VALUE native_base_mod_at(VALUE self, VALUE position, VALUE max_value) {
     ruby_base_mod_t *value = get_base_mod(self);
     int max = NUM2INT(max_value), count;
     hts_base_mod *mods;
+    VALUE mods_storage = 0;
     if (max <= 0) rb_raise(rb_eArgError, "max_mods must be positive");
-    mods = ALLOC_N(hts_base_mod, max);
+    mods = ALLOCV_N(hts_base_mod, mods_storage, max);
     count = bam_mods_at_qpos(get_record(value->record)->pointer, NUM2INT(position), value->state, mods, max);
+    if (count < 0) {
+        ALLOCV_END(mods_storage);
+        raise_base_mod_error("bam_mods_at_qpos");
+    }
     VALUE result = count > 0 ? base_mod_array(mods, count < max ? count : max) : Qnil;
-    xfree(mods);
+    ALLOCV_END(mods_storage);
     return result;
 }
 static VALUE native_base_mod_each_raw(VALUE self, VALUE max_value) {
     ruby_base_mod_t *value = get_base_mod(self);
     int max = NUM2INT(max_value), count, position, index;
     hts_base_mod *mods;
+    VALUE mods_storage = 0;
     if (!rb_block_given_p()) rb_raise(rb_eArgError, "block is required");
     if (max <= 0) rb_raise(rb_eArgError, "max_mods must be positive");
-    mods = ALLOC_N(hts_base_mod, max);
+    mods = ALLOCV_N(hts_base_mod, mods_storage, max);
     while ((count = bam_next_basemod(get_record(value->record)->pointer, value->state, mods, max, &position)) > 0) {
         if (count > max) count = max;
         for (index = 0; index < count; index++) {
@@ -723,7 +778,11 @@ static VALUE native_base_mod_each_raw(VALUE self, VALUE max_value) {
                             INT2NUM(mods[index].qual));
         }
     }
-    xfree(mods);
+    if (count < 0) {
+        ALLOCV_END(mods_storage);
+        raise_base_mod_error("bam_next_basemod");
+    }
+    ALLOCV_END(mods_storage);
     return self;
 }
 static VALUE native_base_mod_types(VALUE self) {

data/ext/htslib_native/native_bcf.c

@@ -128,7 +128,25 @@ static VALUE wrap_bcf_iterator(VALUE file,VALUE header,hts_itr_t *iterator,int t
 static VALUE native_bcf_header_create(VALUE klass) { return wrap_bcf_header(bcf_hdr_init("w")); }
 static VALUE native_bcf_header_duplicate(VALUE self) { return wrap_bcf_header(bcf_hdr_dup(get_bcf_header(self)->pointer)); }
 static VALUE native_bcf_header_version(VALUE self) { const char *v=bcf_hdr_get_version(get_bcf_header(self)->pointer); return v?rb_str_new_cstr(v):Qnil; }
-static VALUE native_bcf_header_set_version(VALUE self,VALUE value) { return INT2NUM(bcf_hdr_set_version(get_bcf_header(self)->pointer,StringValueCStr(value))); }
+static VALUE native_bcf_header_set_version(VALUE self,VALUE value) {
+    bcf_hdr_t *header=get_bcf_header(self)->pointer;
+    const char *version=StringValueCStr(value);
+#if !defined(HTS_VERSION) || HTS_VERSION < 102200
+    /* HTSlib before 1.22 failed to restore the generic-header hash value in
+       bcf_hdr_update_hrec(), so calling bcf_hdr_set_version() twice aborted.
+       Updating the public header record directly avoids that upstream bug. */
+    bcf_hrec_t *record=bcf_hdr_get_hrec(header,BCF_HL_GEN,"fileformat",NULL,NULL);
+    if(record) {
+        char *copy=strdup(version);
+        if(!copy) rb_memerror();
+        free(record->value);
+        record->value=copy;
+        header->dirty=1;
+        return INT2NUM(0);
+    }
+#endif
+    return INT2NUM(bcf_hdr_set_version(header,version));
+}
 static VALUE native_bcf_header_read_file(VALUE self,VALUE path) { return INT2NUM(bcf_hdr_set(get_bcf_header(self)->pointer,StringValueCStr(path))); }
 static VALUE native_bcf_header_nsamples(VALUE self) { return INT2NUM(bcf_hdr_nsamples(get_bcf_header(self)->pointer)); }
 static VALUE native_bcf_header_samples(VALUE self) {
@@ -189,11 +207,12 @@ static VALUE native_bcf_header_schema(VALUE self,VALUE kind_value,VALUE key_valu
     rb_ary_push(result,INT2NUM(bcf_hdr_id2number(h,kind,id))); rb_ary_push(result,INT2NUM(id)); return result;
 }
 static VALUE native_bcf_header_subset(VALUE self,VALUE samples) {
-    bcf_hdr_t *h=get_bcf_header(self)->pointer,*subset; int count=RARRAY_LEN(samples),i; char **names=NULL; int *imap=NULL; VALUE map;
-    if(count>0) { names=ALLOC_N(char*,count); imap=ALLOC_N(int,count); for(i=0;i<count;i++) { VALUE sample=rb_ary_entry(samples,i); names[i]=StringValueCStr(sample); } }
-    subset=bcf_hdr_subset(h,count,names,imap); xfree(names); if(!subset){xfree(imap);return Qnil;}
-    map=rb_ary_new_capa(count); for(i=0;i<count;i++)rb_ary_push(map,INT2NUM(imap[i])); xfree(imap);
-    return rb_ary_new_from_args(2,wrap_bcf_header(subset),map);
+    bcf_hdr_t *h=get_bcf_header(self)->pointer,*subset; int count=RARRAY_LEN(samples),i; char **names=NULL; int *imap=NULL; VALUE map,names_storage=0,imap_storage=0;
+    if(count>0) { names=ALLOCV_N(char*,names_storage,count); imap=ALLOCV_N(int,imap_storage,count); for(i=0;i<count;i++) { VALUE sample=rb_ary_entry(samples,i); names[i]=StringValueCStr(sample); } }
+    subset=bcf_hdr_subset(h,count,names,imap); ALLOCV_END(names_storage); if(!subset){ALLOCV_END(imap_storage);return Qnil;}
+    VALUE subset_value=wrap_bcf_header(subset);
+    map=rb_ary_new_capa(count); for(i=0;i<count;i++)rb_ary_push(map,INT2NUM(imap[i])); ALLOCV_END(imap_storage);
+    return rb_ary_new_from_args(2,subset_value,map);
 }
 
 /* Header record */
@@ -204,6 +223,20 @@ static VALUE native_bcf_hrec_find_key(VALUE self,VALUE key) { return INT2NUM(bcf
 static VALUE native_bcf_hrec_to_s(VALUE self) { kstring_t s=KS_INITIALIZE; VALUE r; bcf_hrec_format(get_bcf_hrec(self)->pointer,&s); r=rb_str_new(s.s,s.l); free(s.s); return r; }
 
 /* Record core */
+static void raise_bcf_record_error(const char *message) {
+    VALUE hts=rb_const_get(rb_cObject,rb_intern("HTS"));
+    VALUE bcf=rb_const_get(hts,rb_intern("Bcf"));
+    VALUE error=rb_const_get(bcf,rb_intern("RecordError"));
+    rb_raise(error,"%s",message);
+}
+static void check_bcf_unpack(bcf1_t *record,int fields) {
+    if(bcf_unpack(record,fields)<0)raise_bcf_record_error("Failed to unpack BCF record");
+}
+static const char *checked_bcf_id(bcf_hdr_t *header,int id) {
+    const char *name=(id>=0 && id<header->n[BCF_DT_ID] && header->id[BCF_DT_ID])?bcf_hdr_int2id(header,BCF_DT_ID,id):NULL;
+    if(!name)raise_bcf_record_error("BCF record contains an ID that is absent from the supplied header");
+    return name;
+}
 static VALUE native_bcf_record_create(VALUE klass) { return wrap_bcf_record(bcf_init()); }
 static VALUE native_bcf_record_duplicate(VALUE self) { return wrap_bcf_record(bcf_dup(get_bcf_record(self)->pointer)); }
 static VALUE native_bcf_record_core_get(VALUE self,VALUE field) {
@@ -221,21 +254,21 @@ static VALUE native_bcf_record_core_set(VALUE self,VALUE field,VALUE value) {
     else rb_raise(rb_eArgError,"unknown BCF field");
     return value;
 }
-static VALUE native_bcf_record_id(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; bcf_unpack(r,BCF_UN_INFO); return rb_str_new_cstr(r->d.id); }
+static VALUE native_bcf_record_id(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; check_bcf_unpack(r,BCF_UN_STR); if(!r->d.id)raise_bcf_record_error("BCF record ID is missing after unpack"); return rb_str_new_cstr(r->d.id); }
 static VALUE native_bcf_record_set_id(VALUE self,VALUE header,VALUE id) { return INT2NUM(bcf_update_id(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,StringValueCStr(id))); }
-static VALUE native_bcf_record_alleles(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; int i; VALUE a; bcf_unpack(r,BCF_UN_STR); a=rb_ary_new_capa(r->n_allele); for(i=0;i<r->n_allele;i++)rb_ary_push(a,rb_str_new_cstr(r->d.allele[i])); return a; }
+static VALUE native_bcf_record_alleles(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; int i; VALUE a; check_bcf_unpack(r,BCF_UN_STR); a=rb_ary_new_capa(r->n_allele); for(i=0;i<r->n_allele;i++){if(!r->d.allele[i])raise_bcf_record_error("BCF allele is missing after unpack");rb_ary_push(a,rb_str_new_cstr(r->d.allele[i]));} return a; }
 static VALUE native_bcf_record_set_alleles(VALUE self,VALUE header,VALUE value) { return INT2NUM(bcf_update_alleles_str(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,StringValueCStr(value))); }
-static VALUE native_bcf_record_filter_ids(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; int i; VALUE a; bcf_unpack(r,BCF_UN_FLT); a=rb_ary_new_capa(r->d.n_flt); for(i=0;i<r->d.n_flt;i++)rb_ary_push(a,INT2NUM(r->d.flt[i])); return a; }
-static VALUE native_bcf_record_filter_names(VALUE self,VALUE header) { bcf1_t *r=get_bcf_record(self)->pointer; bcf_hdr_t *h=get_bcf_header(header)->pointer; int i; VALUE a; bcf_unpack(r,BCF_UN_FLT); a=rb_ary_new_capa(r->d.n_flt); for(i=0;i<r->d.n_flt;i++)rb_ary_push(a,rb_str_new_cstr(bcf_hdr_int2id(h,BCF_DT_ID,r->d.flt[i]))); return a; }
+static VALUE native_bcf_record_filter_ids(VALUE self) { bcf1_t *r=get_bcf_record(self)->pointer; int i; VALUE a; check_bcf_unpack(r,BCF_UN_FLT); a=rb_ary_new_capa(r->d.n_flt); for(i=0;i<r->d.n_flt;i++)rb_ary_push(a,INT2NUM(r->d.flt[i])); return a; }
+static VALUE native_bcf_record_filter_names(VALUE self,VALUE header) { bcf1_t *r=get_bcf_record(self)->pointer; bcf_hdr_t *h=get_bcf_header(header)->pointer; int i; VALUE a; check_bcf_unpack(r,BCF_UN_FLT); a=rb_ary_new_capa(r->d.n_flt); for(i=0;i<r->d.n_flt;i++)rb_ary_push(a,rb_str_new_cstr(checked_bcf_id(h,r->d.flt[i]))); return a; }
 static VALUE native_bcf_record_to_s(VALUE self,VALUE header) { kstring_t s=KS_INITIALIZE; VALUE v; if(vcf_format(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,&s)<0){free(s.s);rb_raise(rb_eRuntimeError,"failed to format BCF record");}v=rb_str_new(s.s,s.l);free(s.s);return v; }
 static VALUE native_bcf_record_set_unpack(VALUE self,VALUE level){get_bcf_record(self)->pointer->max_unpack=NUM2INT(level);return level;}
-static VALUE native_bcf_record_subset(VALUE self,VALUE header,VALUE map){int count=RARRAY_LEN(map),i,*imap=ALLOC_N(int,count?count:1);for(i=0;i<count;i++)imap[i]=NUM2INT(rb_ary_entry(map,i));int result=bcf_subset(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,count,imap);xfree(imap);return INT2NUM(result);}
+static VALUE native_bcf_record_subset(VALUE self,VALUE header,VALUE map){VALUE storage=0;int count=RARRAY_LEN(map),i,*imap=ALLOCV_N(int,storage,count?count:1);for(i=0;i<count;i++)imap[i]=NUM2INT(rb_ary_entry(map,i));int result=bcf_subset(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,count,imap);ALLOCV_END(storage);return INT2NUM(result);}
 
 static VALUE field_rows(bcf_hdr_t *h,bcf1_t *r,int format) {
-    int i,count; VALUE rows; if(format){bcf_unpack(r,BCF_UN_FMT);count=r->n_fmt;}else{bcf_unpack(r,BCF_UN_INFO);count=r->n_info;}
+    int i,count; VALUE rows; if(format){check_bcf_unpack(r,BCF_UN_FMT);count=r->n_fmt;}else{check_bcf_unpack(r,BCF_UN_INFO);count=r->n_info;}
     rows=rb_ary_new_capa(count);
     for(i=0;i<count;i++) { int id=format?r->d.fmt[i].id:r->d.info[i].key, kind=format?BCF_HL_FMT:BCF_HL_INFO; VALUE row=rb_hash_new();
-        rb_hash_aset(row,ID2SYM(rb_intern("name")),rb_str_new_cstr(bcf_hdr_int2id(h,BCF_DT_ID,id)));
+        rb_hash_aset(row,ID2SYM(rb_intern("name")),rb_str_new_cstr(checked_bcf_id(h,id)));
         rb_hash_aset(row,ID2SYM(rb_intern("n")),INT2NUM(bcf_hdr_id2number(h,kind,id)));
         rb_hash_aset(row,ID2SYM(rb_intern("type")),type_symbol(bcf_hdr_id2type(h,kind,id)));
         rb_hash_aset(row,ID2SYM(rb_intern(format?"id":"key")),INT2NUM(id)); rb_ary_push(rows,row); }
@@ -244,82 +277,120 @@ static VALUE field_rows(bcf_hdr_t *h,bcf1_t *r,int format) {
 static VALUE native_bcf_record_info_fields(VALUE self,VALUE header) { return field_rows(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,0); }
 static VALUE native_bcf_record_format_fields(VALUE self,VALUE header) { return field_rows(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,1); }
 
-static VALUE info_get(VALUE self,VALUE header_value,VALUE key_value,VALUE type_value) {
-    bcf_hdr_t *h=get_bcf_header(header_value)->pointer; bcf1_t *r=get_bcf_record(self)->pointer; int type=NUM2INT(type_value),cap=0,count,i; void *dst=NULL; VALUE value;
-    count=bcf_get_info_values(h,r,StringValueCStr(key_value),&dst,&cap,type);
-    if(count<0){free(dst);return Qnil;}
-    if(type==BCF_HT_FLAG){free(dst);return count==1?Qtrue:Qnil;}
-    if(type==BCF_HT_STR)value=rb_str_new_cstr((char*)dst);
-    else { value=rb_ary_new_capa(count); for(i=0;i<count;i++) {
-        if(type==BCF_HT_INT){
-            int32_t item=((int32_t*)dst)[i];
+typedef struct { void *dst; int count; int type; } bcf_value_result_t;
+static void raise_bcf_field_read_error(const char *kind,const char *key,int code) {
+    VALUE hts=rb_const_get(rb_cObject,rb_intern("HTS"));
+    VALUE bcf=rb_const_get(hts,rb_intern("Bcf"));
+    VALUE error=rb_const_get(bcf,rb_intern(kind));
+    const char *reason;
+    switch(code){case -1:reason="tag is not defined in the header";break;case -2:reason="stored type does not match the requested type";break;case -4:reason="native allocation failed";break;default:reason="native read failed";break;}
+    rb_raise(error,"Failed to read %s (HTSlib error %d: %s)",key,code,reason);
+}
+static VALUE bcf_value_result_free(VALUE data) {
+    bcf_value_result_t *result=(bcf_value_result_t *)(uintptr_t)data;
+    free(result->dst); result->dst=NULL; return Qnil;
+}
+static VALUE bcf_info_result_to_ruby(VALUE data) {
+    bcf_value_result_t *result=(bcf_value_result_t *)(uintptr_t)data; int i; VALUE value;
+    if(result->type==BCF_HT_STR)return rb_str_new_cstr((char*)result->dst);
+    value=rb_ary_new_capa(result->count); for(i=0;i<result->count;i++) {
+        if(result->type==BCF_HT_INT){
+            int32_t item=((int32_t*)result->dst)[i];
             if(item==bcf_int32_vector_end)break;
             rb_ary_push(value,item==bcf_int32_missing?Qnil:INT2NUM(item));
         }
-        else if(type==BCF_HT_LONG){
-            int64_t item=((int64_t*)dst)[i];
+        else if(result->type==BCF_HT_LONG){
+            int64_t item=((int64_t*)result->dst)[i];
             if(item==bcf_int64_vector_end)break;
             rb_ary_push(value,item==bcf_int64_missing?Qnil:LL2NUM(item));
         }
         else {
-            float item=((float*)dst)[i];
+            float item=((float*)result->dst)[i];
             if(bcf_float_is_vector_end(item))break;
             rb_ary_push(value,bcf_float_is_missing(item)?Qnil:DBL2NUM(item));
-        } } }
-    free(dst);return value;
+        }
+    }
+    return value;
+}
+static VALUE info_get(VALUE self,VALUE header_value,VALUE key_value,VALUE type_value) {
+    bcf_hdr_t *h=get_bcf_header(header_value)->pointer; bcf1_t *r=get_bcf_record(self)->pointer; int type=NUM2INT(type_value),cap=0,count; void *dst=NULL; bcf_value_result_t result;
+    count=bcf_get_info_values(h,r,StringValueCStr(key_value),&dst,&cap,type);
+    if(count<0){const char *key=StringValueCStr(key_value);free(dst);if(count==-3)return Qnil;raise_bcf_field_read_error("InfoReadError",key,count);}
+    if(type==BCF_HT_FLAG){free(dst);return count==1?Qtrue:Qnil;}
+    result.dst=dst;result.count=count;result.type=type;
+    return rb_ensure(bcf_info_result_to_ruby,(VALUE)(uintptr_t)&result,
+                     bcf_value_result_free,(VALUE)(uintptr_t)&result);
 }
 static VALUE native_bcf_info_get(VALUE self,VALUE header,VALUE key,VALUE type) { return info_get(self,header,key,type); }
 static VALUE native_bcf_info_present(VALUE self,VALUE header,VALUE key,VALUE type) { return NIL_P(info_get(self,header,key,type))?Qfalse:Qtrue; }
-static int fill_i32(VALUE array,int32_t **out) { int n=RARRAY_LEN(array),i; *out=ALLOC_N(int32_t,n?n:1);for(i=0;i<n;i++)(*out)[i]=NUM2INT(rb_ary_entry(array,i));return n; }
-static int fill_float(VALUE array,float **out) { int n=RARRAY_LEN(array),i; *out=ALLOC_N(float,n?n:1);for(i=0;i<n;i++)(*out)[i]=(float)NUM2DBL(rb_ary_entry(array,i));return n; }
 static VALUE native_bcf_info_update(VALUE self,VALUE header,VALUE key,VALUE type_value,VALUE values) {
-    bcf_hdr_t*h=get_bcf_header(header)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),n,result;void*data=NULL;
+    bcf_hdr_t*h=get_bcf_header(header)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),n,i,result;void*data=NULL;VALUE storage=0;
     if(type!=BCF_HT_FLAG && (NIL_P(values) || values==Qfalse)){
         return INT2NUM(bcf_update_info(h,r,StringValueCStr(key),NULL,0,type));
     }
-    if(type==BCF_HT_INT){int32_t*p;n=fill_i32(values,&p);data=p;result=bcf_update_info(h,r,StringValueCStr(key),data,n,type);xfree(p);}
-    else if(type==BCF_HT_REAL){float*p;n=fill_float(values,&p);data=p;result=bcf_update_info(h,r,StringValueCStr(key),data,n,type);xfree(p);}
+    if(type==BCF_HT_INT){int32_t*p;n=RARRAY_LEN(values);p=ALLOCV_N(int32_t,storage,n?n:1);for(i=0;i<n;i++)p[i]=NUM2INT(rb_ary_entry(values,i));data=p;result=bcf_update_info(h,r,StringValueCStr(key),data,n,type);ALLOCV_END(storage);}
+    else if(type==BCF_HT_REAL){float*p;n=RARRAY_LEN(values);p=ALLOCV_N(float,storage,n?n:1);for(i=0;i<n;i++)p[i]=(float)NUM2DBL(rb_ary_entry(values,i));data=p;result=bcf_update_info(h,r,StringValueCStr(key),data,n,type);ALLOCV_END(storage);}
     else if(type==BCF_HT_STR){result=bcf_update_info(h,r,StringValueCStr(key),StringValueCStr(values),1,type);}
     else { n=RTEST(values)?1:0; result=bcf_update_info(h,r,StringValueCStr(key),NULL,n,type); }
     return INT2NUM(result);
 }
 
+typedef struct { char **strings; int sample_count; } bcf_string_result_t;
+static VALUE bcf_string_result_free(VALUE data) {
+    bcf_string_result_t *result=(bcf_string_result_t *)(uintptr_t)data;
+    if(result->strings){if(result->sample_count>0)free(result->strings[0]);free(result->strings);result->strings=NULL;}
+    return Qnil;
+}
+static VALUE bcf_string_result_to_ruby(VALUE data) {
+    bcf_string_result_t *result=(bcf_string_result_t *)(uintptr_t)data; int i;
+    VALUE value=rb_ary_new_capa(result->sample_count);
+    for(i=0;i<result->sample_count;i++)rb_ary_push(value,rb_str_new_cstr(result->strings[i]));
+    return value;
+}
+typedef struct { void *dst; int count; int type; VALUE raw; } bcf_format_result_t;
+static VALUE bcf_format_result_to_ruby(VALUE data) {
+    bcf_format_result_t *result=(bcf_format_result_t *)(uintptr_t)data; int i; VALUE value=rb_ary_new_capa(result->count);
+    for(i=0;i<result->count;i++){if(result->type==BCF_HT_INT)rb_ary_push(value,INT2NUM(((int32_t*)result->dst)[i]));else {float f=((float*)result->dst)[i];uint32_t word;memcpy(&word,&f,4);if(RTEST(result->raw))rb_ary_push(value,UINT2NUM(word));else if(bcf_float_is_missing(f)||bcf_float_is_vector_end(f))rb_ary_push(value,Qnil);else rb_ary_push(value,DBL2NUM(f));}}
+    return value;
+}
 static VALUE native_bcf_format_get(VALUE self,VALUE header_value,VALUE key_value,VALUE type_value,VALUE raw_value) {
-    bcf_hdr_t*h=get_bcf_header(header_value)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),cap=0,count,i;void*dst=NULL;VALUE value;
+    bcf_hdr_t*h=get_bcf_header(header_value)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),cap=0,count;void*dst=NULL;
     if(type==BCF_HT_STR){
         char **strings=NULL;
         int sample_count=bcf_hdr_nsamples(h);
+        bcf_string_result_t result;
         count=bcf_get_format_string(h,r,StringValueCStr(key_value),&strings,&cap);
-        if(count<0){free(strings);return Qnil;}
-        value=rb_ary_new_capa(sample_count);
-        for(i=0;i<sample_count;i++)rb_ary_push(value,rb_str_new_cstr(strings[i]));
-        if(strings){if(sample_count>0)free(strings[0]);free(strings);}
-        return value;
+        if(count<0){const char *key=StringValueCStr(key_value);free(strings);if(count==-3)return Qnil;raise_bcf_field_read_error("FormatReadError",key,count);}
+        result.strings=strings;result.sample_count=sample_count;
+        return rb_ensure(bcf_string_result_to_ruby,(VALUE)(uintptr_t)&result,
+                         bcf_string_result_free,(VALUE)(uintptr_t)&result);
     }
-    count=bcf_get_format_values(h,r,StringValueCStr(key_value),&dst,&cap,type);if(count<0){free(dst);return Qnil;}value=rb_ary_new_capa(count);
-    for(i=0;i<count;i++){if(type==BCF_HT_INT)rb_ary_push(value,INT2NUM(((int32_t*)dst)[i]));else {float f=((float*)dst)[i];uint32_t word;memcpy(&word,&f,4);if(RTEST(raw_value))rb_ary_push(value,UINT2NUM(word));else if(bcf_float_is_missing(f)||bcf_float_is_vector_end(f))rb_ary_push(value,Qnil);else rb_ary_push(value,DBL2NUM(f));}}
-    free(dst);return value;
+    count=bcf_get_format_values(h,r,StringValueCStr(key_value),&dst,&cap,type);if(count<0){const char *key=StringValueCStr(key_value);free(dst);if(count==-3)return Qnil;raise_bcf_field_read_error("FormatReadError",key,count);}
+    bcf_format_result_t result={dst,count,type,raw_value};
+    return rb_ensure(bcf_format_result_to_ruby,(VALUE)(uintptr_t)&result,
+                     bcf_value_result_free,(VALUE)(uintptr_t)&result);
 }
 static VALUE native_bcf_format_update(VALUE self,VALUE header,VALUE key,VALUE type_value,VALUE values) {
-    bcf_hdr_t*h=get_bcf_header(header)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),n,result;
-    if(type==BCF_HT_INT){int32_t*p;n=fill_i32(values,&p);result=bcf_update_format_int32(h,r,StringValueCStr(key),p,n);xfree(p);}
-    else if(type==BCF_HT_REAL){float*p;n=fill_float(values,&p);result=bcf_update_format_float(h,r,StringValueCStr(key),p,n);xfree(p);}
-    else {int i;char**strings;n=RARRAY_LEN(values);strings=ALLOC_N(char*,n?n:1);for(i=0;i<n;i++){VALUE string=rb_ary_entry(values,i);strings[i]=StringValueCStr(string);}result=bcf_update_format_string(h,r,StringValueCStr(key),(const char**)strings,n);xfree(strings);}return INT2NUM(result);
+    bcf_hdr_t*h=get_bcf_header(header)->pointer;bcf1_t*r=get_bcf_record(self)->pointer;int type=NUM2INT(type_value),n,i,result;VALUE storage=0;
+    if(type==BCF_HT_INT){int32_t*p;n=RARRAY_LEN(values);p=ALLOCV_N(int32_t,storage,n?n:1);for(i=0;i<n;i++)p[i]=NUM2INT(rb_ary_entry(values,i));result=bcf_update_format_int32(h,r,StringValueCStr(key),p,n);ALLOCV_END(storage);}
+    else if(type==BCF_HT_REAL){float*p;n=RARRAY_LEN(values);p=ALLOCV_N(float,storage,n?n:1);for(i=0;i<n;i++)p[i]=(float)NUM2DBL(rb_ary_entry(values,i));result=bcf_update_format_float(h,r,StringValueCStr(key),p,n);ALLOCV_END(storage);}
+    else {int i;char**strings;n=RARRAY_LEN(values);strings=ALLOCV_N(char*,storage,n?n:1);for(i=0;i<n;i++){VALUE string=rb_ary_entry(values,i);strings[i]=StringValueCStr(string);}result=bcf_update_format_string(h,r,StringValueCStr(key),(const char**)strings,n);ALLOCV_END(storage);}return INT2NUM(result);
 }
 static VALUE native_bcf_format_update_float_words(VALUE self,VALUE header,VALUE key,VALUE values) {
     bcf_hdr_t *h=get_bcf_header(header)->pointer;
     bcf1_t *r=get_bcf_record(self)->pointer;
     int n=RARRAY_LEN(values),i,result;
-    float *floats=ALLOC_N(float,n?n:1);
+    VALUE storage=0;
+    float *floats=ALLOCV_N(float,storage,n?n:1);
     for(i=0;i<n;i++){
         uint32_t word=NUM2UINT(rb_ary_entry(values,i));
         memcpy(&floats[i],&word,sizeof(word));
     }
     result=bcf_update_format_float(h,r,StringValueCStr(key),floats,n);
-    xfree(floats);
+    ALLOCV_END(storage);
     return INT2NUM(result);
 }
-static VALUE native_bcf_genotype_update(VALUE self,VALUE header,VALUE values) {int32_t*p;int n=fill_i32(values,&p);int result=bcf_update_genotypes(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,p,n);xfree(p);return INT2NUM(result);}
+static VALUE native_bcf_genotype_update(VALUE self,VALUE header,VALUE values) {VALUE storage=0;int32_t*p;int n=RARRAY_LEN(values),i;p=ALLOCV_N(int32_t,storage,n?n:1);for(i=0;i<n;i++)p[i]=NUM2INT(rb_ary_entry(values,i));int result=bcf_update_genotypes(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,p,n);ALLOCV_END(storage);return INT2NUM(result);}
 static VALUE native_bcf_format_delete(VALUE self,VALUE header,VALUE key,VALUE type) {return INT2NUM(bcf_update_format(get_bcf_header(header)->pointer,get_bcf_record(self)->pointer,StringValueCStr(key),NULL,0,NUM2INT(type)));}
 
 /* File */
@@ -331,13 +402,20 @@ static void *bcf_write_header_without_gvl(void*data){bcf_io_args_t*a=data;a->res
 static void *bcf_write_without_gvl(void*data){bcf_io_args_t*a=data;a->result=bcf_write(a->file,a->header,a->record);return NULL;}
 static void *bcf_iterator_without_gvl(void*data){bcf_io_args_t*a=data;if(a->tabix){int n=tbx_itr_next(a->file,a->tabix,a->iterator,a->line);a->result=n<0?n:vcf_parse(a->line,a->header,a->record);}else a->result=bcf_itr_next(a->file,a->iterator,a->record);return NULL;}
 static void bcf_io_begin(ruby_bcf_file_t*v){if(v->active_io)rb_raise(rb_eIOError,"concurrent BCF I/O is not supported");v->active_io=1;}
-static VALUE native_bcf_file_open(VALUE klass,VALUE path,VALUE mode) {ruby_bcf_file_t*v;VALUE o=TypedData_Make_Struct(klass,ruby_bcf_file_t,&bcf_file_type,v);v->index=NULL;v->tabix=NULL;v->active_io=0;v->path=rb_str_dup(StringValue(path));RB_OBJ_WRITE(o,&v->path,v->path);v->file=hts_open(StringValueCStr(v->path),StringValueCStr(mode));if(!v->file)rb_syserr_fail_str(ENOENT,path);return o;}
-static VALUE native_bcf_file_close(VALUE self){ruby_bcf_file_t*v=get_bcf_file(self,1);if(v->active_io)rb_raise(rb_eIOError,"cannot close BCF during active I/O");if(v->index){hts_idx_destroy(v->index);v->index=NULL;}if(v->tabix){tbx_destroy(v->tabix);v->tabix=NULL;}if(v->file){hts_close(v->file);v->file=NULL;}return Qnil;}
+typedef struct {ruby_bcf_file_t*file;void*(*operation)(void*);void*arguments;} bcf_io_call_t;
+static VALUE bcf_io_call_without_gvl(VALUE data){bcf_io_call_t*call=(bcf_io_call_t*)(uintptr_t)data;rb_thread_call_without_gvl(call->operation,call->arguments,RUBY_UBF_IO,NULL);return Qnil;}
+static VALUE bcf_io_end(VALUE data){bcf_io_call_t*call=(bcf_io_call_t*)(uintptr_t)data;call->file->active_io=0;return Qnil;}
+/* Async exceptions run only after the no-GVL operation (and any UBF cancellation)
+ * returns; rb_ensure resets the guard while the call arguments are still alive. */
+static void bcf_io_run(ruby_bcf_file_t*file,void*(*operation)(void*),void*arguments){bcf_io_call_t call={file,operation,arguments};bcf_io_begin(file);rb_ensure(bcf_io_call_without_gvl,(VALUE)(uintptr_t)&call,bcf_io_end,(VALUE)(uintptr_t)&call);}
+static void raise_bcf_open_error(VALUE path,int error){if(error)rb_syserr_fail_str(error,path);VALUE hts=rb_const_get(rb_cObject,rb_intern("HTS"));VALUE bcf=rb_const_get(hts,rb_intern("Bcf"));VALUE klass=rb_const_get(bcf,rb_intern("OpenError"));rb_raise(klass,"Failed to open %"PRIsVALUE": HTSlib could not recognize or open the input",path);}
+static VALUE native_bcf_file_open(VALUE klass,VALUE path,VALUE mode) {ruby_bcf_file_t*v;VALUE o=TypedData_Make_Struct(klass,ruby_bcf_file_t,&bcf_file_type,v);v->index=NULL;v->tabix=NULL;v->active_io=0;v->path=rb_str_dup(StringValue(path));RB_OBJ_WRITE(o,&v->path,v->path);errno=0;v->file=hts_open(StringValueCStr(v->path),StringValueCStr(mode));if(!v->file)raise_bcf_open_error(path,errno);return o;}
+static VALUE native_bcf_file_close(VALUE self){ruby_bcf_file_t*v=get_bcf_file(self,1);int result=0;if(v->active_io)rb_raise(rb_eIOError,"cannot close BCF during active I/O");if(v->index){hts_idx_destroy(v->index);v->index=NULL;}if(v->tabix){tbx_destroy(v->tabix);v->tabix=NULL;}if(v->file){result=hts_close(v->file);v->file=NULL;}return INT2NUM(result);}
 static VALUE native_bcf_file_closed(VALUE self){return get_bcf_file(self,1)->file?Qfalse:Qtrue;}
-static VALUE native_bcf_file_read_header(VALUE self){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_header_read_args_t a={v->file,NULL};bcf_io_begin(v);rb_thread_call_without_gvl(bcf_read_header_without_gvl,&a,RUBY_UBF_IO,NULL);v->active_io=0;return wrap_bcf_header(a.result);}
-static VALUE native_bcf_file_read(VALUE self,VALUE header,VALUE record){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,get_bcf_record(record)->pointer,NULL,NULL,NULL,0};bcf_io_begin(v);rb_thread_call_without_gvl(bcf_read_without_gvl,&a,RUBY_UBF_IO,NULL);v->active_io=0;return INT2NUM(a.result);}
-static VALUE native_bcf_file_write_header(VALUE self,VALUE header){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,NULL,NULL,NULL,NULL,0};bcf_io_begin(v);rb_thread_call_without_gvl(bcf_write_header_without_gvl,&a,RUBY_UBF_IO,NULL);v->active_io=0;return INT2NUM(a.result);}
-static VALUE native_bcf_file_write(VALUE self,VALUE header,VALUE record){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,get_bcf_record(record)->pointer,NULL,NULL,NULL,0};bcf_io_begin(v);rb_thread_call_without_gvl(bcf_write_without_gvl,&a,RUBY_UBF_IO,NULL);v->active_io=0;return INT2NUM(a.result);}
+static VALUE native_bcf_file_read_header(VALUE self){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_header_read_args_t a={v->file,NULL};bcf_io_run(v,bcf_read_header_without_gvl,&a);return wrap_bcf_header(a.result);}
+static VALUE native_bcf_file_read(VALUE self,VALUE header,VALUE record){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,get_bcf_record(record)->pointer,NULL,NULL,NULL,0};bcf_io_run(v,bcf_read_without_gvl,&a);return INT2NUM(a.result);}
+static VALUE native_bcf_file_write_header(VALUE self,VALUE header){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,NULL,NULL,NULL,NULL,0};bcf_io_run(v,bcf_write_header_without_gvl,&a);return INT2NUM(a.result);}
+static VALUE native_bcf_file_write(VALUE self,VALUE header,VALUE record){ruby_bcf_file_t*v=get_bcf_file(self,0);bcf_io_args_t a={v->file,get_bcf_header(header)->pointer,get_bcf_record(record)->pointer,NULL,NULL,NULL,0};bcf_io_run(v,bcf_write_without_gvl,&a);return INT2NUM(a.result);}
 static VALUE native_bcf_file_set_threads(VALUE self,VALUE n){return INT2NUM(hts_set_threads(get_bcf_file(self,0)->file,NUM2INT(n)));}
 static VALUE native_bcf_file_format(VALUE self){const htsFormat*f=hts_get_format(get_bcf_file(self,0)->file);if(!f)return Qnil;switch(f->format){case vcf:return rb_str_new_cstr("vcf");case bcf:return rb_str_new_cstr("bcf");default:return rb_str_new_cstr("unknown_format");}}
 static VALUE native_bcf_file_version(VALUE self){const htsFormat*f=hts_get_format(get_bcf_file(self,0)->file);if(!f)return Qnil;if(f->version.minor==-1)return rb_sprintf("%d",f->version.major);return rb_sprintf("%d.%d",f->version.major,f->version.minor);}
@@ -348,7 +426,7 @@ static VALUE native_bcf_file_index_loaded(VALUE self){ruby_bcf_file_t*v=get_bcf_
 static VALUE native_bcf_file_build_index(VALUE klass,VALUE path,VALUE index,VALUE shift,VALUE threads){return INT2NUM(bcf_index_build3(StringValueCStr(path),NIL_P(index)?NULL:StringValueCStr(index),NUM2INT(shift),NUM2INT(threads)));}
 static VALUE native_bcf_file_query_region(VALUE self,VALUE header,VALUE region){ruby_bcf_file_t*v=get_bcf_file(self,0);hts_itr_t*i;if(v->tabix)i=tbx_itr_querys(v->tabix,StringValueCStr(region));else i=bcf_itr_querys(v->index,get_bcf_header(header)->pointer,StringValueCStr(region));return wrap_bcf_iterator(self,header,i,v->tabix!=NULL);}
 static VALUE native_bcf_file_query_interval(VALUE self,VALUE header,VALUE rid,VALUE beg,VALUE end){ruby_bcf_file_t*v=get_bcf_file(self,0);hts_itr_t*i=v->tabix?tbx_itr_queryi(v->tabix,NUM2INT(rid),NUM2LL(beg),NUM2LL(end)):bcf_itr_queryi(v->index,NUM2INT(rid),NUM2LL(beg),NUM2LL(end));return wrap_bcf_iterator(self,header,i,v->tabix!=NULL);}
-static VALUE native_bcf_iterator_next(VALUE self,VALUE record){ruby_bcf_iterator_t*i=get_bcf_iterator(self);ruby_bcf_file_t*f=get_bcf_file(i->file,0);bcf_io_args_t a={f->file,get_bcf_header(i->header)->pointer,get_bcf_record(record)->pointer,i->iterator,i->tabix?f->tabix:NULL,&i->line,0};bcf_io_begin(f);rb_thread_call_without_gvl(bcf_iterator_without_gvl,&a,RUBY_UBF_IO,NULL);f->active_io=0;return INT2NUM(a.result);}
+static VALUE native_bcf_iterator_next(VALUE self,VALUE record){ruby_bcf_iterator_t*i=get_bcf_iterator(self);ruby_bcf_file_t*f=get_bcf_file(i->file,0);bcf_io_args_t a={f->file,get_bcf_header(i->header)->pointer,get_bcf_record(record)->pointer,i->iterator,i->tabix?f->tabix:NULL,&i->line,0};bcf_io_run(f,bcf_iterator_without_gvl,&a);return INT2NUM(a.result);}
 static VALUE native_bcf_iterator_close(VALUE self){ruby_bcf_iterator_t*v;TypedData_Get_Struct(self,ruby_bcf_iterator_t,&bcf_iterator_type,v);if(v->iterator){hts_itr_destroy(v->iterator);v->iterator=NULL;}return Qnil;}
 
 void Init_htslib_native_bcf(VALUE native) {

data/ext/htslib_native/native_faidx.c

@@ -1,6 +1,7 @@
 #include "htslib_native.h"
 
 #include <htslib/faidx.h>
+#include <errno.h>
 #include <stdlib.h>
 
 typedef struct {
@@ -47,10 +48,18 @@ static VALUE native_faidx_open(VALUE klass, VALUE path_value, VALUE format_value
     enum fai_format_options format = NUM2INT(format_value) == 1 ? FAI_FASTQ : FAI_FASTA;
 
     object = TypedData_Make_Struct(klass, ruby_faidx_t, &ruby_faidx_type, handle);
+    errno = 0;
     handle->fai = RTEST(auto_build_value)
         ? fai_load_format(path, format)
         : fai_load3_format(path, NULL, NULL, 0, format);
-    if (handle->fai == NULL) rb_syserr_fail_str(ENOENT, path_value);
+    if (handle->fai == NULL) {
+        int error = errno;
+        if (error) rb_syserr_fail_str(error, path_value);
+        VALUE hts = rb_const_get(rb_cObject, rb_intern("HTS"));
+        VALUE faidx = rb_const_get(hts, rb_intern("Faidx"));
+        VALUE open_error = rb_const_get(faidx, rb_intern("OpenError"));
+        rb_raise(open_error, "Failed to open %"PRIsVALUE": HTSlib could not load the index", path_value);
+    }
     return object;
 }
 

data/ext/htslib_native/native_tabix.c

@@ -3,6 +3,7 @@
 #include <htslib/hts.h>
 #include <htslib/kstring.h>
 #include <htslib/tbx.h>
+#include <errno.h>
 #include <stdlib.h>
 
 typedef struct {
@@ -72,8 +73,16 @@ static VALUE native_tabix_open(VALUE klass, VALUE path_value)
     handle->active_queries = 0;
     handle->path = rb_str_dup(StringValue(path_value));
     RB_OBJ_WRITE(object, &handle->path, handle->path);
+    errno = 0;
     handle->file = hts_open(StringValueCStr(handle->path), "r");
-    if (handle->file == NULL) rb_syserr_fail_str(ENOENT, path_value);
+    if (handle->file == NULL) {
+        int error = errno;
+        if (error) rb_syserr_fail_str(error, path_value);
+        VALUE hts = rb_const_get(rb_cObject, rb_intern("HTS"));
+        VALUE tabix = rb_const_get(hts, rb_intern("Tabix"));
+        VALUE open_error = rb_const_get(tabix, rb_intern("OpenError"));
+        rb_raise(open_error, "Failed to open %"PRIsVALUE": HTSlib could not recognize or open the input", path_value);
+    }
     return object;
 }
 

data/lib/hts/bam/base_mod.rb

@@ -12,6 +12,7 @@ module HTS
     class BaseMod
       include Enumerable
 
+      class Error < HTS::Error; end
       class NotParsedError < StandardError; end
 
       attr_reader :record

data/lib/hts/bam/flag.rb

@@ -28,6 +28,10 @@ module HTS
       DUPLICATE = 1024
       SUPPLEMENTARY = 2048
 
+      UNMAP = UNMAPPED
+      MUNMAP = MATE_UNMAPPED
+      DUP = DUPLICATE
+
       TABLE = { paired?: PAIRED, proper_pair?: PROPER_PAIR, unmapped?: UNMAPPED,
                 mate_unmapped?: MATE_UNMAPPED, reverse?: REVERSE,
                 mate_reverse?: MATE_REVERSE, read1?: READ1, read2?: READ2,
@@ -74,9 +78,7 @@ module HTS
       end
 
       def ~
-        # FIXME: Only 12bits are used for flags
-        # The result is different from the Crystal version.
-        self.class.new(~@value)
+        self.class.new((~@value) & 0x0fff)
       end
 
       def <<(f)

data/lib/hts/bam.rb

@@ -17,6 +17,11 @@ module HTS
   class Bam
     include Enumerable
 
+    class ReadError < HTS::Error; end
+    class WriteError < HTS::Error; end
+    class OpenError < HTS::Error; end
+    class MissingIndexError < HTS::Error; end
+
     # Filter an owning batch of records in one native pass when available.
     def self.filter_records(records, required_flags: 0, excluded_flags: 0,
                             min_mapq: 0, tid: nil, beg: nil, end_: nil)
@@ -38,11 +43,11 @@ module HTS
       return file unless block_given?
 
       begin
-        yield file
+        result = yield file
       ensure
         file.close
       end
-      file
+      result
     end
 
     def self.build_index(file_name, index_name = nil, min_shift = 0, threads = 0, verbose = true)
@@ -98,7 +103,11 @@ module HTS
 
       set_threads(threads) if threads
 
-      return if @mode[0] == "w"
+      if writing?
+        @auto_index_on_close = build_index
+        @index_name_on_close = index
+        return
+      end
 
       @header = Bam::Header.new(@native.read_header)
       if build_index
@@ -120,6 +129,12 @@ module HTS
     end
 
     def load_index(index_name = nil)
+      return self if try_load_index(index_name)
+
+      raise MissingIndexError, "Failed to load index #{index_name || "for #{@file_name}"}"
+    end
+
+    def try_load_index(index_name = nil)
       check_closed
 
       @index_name = index_name
@@ -134,7 +149,16 @@ module HTS
     end
 
     def close
-      @native&.close
+      was_closed = closed?
+      result = @native&.close
+      raise WriteError, "Failed to close #{@file_name}: buffered output may be incomplete" if writing? && result&.negative?
+
+      if writing? && @auto_index_on_close && !was_closed
+        @auto_index_on_close = false
+        self.class.build_index(@file_name, @index_name_on_close, 0, @nthreads || 0, false)
+      end
+
+      nil
     end
 
     def closed? = @native.nil? || @native.closed?
@@ -168,6 +192,8 @@ module HTS
 
     private
 
+    def writing? = @mode&.start_with?("w", "a")
+
     def native_handle = @native
 
     public
@@ -177,6 +203,7 @@ module HTS
 
       @header = header.dup
       @native.write_header(header.__send__(:native_handle))
+      nil
     end
 
     def header=(header)
@@ -188,10 +215,13 @@ module HTS
 
       r = @native.write(header.__send__(:native_handle), record.__send__(:native_handle))
       raise "Failed to write record" if r < 0
+
+      nil
     end
 
     def <<(record)
       write(record)
+      self
     end
 
     # @!macro [attach] define_getter
@@ -230,6 +260,13 @@ module HTS
       each(copy: true).to_a
     end
 
+    # Materialize independent, owning records. Enumerable#to_a is unsafe for
+    # the default reused-record iterator because every array element would
+    # otherwise refer to the same native bam1_t buffer.
+    def to_a
+      collect_records
+    end
+
     # @!macro [attach] define_iterator
     #   @method each_$1
     #   Get $1 iterator
@@ -378,7 +415,13 @@ module HTS
       return to_enum(__method__) unless block_given?
 
       record = Record.new(header)
-      yield record while @native.read(header.__send__(:native_handle), record.__send__(:native_handle)) != -1
+      loop do
+        result = @native.read(header.__send__(:native_handle), record.__send__(:native_handle))
+        break if result == -1
+        raise ReadError, "Failed to read BAM/SAM record (HTSlib error #{result})" if result < -1
+
+        yield record
+      end
       self
     end
 
@@ -388,7 +431,13 @@ module HTS
       return to_enum(__method__) unless block_given?
 
       record = Record.new(header)
-      yield record.dup while @native.read(header.__send__(:native_handle), record.__send__(:native_handle)) != -1
+      loop do
+        result = @native.read(header.__send__(:native_handle), record.__send__(:native_handle))
+        break if result == -1
+        raise ReadError, "Failed to read BAM/SAM record (HTSlib error #{result})" if result < -1
+
+        yield record.dup
+      end
       self
     end
 

data/lib/hts/bcf/errors.rb

@@ -5,14 +5,17 @@ module HTS
     class Error < HTS::Error; end
 
     class OpenError < Error; end
+    class WriteError < Error; end
     class IndexError < Error; end
     class MissingIndexError < IndexError; end
     class QueryError < Error; end
+    class RecordError < Error; end
     class HeaderError < Error; end
     class SubsetError < HeaderError; end
     class UnknownSampleError < SubsetError; end
     class FieldError < Error; end
     class InfoError < FieldError; end
+    class InfoDefinitionError < InfoError; end
     class InfoTypeError < InfoError; end
     class InfoReadError < InfoError; end
     class InfoUpdateError < InfoError; end

data/lib/hts/bcf/format.rb

@@ -141,7 +141,14 @@ module HTS
         native.format_get(header_native, key, code, raw_float)
       end
 
-      def get_int(key) = get(key, :int)
+      def get_int_raw(key) = get_raw(key, :int)
+
+      def get_int(key)
+        values = get_int_raw(key)
+        values&.each_with_object([]) do |value, decoded|
+          decoded << missing_int(value) unless value == Native::BCF_INT32_VECTOR_END
+        end
+      end
 
       def get_float(key)
         words = get_raw(key, :float)

data/lib/hts/bcf/header.rb

@@ -44,6 +44,7 @@ module HTS
       def get_version
         @native.version
       end
+      alias version get_version
 
       def set_version(version)
         rc = @native.set_version(version)
@@ -53,6 +54,7 @@ module HTS
         sync_if_needed!
         self
       end
+      alias version= set_version
 
       def nsamples
         @native.nsamples

data/lib/hts/bcf/info.rb

@@ -15,7 +15,7 @@ module HTS
 
       def get(key, type = nil)
         schema = header.schema("INFO", key.to_s)
-        return nil unless schema
+        raise InfoDefinitionError, "INFO tag #{key} not defined in header" unless schema
 
         actual_type = schema.first
         requested = type&.to_sym
@@ -24,7 +24,8 @@ module HTS
         end
 
         code = TYPE_CODES.fetch(requested || actual_type)
-        native.info_get(header_native, key.to_s, code)
+        value = native.info_get(header_native, key.to_s, code)
+        code == Native::BCF_HT_FLAG && value.nil? ? false : value
       end
 
       def get_int(key) = get(key, :int)

data/lib/hts/bcf/record.rb

@@ -27,11 +27,12 @@ module HTS
       def id = @native.id
 
       def id=(value)
-        @native.set_id(@header.__send__(:native_handle), value)
+        check_update_rc!(@native.set_id(@header.__send__(:native_handle), value), "ID", value)
+        value
       end
 
       def clear_id
-        @native.set_id(@header.__send__(:native_handle), ".")
+        check_update_rc!(@native.set_id(@header.__send__(:native_handle), "."), "ID", ".")
         nil
       end
 
@@ -44,7 +45,8 @@ module HTS
         values = Array(values).map(&:to_s)
         raise ArgumentError, "at least one allele is required" if values.empty?
 
-        @native.set_alleles(@header.__send__(:native_handle), values.join(","))
+        encoded = values.join(",")
+        check_update_rc!(@native.set_alleles(@header.__send__(:native_handle), encoded), "alleles", encoded)
         values
       end
 
@@ -62,15 +64,20 @@ module HTS
         @native.core_set(:qual, value)
       end
 
-      def filter
+      def filters
         names = @native.filter_names(@header.__send__(:native_handle))
-        case names.length
-        when 0 then "PASS"
-        when 1 then names.first
-        else names
-        end
+        names
       end
 
+
+      # VCF FILTER is a list even when it contains a single value. Keeping a
+      # stable return type avoids substring matching for single-filter records.
+      alias filter filters
+
+      def passed? = filters == ["PASS"]
+      def filter_missing? = filters.empty?
+      def filtered? = !passed? && !filter_missing?
+
       def each_filter_id(&block)
         return to_enum(__method__) unless block_given?
 
@@ -95,6 +102,12 @@ module HTS
 
       private
 
+      def check_update_rc!(result, field, value)
+        return result unless result.negative?
+
+        raise RecordError, "Failed to update #{field} to #{value.inspect} (HTSlib error #{result})"
+      end
+
       def native_handle = @native
 
       def initialize_copy(original)

data/lib/hts/bcf.rb

@@ -29,11 +29,11 @@ module HTS
       return file unless block_given?
 
       begin
-        yield file
+        result = yield file
       ensure
         file.close
       end
-      file
+      result
     end
 
     def self.build_index(file_name, index_name = nil, min_shift = 14, threads = 0, verbose = true)
@@ -67,7 +67,11 @@ module HTS
         raise SubsetError,
               "Sample subsetting is only available when reading BCF/VCF files"
       end
-      return if mode.start_with?("w")
+      if writing?
+        @auto_index_on_close = build_index
+        @index_name_on_close = index
+        return
+      end
 
       @read_header = Header.new(@native.read_header)
       @header = subset ? @read_header.subset(subset) : @read_header
@@ -91,6 +95,12 @@ module HTS
     end
 
     def load_index(index_name = nil)
+      return self if try_load_index(index_name)
+
+      raise MissingIndexError, "Failed to load index #{index_name || "for #{@file_name}"}"
+    end
+
+    def try_load_index(index_name = nil)
       check_closed
       @index_name = index_name
       @index_load_attempted = true
@@ -102,7 +112,18 @@ module HTS
       @native.index_loaded?
     end
 
-    def close = @native&.close
+    def close
+      was_closed = closed?
+      result = @native&.close
+      raise WriteError, "Failed to close #{@file_name}: buffered output may be incomplete" if writing? && result&.negative?
+
+      if writing? && @auto_index_on_close && !was_closed
+        @auto_index_on_close = false
+        self.class.build_index(@file_name, @index_name_on_close, 14, @nthreads || 0, false)
+      end
+
+      nil
+    end
     def closed? = @native.nil? || @native.closed?
     def file_format = @native.file_format
     def file_format_version = @native.file_format_version
@@ -137,7 +158,7 @@ module HTS
       result = @native.write_header(header.__send__(:native_handle))
       raise HeaderError, "Failed to write BCF header" if result.negative?
 
-      result
+      nil
     end
 
     def header=(header)
@@ -149,9 +170,13 @@ module HTS
       result = @native.write(header.__send__(:native_handle), record.__send__(:native_handle))
       raise "Failed to write record" if result.negative?
 
-      result
+      nil
+    end
+
+    def <<(record)
+      write(record)
+      self
     end
-    alias << write
 
     def nsamples
       check_closed
@@ -192,6 +217,10 @@ module HTS
 
     def collect_records = each(copy: true).to_a
 
+    # Materialize independent, owning records rather than retaining the
+    # reused Record yielded by the allocation-conscious default iterator.
+    def to_a = collect_records
+
     define_iterator :chrom
     define_iterator :pos
     define_iterator :endpos
@@ -244,6 +273,8 @@ module HTS
 
     private
 
+    def writing? = @mode&.start_with?("w", "a")
+
     def ensure_index_loaded
       return true if index_loaded?
       return false if @index_load_attempted

data/lib/hts/faidx.rb

@@ -4,6 +4,8 @@ require_relative "native"
 
 module HTS
   class Faidx
+    class OpenError < HTS::Error; end
+
     attr_reader :file_name, :format
 
     def self.open(file_name, format: :auto, auto_build: true)

data/lib/hts/tabix.rb

@@ -9,6 +9,9 @@ module HTS
   class Tabix < Hts
     include Enumerable
 
+    class OpenError < HTS::Error; end
+    class MissingIndexError < HTS::Error; end
+
     attr_reader :file_name, :index_name, :mode, :nthreads
 
     def self.open(*args, **kw)
@@ -16,11 +19,11 @@ module HTS
       return file unless block_given?
 
       begin
-        yield file
+        result = yield file
       ensure
         file.close
       end
-      file
+      result
     end
 
     def initialize(file_name, index: nil, threads: nil, build_index: false)
@@ -40,8 +43,12 @@ module HTS
 
       set_threads(threads) if threads
 
-      # build_index(index) if build_index
-      load_index(index) if index
+      if build_index
+        build_index(index)
+        load_index(index)
+      elsif index
+        load_index(index)
+      end
     end
 
     def build_index(index_name = nil, min_shift: 0)
@@ -70,6 +77,12 @@ module HTS
     end
 
     def load_index(index_name = nil)
+      return self if try_load_index(index_name)
+
+      raise MissingIndexError, "Failed to load index #{index_name || "for #{@file_name}"}"
+    end
+
+    def try_load_index(index_name = nil)
       check_closed
       @index_name = index_name
       @index_load_attempted = true

data/lib/hts/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTS
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: htslib
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - kojix2