minibwa 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5d54a100aaa8439c2dc2fb9b686ca60f4898ea0873370f3dc5b58bfd5af1b7fa
+  data.tar.gz: 17911037009111f945b2f2621ccdc1e6b51928748585cc3753d6341250cca51e
+SHA512:
+  metadata.gz: 0e3a98d1f7e2652f16d3537bbbe7a2e3b89ff05dad6b5f1c166db505a465cdb1f854bbd2970bca0c1c0152f8f5fa4bc10bf7ef4a716a4c9001663bf35ec77743
+  data.tar.gz: 0c99b08294dcaaff5f896da4516c4c52df07cb74e879e58c7eea40f795235ac95b92535e7a86dec93cd900ee6257d4ea4e5e42b199fe4705fe1faa851d0cdb39

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 kojix2
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,119 @@
+# ruby-minibwa
+
+[![Gem Version](https://img.shields.io/gem/v/minibwa?color=brightgreen)](https://rubygems.org/gems/minibwa)
+[![Test](https://github.com/kojix2/ruby-minibwa/actions/workflows/test.yml/badge.svg)](https://github.com/kojix2/ruby-minibwa/actions/workflows/test.yml)
+[![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Fruby-minibwa%2Flines)](https://tokei.kojix2.net/github/kojix2/ruby-minibwa)
+
+Ruby bindings for [minibwa](https://github.com/lh3/minibwa), a short-read
+aligner combining bwa-mem seeding with minimap2 chaining and alignment.
+
+## Installation
+
+Requires a C compiler, zlib, and Ruby >= 3.2.
+
+```sh
+git clone --recursive https://github.com/kojix2/ruby-minibwa
+cd ruby-minibwa
+bundle install
+bundle exec rake compile
+```
+
+The extension builds the vendored minibwa sources, including libsais for
+index construction. Expect the first build to take a few minutes.
+
+## Usage
+
+Build an index:
+
+```ruby
+require "minibwa"
+
+Minibwa::Index.build("ref.fa", "ref", n_thread: 4)
+```
+
+This writes `ref.l2b` and `ref.mbw`. Indexes made by the `minibwa index`
+command are also usable.
+
+Map reads:
+
+```ruby
+opt = Minibwa::Options.new
+opt.preset("sr")  # or "adap", "lr"
+
+idx = Minibwa::Index.load("ref")
+
+hits = idx.map("ACGT...", name: "read1", opt: opt)
+hits.each do |h|
+  puts [h.ctg, h.ts, h.te, h.strand, h.qs, h.qe, h.mapq, h.cigar_str].join("\t")
+end
+```
+
+Map many reads in one call:
+
+```ruby
+seqs  = ["ACGT...", "TGCA..."]
+names = ["read1", "read2"]
+hits  = idx.map_batch(seqs, names: names, opt: opt)
+# => [[Hit, ...], [Hit, ...]]
+```
+
+Use a reusable buffer for repeated mapping:
+
+```ruby
+buf = Minibwa::Buffer.new
+idx.map(seq, buf: buf)
+```
+
+Generate SAM output:
+
+```ruby
+puts Minibwa::Sam.header(idx)
+hits.each do |h|
+  puts Minibwa::Sam.format("read1", 0, h, seq)
+end
+```
+
+**Note on reverse-strand alignments:** For hits where `hit.rev` is true,
+the SAM spec requires SEQ to be the reverse complement of the original
+query and the FLAG to have 0x10 set. `Sam.format` does not do this
+automatically — pass the already-oriented sequence and the correct flag.
+The library does not retain the original query after mapping.
+
+With `pe: true`, `map_batch` treats consecutive sequences as read pairs.
+
+### CIGAR
+
+`Hit#cigar` and `#cigar_str` cover the aligned region only and contain no
+clipping, which is how minibwa reports alignments. `#full_cigar_str`
+takes the query length and adds soft clips derived from `qs` and `qe`.
+
+### Threads
+
+`Options#n_thread` affects only `Index.build` (via libsais + OpenMP).
+Mapping itself is single-threaded per call, but releases the GVL, so Ruby
+threads run in parallel. To map from several Ruby threads, give each one
+its own buffer:
+
+```ruby
+buf = Minibwa::Buffer.new
+idx.map(seq, opt: opt, buf: buf)
+```
+
+A `Buffer` holds mutable scratch state and must not be shared between
+threads mapping at the same time.
+
+## Development
+
+```sh
+bundle exec rake compile
+bundle exec rake test
+```
+
+`bin/console` gives an IRB session with the extension loaded.
+
+## License
+
+MIT. The vendored minibwa is MIT as well; its GPL-licensed files
+(`bwtgen.c`, `QSufSort.c`, providing the low-memory BWT construction
+option) are neither compiled nor distributed. See
+`ext/minibwa/minibwa/LICENSE.txt`.

data/ext/minibwa/extconf.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Builds the binding together with the minibwa sources from the submodule.
+#
+# There is no shared libminibwa to link against, so the C library is compiled
+# into the extension. Upstream's Makefile is the reference for which files and
+# flags are needed; api-test/Makefile shows that the public mapping API needs
+# only libminibwa.a (the LOBJS group) plus -lz -lm.
+
+require 'mkmf'
+
+upstream = File.join(__dir__, 'minibwa')
+
+unless File.exist?(File.join(upstream, 'minibwa.h'))
+  abort 'minibwa sources not found. Run: git submodule update --init --recursive'
+end
+
+# --- source selection ------------------------------------------------------
+
+# The LOBJS group of upstream's Makefile: everything behind the public API.
+core = %w[
+  kommon kalloc bwt l2bit options seed map-algo lchain align pe cs format
+]
+
+# SSE alignment kernels. On ARM these fall back to s2n-lite.h (NEON) on their
+# own, so no extra flag is needed there.
+ksw2 = %w[ksw2_extz2_sse ksw2_extd2_sse ksw2_ll_sse]
+
+# Suffix array construction, needed only by Index.build.
+sais = %w[libsais libsais64]
+
+# Deliberately NOT compiled:
+#
+#   index.c       mb_index_build.c #includes it to reach the static
+#                 mb_bwt_libsais(); compiling it too would define every
+#                 symbol in it twice.
+#   bwtgen.c      GPL, and the low-memory BWT construction they implement is
+#   QSufSort.c    not offered by this gem. Keeping them out keeps it MIT.
+#   mimalloc/     replaces malloc process-wide, which is not something a Ruby
+#                 extension may do to its host. See HAVE_KALLOC below.
+#   main.c        the command line tool.
+#   fastmap.c
+#   map-main.c
+#   bseq.c        FASTX reading and thread pool for the CLI; reading sequences
+#   kthread.c     is the caller's job in Ruby.
+
+binding_srcs = %w[minibwa mb_options mb_index mb_index_build mb_buffer mb_hit]
+
+$srcs = binding_srcs.map { |f| "#{f}.c" } +
+        (core + ksw2 + sais).map { |f| "minibwa/#{f}.c" }
+$objs = $srcs.map { |f| "#{File.basename(f, '.c')}.o" }
+$VPATH << '$(srcdir)/minibwa'
+
+# So that our own sources can say #include "minibwa/minibwa.h".
+$INCFLAGS << ' -I$(srcdir)'
+
+# --- libraries -------------------------------------------------------------
+
+# l2bit.c reads FASTA through kseq/gzip.
+abort 'zlib is required' unless have_header('zlib.h') && have_library('z', 'gzopen')
+have_library('m', 'log')
+
+# --- flags -----------------------------------------------------------------
+
+# Required, and quietly consequential: without it mb_opt_init() sets
+# MB_F_NO_KALLOC and every allocation goes to the system allocator. Upstream
+# defines it whenever mimalloc is not linked, which for us is always. The
+# build succeeds either way, so a missing -DHAVE_KALLOC shows up only as lost
+# performance.
+$defs << '-DHAVE_KALLOC'
+
+# Keep optional CPU instructions local to the alignment kernels so the rest
+# of a precompiled extension remains compatible with baseline x86_64 CPUs.
+sse_cflags = if RbConfig::CONFIG['host_cpu'].match?(/x86_64|x64|amd64/i)
+               %w[-msse4.2 -mpopcnt].select { |flag| try_cflags(flag) }
+             else
+               []
+             end
+
+# libsais parallelises index construction with OpenMP; Options#n_thread has no
+# effect on Index.build without it. Everything else is single-threaded here,
+# so this is optional. Disable with --disable-openmp.
+if enable_config('openmp', true) && try_compile("#include <omp.h>\nint main(void){return 0;}", '-fopenmp')
+  $defs << '-DLIBSAIS_OPENMP'
+  append_cflags('-fopenmp')
+  append_ldflags('-fopenmp')
+end
+
+# Hide upstream's symbols. ksw2 and kalloc names are shared with minimap2 and
+# other lh3 libraries, which may be loaded into the same process by another
+# gem.
+append_cflags('-fvisibility=hidden')
+
+create_makefile('minibwa/minibwa')
+
+unless sse_cflags.empty?
+  File.open('Makefile', 'a') do |makefile|
+    ksw2.each do |source|
+      makefile.puts
+      makefile.puts "#{source}.o: $(srcdir)/minibwa/#{source}.c"
+      makefile.puts "\t$(ECHO) compiling $<"
+      makefile.puts "\t$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) #{sse_cflags.join(' ')} $(COUTFLAG)$@ -c $(CSRCFLAG)$<"
+    end
+  end
+end

data/ext/minibwa/mb_buffer.c

@@ -0,0 +1,113 @@
+/*
+ * Document-class: Minibwa::Buffer
+ *
+ * Minibwa::Buffer -- wraps mb_tbuf_t, the reusable per-thread scratch buffer.
+ *
+ * Passing a Buffer to Index#map saves an mb_tbuf_init/mb_tbuf_destroy pair on
+ * every call; passing nil lets mb_map() allocate one internally. A Buffer
+ * carries mutable working state and must never be shared between threads that
+ * map concurrently -- one Buffer per thread.
+ *
+ * Freed with mb_tbuf_destroy().
+ */
+
+#include "minibwa.h"
+
+static void
+rb_minibwa_buffer_free(void *ptr)
+{
+    mb_tbuf_t *b = (mb_tbuf_t *)ptr;
+    if (b) mb_tbuf_destroy(b);
+}
+
+static size_t
+rb_minibwa_buffer_memsize(const void *ptr)
+{
+    /* mb_tbuf_t is an opaque type; report the pointer size only. */
+    (void)ptr;
+    return 0;
+}
+
+const rb_data_type_t rb_minibwa_buffer_type = {
+    .wrap_struct_name = "Minibwa::Buffer",
+    .function = {
+        NULL,
+        rb_minibwa_buffer_free,
+        rb_minibwa_buffer_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+/* ------------------------------------------------------------------ */
+/* Constructor                                                        */
+/* ------------------------------------------------------------------ */
+
+/*
+ * call-seq:
+ *   Buffer.new(no_kalloc: false) -> Buffer
+ *
+ * Allocates a new thread-local scratch buffer.  Set +no_kalloc:+ to +true+
+ * to disable the internal allocator.
+ */
+static VALUE
+rb_minibwa_buffer_initialize(int argc, VALUE *argv, VALUE self)
+{
+    VALUE kwargs;
+    rb_scan_args(argc, argv, ":", &kwargs);
+
+    int no_kalloc = 0;
+    if (!NIL_P(kwargs)) {
+        VALUE v = rb_hash_aref(kwargs, ID2SYM(rb_intern("no_kalloc")));
+        if (RTEST(v)) no_kalloc = 1;
+    }
+
+    /* The buffer was allocated by alloc with the default (kalloc enabled).
+     * If the caller wants no_kalloc, rebuild it through the public API. */
+    if (no_kalloc) {
+        mb_tbuf_t *b = rb_minibwa_get_tbuf(self);
+        if (b) mb_tbuf_destroy(b);
+        b = mb_tbuf_init(1);
+        if (!b) rb_raise(rb_eMinibwaError, "mb_tbuf_init failed");
+        DATA_PTR(self) = b;
+    }
+    return Qnil;
+}
+
+static VALUE
+rb_minibwa_buffer_alloc(VALUE klass)
+{
+    mb_tbuf_t *b = mb_tbuf_init(0);
+    VALUE obj = TypedData_Wrap_Struct(klass, &rb_minibwa_buffer_type, b);
+    return obj;
+}
+
+/*
+ * call-seq:
+ *   reset!(max_block_size) -> Integer
+ *
+ * Resets the buffer for reuse, optionally setting a new maximum block size.
+ * Returns the new capacity.
+ */
+static VALUE
+rb_minibwa_buffer_reset(VALUE self, VALUE max_block_size)
+{
+    mb_tbuf_t *b = rb_minibwa_get_tbuf(self);
+    int64_t mbs = NUM2LL(max_block_size);
+    int32_t cap = mb_tbuf_reset(b, mbs);
+    return INT2NUM(cap);
+}
+
+/* ------------------------------------------------------------------ */
+/* Registration                                                       */
+/* ------------------------------------------------------------------ */
+
+void
+rb_minibwa_init_buffer(void)
+{
+    VALUE klass = rb_define_class_under(rb_mMinibwa, "Buffer", rb_cObject);
+    rb_cMinibwaBuffer = klass;
+
+    rb_define_alloc_func(klass, rb_minibwa_buffer_alloc);
+    rb_define_method(klass, "initialize", rb_minibwa_buffer_initialize, -1);
+    rb_define_method(klass, "reset!", rb_minibwa_buffer_reset, 1);
+}

data/ext/minibwa/mb_hit.c

@@ -0,0 +1,192 @@
+/*
+ * Minibwa::Hit -- one alignment produced by mb_map() / mb_map_batch().
+ *
+ * mb_hit_t is converted eagerly into a plain Ruby object and the C memory is
+ * released immediately, because the caller owns both hit[i].p and the hit
+ * array. Copying up front costs one pass but removes every question about
+ * object lifetime, and keeps a Hit usable after its Index is gone.
+ *
+ * The CIGAR in mb_extra_t is unpacked into an array of [length, op] pairs.
+ * It describes the aligned region only and contains no soft or hard clipping;
+ * clips have to be reconstructed from qs/qe (see lib/minibwa/hit.rb).
+ */
+
+#include "minibwa.h"
+
+/* ------------------------------------------------------------------ */
+/* Single hit conversion                                              */
+/* ------------------------------------------------------------------ */
+
+/*
+ * Builds a Minibwa::Hit from an mb_hit_t.  Takes ownership of hit->p
+ * (frees it).  The idx is needed for ctg_name lookups.
+ */
+VALUE
+rb_minibwa_hit_new(const mb_idx_t *idx, mb_hit_t *hit)
+{
+    VALUE klass = rb_cMinibwaHit;
+    VALUE obj = rb_obj_alloc(klass);
+
+    /* --- scalar fields --- */
+    rb_ivar_set(obj, rb_intern("@tid"),    LL2NUM(hit->tid));
+    rb_ivar_set(obj, rb_intern("@ts"),     LL2NUM(hit->ts));
+    rb_ivar_set(obj, rb_intern("@te"),     LL2NUM(hit->te));
+    rb_ivar_set(obj, rb_intern("@qs"),     INT2NUM(hit->qs));
+    rb_ivar_set(obj, rb_intern("@qe"),     INT2NUM(hit->qe));
+    rb_ivar_set(obj, rb_intern("@score"),  INT2NUM(hit->score));
+    rb_ivar_set(obj, rb_intern("@score0"), INT2NUM(hit->score0));
+    rb_ivar_set(obj, rb_intern("@mlen"),   INT2NUM(hit->mlen));
+    rb_ivar_set(obj, rb_intern("@blen"),   INT2NUM(hit->blen));
+    rb_ivar_set(obj, rb_intern("@mapq"),   INT2NUM(hit->mapq));
+    rb_ivar_set(obj, rb_intern("@cnt"),    INT2NUM(hit->cnt));
+    rb_ivar_set(obj, rb_intern("@n_sub"),  INT2NUM(hit->n_sub));
+    rb_ivar_set(obj, rb_intern("@subsc"),  INT2NUM(hit->subsc));
+    rb_ivar_set(obj, rb_intern("@hash"),   UINT2NUM(hit->hash));
+
+    /* --- bit fields --- */
+    rb_ivar_set(obj, rb_intern("@rev"),         hit->rev         ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@proper_pair"), hit->proper_pair ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@sam_pri"),     hit->sam_pri     ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@flt"),         hit->flt         ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@inv"),         hit->inv         ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@split"),       INT2NUM(hit->split));
+    rb_ivar_set(obj, rb_intern("@split_inv"),   hit->split_inv   ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@rescued"),     hit->rescued     ? Qtrue : Qfalse);
+    rb_ivar_set(obj, rb_intern("@frac_high"),   INT2NUM(hit->frac_high));
+    rb_ivar_set(obj, rb_intern("@seed_ratio"),  INT2NUM(hit->seed_ratio));
+
+    /* --- contig name (lazy: store tid, resolve in Ruby) --- */
+    const char *ctg = mb_idx_ctg_name(idx, (int32_t)hit->tid);
+    rb_ivar_set(obj, rb_intern("@ctg"),
+                ctg ? rb_str_new_cstr(ctg) : Qnil);
+
+    /* --- extra (CIGAR, DP scores) --- */
+    if (hit->p) {
+        mb_extra_t *p = hit->p;
+
+        rb_ivar_set(obj, rb_intern("@dp_score"), INT2NUM(p->dp_score));
+        rb_ivar_set(obj, rb_intern("@dp_max0"),  INT2NUM(p->dp_max0));
+        rb_ivar_set(obj, rb_intern("@dp_max"),   INT2NUM(p->dp_max));
+        rb_ivar_set(obj, rb_intern("@dp_max2"),  INT2NUM(p->dp_max2));
+        rb_ivar_set(obj, rb_intern("@n_ambi"),   UINT2NUM(p->n_ambi));
+        rb_ivar_set(obj, rb_intern("@cs_flag"),  p->cs ? Qtrue : Qfalse);
+
+        /* CIGAR: array of [length, op] pairs */
+        VALUE cigar = rb_ary_new_capa(p->n_cigar);
+        for (int32_t i = 0; i < p->n_cigar; i++) {
+            uint32_t c = p->cigar[i];
+            VALUE pair = rb_ary_new_from_args(2,
+                UINT2NUM(c >> 4),
+                INT2NUM(c & 0xf));
+            rb_ary_push(cigar, pair);
+        }
+        rb_ivar_set(obj, rb_intern("@cigar"), cigar);
+
+        free(p);
+        hit->p = NULL;  /* mark as consumed for the ensure handler */
+    } else {
+        rb_ivar_set(obj, rb_intern("@dp_score"), INT2NUM(0));
+        rb_ivar_set(obj, rb_intern("@dp_max0"),  INT2NUM(0));
+        rb_ivar_set(obj, rb_intern("@dp_max"),   INT2NUM(0));
+        rb_ivar_set(obj, rb_intern("@dp_max2"),  INT2NUM(0));
+        rb_ivar_set(obj, rb_intern("@n_ambi"),   INT2NUM(0));
+        rb_ivar_set(obj, rb_intern("@cs_flag"),  Qfalse);
+        rb_ivar_set(obj, rb_intern("@cigar"),    rb_ary_new());
+    }
+
+    return obj;
+}
+
+/* ------------------------------------------------------------------ */
+/* Hit array conversion                                               */
+/* ------------------------------------------------------------------ */
+
+struct hit_ary_ctx {
+    const mb_idx_t *idx;
+    mb_hit_t *hits;
+    int32_t n_hit;
+    VALUE ary;
+};
+
+static VALUE
+rb_minibwa_hit_ary_convert(VALUE ptr)
+{
+    struct hit_ary_ctx *ctx = (struct hit_ary_ctx *)ptr;
+    ctx->ary = rb_ary_new_capa(ctx->n_hit);
+    for (int32_t i = 0; i < ctx->n_hit; i++) {
+        VALUE hit = rb_minibwa_hit_new(ctx->idx, &ctx->hits[i]);
+        rb_ary_push(ctx->ary, hit);
+    }
+    return ctx->ary;
+}
+
+static VALUE
+rb_minibwa_hit_ary_free_hits(VALUE ptr)
+{
+    struct hit_ary_ctx *ctx = (struct hit_ary_ctx *)ptr;
+    /* If conversion raised, free any remaining hit[i].p and the array.
+     * rb_minibwa_hit_new() sets hit->p to NULL after freeing, so already-
+     * converted hits are skipped. */
+    for (int32_t i = 0; i < ctx->n_hit; i++)
+        free(ctx->hits[i].p);
+    free(ctx->hits);
+    return Qnil;
+}
+
+/*
+ * Converts an array of mb_hit_t to a Ruby Array of Minibwa::Hit.
+ * Takes ownership of the hit array and all hit[i].p (frees them).
+ * If conversion raises, the array is still freed before re-raising.
+ */
+VALUE
+rb_minibwa_hit_ary_new(const mb_idx_t *idx, mb_hit_t *hits, int32_t n_hit)
+{
+    struct hit_ary_ctx ctx = { idx, hits, n_hit, Qnil };
+    return rb_ensure(rb_minibwa_hit_ary_convert, (VALUE)&ctx,
+                     rb_minibwa_hit_ary_free_hits, (VALUE)&ctx);
+}
+
+/* ------------------------------------------------------------------ */
+/* Registration                                                       */
+/* ------------------------------------------------------------------ */
+
+void
+rb_minibwa_init_hit(void)
+{
+    VALUE klass = rb_define_class_under(rb_mMinibwa, "Hit", rb_cObject);
+    rb_cMinibwaHit = klass;
+
+    /* attr_readers for all fields */
+    rb_define_attr(klass, "tid",         1, 0);
+    rb_define_attr(klass, "ts",          1, 0);
+    rb_define_attr(klass, "te",          1, 0);
+    rb_define_attr(klass, "qs",          1, 0);
+    rb_define_attr(klass, "qe",          1, 0);
+    rb_define_attr(klass, "score",       1, 0);
+    rb_define_attr(klass, "score0",      1, 0);
+    rb_define_attr(klass, "mlen",        1, 0);
+    rb_define_attr(klass, "blen",        1, 0);
+    rb_define_attr(klass, "mapq",        1, 0);
+    rb_define_attr(klass, "cnt",         1, 0);
+    rb_define_attr(klass, "n_sub",       1, 0);
+    rb_define_attr(klass, "subsc",       1, 0);
+    rb_define_attr(klass, "hash",        1, 0);
+    rb_define_attr(klass, "rev",         1, 0);
+    rb_define_attr(klass, "proper_pair", 1, 0);
+    rb_define_attr(klass, "sam_pri",     1, 0);
+    rb_define_attr(klass, "flt",         1, 0);
+    rb_define_attr(klass, "inv",         1, 0);
+    rb_define_attr(klass, "split",       1, 0);
+    rb_define_attr(klass, "split_inv",   1, 0);
+    rb_define_attr(klass, "rescued",     1, 0);
+    rb_define_attr(klass, "frac_high",   1, 0);
+    rb_define_attr(klass, "seed_ratio",  1, 0);
+    rb_define_attr(klass, "ctg",         1, 0);
+    rb_define_attr(klass, "dp_score",    1, 0);
+    rb_define_attr(klass, "dp_max0",     1, 0);
+    rb_define_attr(klass, "dp_max",      1, 0);
+    rb_define_attr(klass, "dp_max2",     1, 0);
+    rb_define_attr(klass, "n_ambi",      1, 0);
+    rb_define_attr(klass, "cs_flag",     1, 0);
+    rb_define_attr(klass, "cigar",       1, 0);
+}