bio-twobit 0.1.1

data/ext/bio/twobit/2bit.h

@@ -0,0 +1,134 @@
+#include <inttypes.h>
+#include <stdio.h>
+
+/*! \mainpage libBigWig
+ *
+ * \section Introduction
+ *
+ * lib2bit is a C-based library for accessing [2bit files](https://genome.ucsc.edu/FAQ/FAQformat.html#format7). At the moment, only reading 2bit files is supported (there are no plans to change this, though if someone wants to submit a pull request...). Though it's unlikely to matter, 
+ *
+ * The motivation for this project is due to needing fast access to 2bit files in [deepTools](https://github.com/fidelram/deepTools). Originally, we were using bx-python for this, which had the benefit of being easy to install and pretty quick. However, that wasn't compatible with python3, so we switched to [twobitreader](https://github.com/benjschiller/twobitreader). While doing everything we needed and working under both python2 and python3, it turns out that it has terrible performance (up to 1000x slow down in `computeGCBias`). Since we'd like to have our cake and eat it too, I began wrote a C library for convenient 2bit access and then [a python wrapper](https://github.com/dpryan79/py2bit) around it to work in python2 and 3.
+ *
+ * \section Installation
+ *
+ * 2bit files are very simple and there are no dependencies. Simply typing `make` should suffice for compilation. To install into a specific path (the default is `/usr/local`):
+ * 
+ *     make install prefix=/some/where/else
+ *
+ * `lib2bit.so` and `lib2bit.a` will then be in `/some/where/else/lib` and `2bit.h` in `/some/where/else/include`.
+ *
+ * \section Example
+ *
+ * See the `test/` directory for an example of using the library.
+ */
+
+/*! \file 2bit.h
+ *
+ * These are all functions and structures exported in lib2bit. There are a few things that could be more efficiently implemented, but at the moment theverything is "fast enough".
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*!
+ * @brief This structure holds the fixed-sized file header (16 bytes, of which 4 are blank). The version should always be 0. In theory, the endianness of the magic number can change (indicating that everything in the file should be swapped). As I've never actually seen this occur in the wild I've not bothered implementing it, though it'd be simple enough to do so.
+ */
+typedef struct {
+    uint32_t magic; /**<Holds the magic number, should be 0x1A412743 */
+    uint32_t version; /**<File version, should be 0 */
+    uint32_t nChroms; /**<Number of chromosomes/contigs */
+} TwoBitHeader;
+
+/*!
+ * @brief This structure holds the chromosome names and the offset to the on-disk beginning of their sequences
+ */
+typedef struct {
+    char **chrom; /**<A list of null terminated chromosomes */
+    uint32_t *offset; /**<The file offset for the beginning of each chromosome */
+} TwoBitCL;
+
+/*!
+ * @brief This structure holds the number, location and size of the hard (N) and soft (lower case) masked blocks.
+ *
+ * Note that this isn't a great data structure for random access, particularly for the soft-masked blocks. In practice, soft-masking is typically ignored and file access is less random and more blocky. Nonetheless, if performance is not acceptable then this is the structure to change.
+ */
+typedef struct {
+    uint32_t *size; /**<The size of a given chromosome/contig */
+    uint32_t *nBlockCount; /**<The number of blocks of Ns in a given chromosome/contig */
+    uint32_t **nBlockStart; /**<For each chromosome/contig, the list (size nBlockCount) of start positions of the block of Ns */
+    uint32_t **nBlockSizes; /**<The size of each block specified above */
+    uint32_t *maskBlockCount; /**<The number of blocks of masked sequence in a given chromosome/contig */
+    uint32_t **maskBlockStart; /**<For each chromosome/contig, the list (size maskBlockCount) of start positions of the masked sequence blocks */
+    uint32_t **maskBlockSizes; /**<The size of each block specified above */
+    uint64_t *offset; /**<The offset to the packed 2-bit sequence */
+} TwoBitMaskedIdx;
+
+/*!
+ * @brief This is the main structure for holding a 2bit file
+ *
+ * Note that currently the 2bit file is mmap()ed prior to reading and that this isn't optional.
+ */
+typedef struct {
+    FILE *fp;    /**<The file pointer for the opened file */
+    uint64_t sz; /**<File size in bytes (needed for munmap) */
+    uint64_t offset; /**<If the file is memory mapped, then this is the current file offset (otherwise ignored) */
+    void *data;  /**<The memory mapped file, if it exists. */
+    TwoBitHeader *hdr; /**<File header */
+    TwoBitCL *cl; /**<Chromosome list with sizes */
+    TwoBitMaskedIdx *idx; /**<Index of masked blocks */
+} TwoBit;
+
+/*!
+ * @brief Opens a local 2bit file
+ *
+ * @param fname The name of the 2bit file.
+ * @param storeMasked Whether soft-masking information should be stored. If this is 1 then soft-masking information will be stored and the `twobitSequence()` function will return lower case letters in soft-masked regions. Note that this has a considerable performance and memory impact.
+ * @return A pointer to a TwoBit object.
+ * @note The file is memory mapped.
+ */
+TwoBit* twobitOpen(char *fname, int storeMasked);
+
+/*!
+ * @brief Closes a 2bit file and free memory.
+ */
+void twobitClose(TwoBit *tb);
+
+/*!
+ * @brief Returns the length of a given chromosome.
+ * 
+ * @param tb A pointer to a TwoBit object.
+ * @param chrom The chromosome name.
+ * @return The chromosome length as a uint32_t. Note that if the chromosome/contig isn't present in the file that 0 is returned.
+ */
+uint32_t twobitChromLen(TwoBit *tb, char *chrom);
+
+/*!
+ * @brief Returns the sequence of a chromosome/contig or range of it.
+ *
+ * @param tb A pointer to a TwoBit object.
+ * @param chrom The chromosome name.
+ * @param start The starting position in 0-based coordinates.
+ * @param end The end position in 1-based coordinates.
+ * @return The sequence or NULL on error. If both start and end are 0 then the sequence for the entire chromosome/contig is returned.
+ * @note The result MUST be `free()`d. Care is taken to return reasonable sequences when illegal regions are requested. If the end value is beyond the possible end of the chromosome then it is modified according.
+ */
+char *twobitSequence(TwoBit *tb, char *chrom, uint32_t start, uint32_t end);
+
+/*!
+ * @brief Return the number/fraction of A, C, T, and G in a chromosome/region
+ * 
+ * @param tb A pointer to a TwoBit object.
+ * @param chrom The chromosome name.
+ * @param start The starting position in 0-based coordinates.
+ * @param end The end position in 1-based coordinates.
+ * @param fraction Whether to return the values as fractions (1) or integers (0).
+ * @return If fraction is not 0, then 4 `double`s with the fraction of bases as A, C, T and G, respectively. If fraction is 1, integer counts are returned as 4 `uint32_t`s in the aforementioned order.
+ * @note On error NULL is returned. The result MUST be `free()`d.
+ */
+
+void *twobitBases(TwoBit *tb, char *chrom, uint32_t start, uint32_t end, int fraction);
+
+#ifdef __cplusplus
+}
+#endif

data/ext/bio/twobit/LICENSE

@@ -0,0 +1,24 @@
+dpryan79/lib2bit
+
+The MIT License (MIT)
+
+Copyright (c) 2015 Devon Ryan
+
+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/ext/bio/twobit/extconf.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+create_makefile("bio/twobit/twobit")

data/ext/bio/twobit/twobit.c

@@ -0,0 +1,524 @@
+#include "twobit.h"
+
+#define SIZEOF_INT32 4
+#define SIZEOF_INT64 8
+
+#if SIZEOF_SHORT == SIZEOF_INT32
+#define NUM2UINT32 NUM2USHORT
+#define NUM2INT32 NUM2SHORT
+#define UINT32_2NUM USHORT2NUM
+#define INT32_2NUM SHORT2NUM
+#elif SIZEOF_INT == SIZEOF_INT32
+#define NUM2UINT32 NUM2UINT
+#define NUM2INT32 NUM2INT
+#define UINT32_2NUM UINT2NUM
+#define INT32_2NUM INT2NUM
+#elif SIZEOF_LONG == SIZEOF_INT32
+#define NUM2UINT32 NUM2ULONG
+#define NUM2INT32 NUM2LONG
+#define UINT32_2NUM ULONG2NUM
+#define INT32_2NUM LONG2NUM
+#else
+#error "Neither int, long, nor short is the same size as int32_t"
+#endif
+
+#if SIZEOF_INT == SIZEOF_INT64
+#define NUM2UINT64 NUM2UINT
+#define NUM2INT64 NUM2INT
+#define UINT64_2NUM UINT2NUM
+#define INT64_2NUM INT2NUM
+#elif SIZEOF_LONG == SIZEOF_INT64
+#define NUM2UINT64 NUM2ULONG
+#define NUM2INT64 NUM2LONG
+#define UINT64_2NUM ULONG2NUM
+#define INT64_2NUM LONG2NUM
+#elif SIZEOF_LONGLONG == SIZEOF_INT64
+#define NUM2UINT64 NUM2ULL
+#define NUM2INT64 NUM2LL
+#define UINT64_2NUM ULL2NUM
+#define INT64_2NUM LL2NUM
+#else
+#error "Neither int, long, nor short is the same size as int64_t"
+#endif
+
+VALUE mBio;
+VALUE mTwoBit;
+
+static void TwoBit_free(void *ptr);
+static size_t TwoBit_memsize(const void *ptr);
+
+static const rb_data_type_t TwoBit_type = {
+    "TwoBit",
+    {
+        0,
+        TwoBit_free,
+        TwoBit_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static void
+TwoBit_free(void *ptr)
+{
+  // twobitClose checks for null
+  twobitClose(ptr);
+}
+
+static size_t
+TwoBit_memsize(const void *ptr)
+{
+  const TwoBit *data = ptr;
+
+  return data ? sizeof(*data) : 0;
+}
+
+static TwoBit *getTwoBit(VALUE self)
+{
+  TwoBit *ptr = NULL;
+  TypedData_Get_Struct(self, TwoBit, &TwoBit_type, ptr);
+
+  return ptr;
+}
+
+static VALUE
+twobit_allocate(VALUE klass)
+{
+  TwoBit *tb = NULL;
+
+  return TypedData_Wrap_Struct(klass, &TwoBit_type, tb);
+}
+
+static VALUE
+twobit_init(VALUE klass, VALUE fpath, VALUE storeMasked)
+{
+  char *path = NULL;
+  int mask = 0;
+  TwoBit *tb = NULL;
+
+  path = StringValueCStr(fpath);
+  mask = NUM2INT(storeMasked);
+
+  tb = twobitOpen(path, mask);
+  if (!tb)
+  {
+    twobitClose(tb);
+    rb_raise(rb_eRuntimeError, "Could not open file %s", path);
+    return Qnil;
+  }
+  DATA_PTR(klass) = tb;
+
+  return klass;
+}
+
+static VALUE
+twobit_close(VALUE self)
+{
+  TwoBit *tb = getTwoBit(self);
+  if (tb)
+  {
+    twobitClose(tb);
+    DATA_PTR(self) = NULL;
+  }
+
+  return Qnil;
+}
+
+static VALUE
+twobit_info(VALUE self)
+{
+  TwoBit *tb = getTwoBit(self);
+
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  uint32_t i, j, foo;
+  VALUE val;
+  VALUE info = rb_hash_new();
+
+  //file size
+  val = UINT64_2NUM(tb->sz);
+  if (!val)
+    goto error;
+  rb_hash_aset(info, rb_str_new2("file_size"), val);
+
+  //nContigs
+  val = UINT32_2NUM(tb->hdr->nChroms);
+  if (!val)
+    goto error;
+  rb_hash_aset(info, rb_str_new2("nChroms"), val);
+
+  //sequence length
+  foo = 0;
+  for (i = 0; i < tb->hdr->nChroms; i++)
+  {
+    foo += tb->idx->size[i];
+  }
+  val = UINT32_2NUM(foo);
+  if (!val)
+    goto error;
+  rb_hash_aset(info, rb_str_new2("sequence_length"), val);
+
+  //hard-masked length
+  foo = 0;
+  for (i = 0; i < tb->hdr->nChroms; i++)
+  {
+    for (j = 0; j < tb->idx->nBlockCount[i]; j++)
+    {
+      foo += tb->idx->nBlockSizes[i][j];
+    }
+  }
+  val = UINT32_2NUM(foo);
+  if (!val)
+    goto error;
+  rb_hash_aset(info, rb_str_new2("hard_masked_length"), val);
+
+  //soft-masked length
+  if (tb->idx->maskBlockStart)
+  {
+    foo = 0;
+    for (i = 0; i < tb->hdr->nChroms; i++)
+    {
+      for (j = 0; j < tb->idx->maskBlockCount[i]; j++)
+      {
+        foo += tb->idx->maskBlockSizes[i][j];
+      }
+    }
+    val = UINT32_2NUM(foo);
+    if (!val)
+      goto error;
+    rb_hash_aset(info, rb_str_new2("soft_masked_length"), val);
+  }
+
+  return info;
+
+error:
+  rb_raise(rb_eRuntimeError, "Received an error while gathering information on the 2bit file!");
+  return Qnil;
+}
+
+static VALUE
+twobit_chroms(VALUE self)
+{
+  TwoBit *tb = getTwoBit(self);
+
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  uint32_t i;
+  VALUE val;
+  VALUE chroms = rb_hash_new();
+
+  for (i = 0; i < tb->hdr->nChroms; i++)
+  {
+    val = UINT32_2NUM(tb->idx->size[i]);
+    if (!val)
+      goto error;
+    rb_hash_aset(chroms, rb_str_new2(tb->cl->chrom[i]), val);
+  }
+
+  return chroms;
+
+error:
+  rb_raise(rb_eRuntimeError, "Received an error while adding an item to the output hash!");
+  return Qnil;
+}
+
+static VALUE
+twobit_sequence(VALUE self, VALUE chrom, VALUE rbstart, VALUE rbend)
+{
+  char *ch, *str;
+  unsigned long startl = 0, endl = 0;
+  uint32_t start, end, len;
+  TwoBit *tb;
+
+  ch = StringValueCStr(chrom);
+  startl = NUM2UINT32(rbstart);
+  endl = NUM2UINT32(rbend);
+  tb = getTwoBit(self);
+
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  len = twobitChromLen(tb, ch);
+  if (len == 0)
+  {
+    rb_raise(rb_eRuntimeError, "The chromosome %s does not exist in the 2bit file!", ch);
+    return Qnil;
+  }
+  if (endl > len)
+    endl = len;
+  end = (uint32_t)endl;
+  if (startl >= endl && startl > 0)
+  {
+    rb_raise(rb_eRuntimeError, "The start position %lu is greater than the end position %lu!", startl, endl);
+    return Qnil;
+  }
+  start = (uint32_t)startl;
+
+  str = twobitSequence(tb, ch, start, end);
+
+  return rb_str_new2(str);
+}
+
+static VALUE
+twobit_bases(VALUE self, VALUE chrom, VALUE start, VALUE end, VALUE fraction)
+{
+  char *ch;
+  uint32_t st, en, fr;
+  TwoBit *tb;
+  void *o = NULL;
+  VALUE val, hash;
+
+  tb = getTwoBit(self);
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  ch = StringValueCStr(chrom);
+  st = NUM2UINT32(start);
+  en = NUM2UINT32(end);
+  fr = NUM2INT(fraction);
+
+  o = twobitBases(tb, ch, st, en, fr);
+  if (!o)
+  {
+    rb_raise(rb_eRuntimeError, "Received an error while determining the per-base metrics.");
+    return Qnil;
+  }
+
+  hash = rb_hash_new();
+
+  if (fr)
+  {
+    val = DBL2NUM(((double *)o)[0]);
+  }
+  else
+  {
+    val = UINT32_2NUM(((uint32_t *)o)[0]);
+  }
+  rb_hash_aset(hash, rb_str_new2("A"), val);
+
+  if (fr)
+  {
+    val = DBL2NUM(((double *)o)[1]);
+  }
+  else
+  {
+    val = UINT32_2NUM(((uint32_t *)o)[1]);
+  }
+  rb_hash_aset(hash, rb_str_new2("C"), val);
+
+  if (fr)
+  {
+    val = DBL2NUM(((double *)o)[2]);
+  }
+  else
+  {
+    val = UINT32_2NUM(((uint32_t *)o)[2]);
+  }
+  rb_hash_aset(hash, rb_str_new2("T"), val);
+
+  if (fr)
+  {
+    val = DBL2NUM(((double *)o)[3]);
+  }
+  else
+  {
+    val = UINT32_2NUM(((uint32_t *)o)[3]);
+  }
+  rb_hash_aset(hash, rb_str_new2("G"), val);
+
+  free(o);
+
+  return hash;
+}
+
+static VALUE
+twobit_hard_masked_blocks(VALUE self, VALUE chrom, VALUE rbstart, VALUE rbend)
+{
+  char *ch;
+  TwoBit *tb;
+  unsigned long startl = 0, endl = 0, totalBlocks = 0, tid;
+  uint32_t i, len, start, end, blockStart, blockEnd;
+  VALUE val, ary;
+
+  tb = getTwoBit(self);
+  ch = StringValueCStr(chrom);
+  startl = NUM2UINT32(rbstart);
+  endl = NUM2UINT32(rbend);
+
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  //Get the chromosome ID
+  for (i = 0; i < tb->hdr->nChroms; i++)
+  {
+    if (strcmp(tb->cl->chrom[i], ch) == 0)
+    {
+      tid = i;
+      break;
+    }
+  }
+
+  len = twobitChromLen(tb, ch);
+  if (len == 0)
+  {
+    rb_raise(rb_eRuntimeError, "The chromosome %s doesn't exist in the 2bit file!", ch);
+    return Qnil;
+  }
+  if (endl == 0)
+    endl = len;
+  if (endl > len)
+    endl = len;
+  end = (uint32_t)endl;
+  if (startl > endl && startl > 0)
+  {
+    rb_raise(rb_eRuntimeError, "The start value must be less then the end value (and the end of the chromosome!");
+    return Qnil;
+  }
+  start = (uint32_t)startl;
+
+  //Count the total number of overlapping N-masked blocks
+  for (i = 0; i < tb->idx->nBlockCount[tid]; i++)
+  {
+    blockStart = tb->idx->nBlockStart[tid][i];
+    blockEnd = blockStart + tb->idx->nBlockSizes[tid][i];
+    if (blockStart < end && blockEnd > start)
+    {
+      totalBlocks++;
+    }
+  }
+
+  //Form the output
+  ary = rb_ary_new2(totalBlocks);
+  if (totalBlocks == 0)
+    return ary;
+  for (i = 0; i < tb->idx->nBlockCount[tid]; i++)
+  {
+    blockStart = tb->idx->nBlockStart[tid][i];
+    blockEnd = blockStart + tb->idx->nBlockSizes[tid][i];
+    if (blockStart < end && blockEnd > start)
+    {
+      val = rb_ary_new3(2, UINT32_2NUM(blockStart), UINT32_2NUM(blockEnd));
+      rb_ary_push(ary, val);
+    }
+  }
+
+  return ary;
+}
+
+static VALUE
+twobit_soft_masked_blocks(VALUE self, VALUE chrom, VALUE rbstart, VALUE rbend)
+{
+  char *ch;
+  TwoBit *tb;
+  unsigned long startl = 0, endl = 0, totalBlocks = 0, tid;
+  uint32_t i, len, start, end, blockStart, blockEnd;
+  VALUE val, ary;
+
+  tb = getTwoBit(self);
+  ch = StringValueCStr(chrom);
+  startl = NUM2UINT32(rbstart);
+  endl = NUM2UINT32(rbend);
+
+  if (!tb)
+  {
+    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
+    return Qnil;
+  }
+
+  //Get the chromosome ID
+  for (i = 0; i < tb->hdr->nChroms; i++)
+  {
+    if (strcmp(tb->cl->chrom[i], ch) == 0)
+    {
+      tid = i;
+      break;
+    }
+  }
+
+  len = twobitChromLen(tb, ch);
+  if (len == 0)
+  {
+    rb_raise(rb_eRuntimeError, "The chromosome %s doesn't exist in the 2bit file!", ch);
+    return Qnil;
+  }
+  if (endl == 0)
+    endl = len;
+  if (endl > len)
+    endl = len;
+  end = (uint32_t)endl;
+  if (startl >= endl && startl > 0)
+  {
+    rb_raise(rb_eRuntimeError, "The start value must be less then the end value (and the end of the chromosome!");
+    return Qnil;
+  }
+  start = (uint32_t)startl;
+
+  if (!tb->idx->maskBlockStart)
+  {
+    rb_raise(rb_eRuntimeError, "The file was not opened with storeMasked=True! Consequently, there are no stored soft-masked regions.");
+    return Qnil;
+  }
+
+  //Count the total number of overlapping N-masked blocks
+  for (i = 0; i < tb->idx->maskBlockCount[tid]; i++)
+  {
+    blockStart = tb->idx->maskBlockStart[tid][i];
+    blockEnd = blockStart + tb->idx->maskBlockSizes[tid][i];
+    if (blockStart < end && blockEnd > start)
+    {
+      totalBlocks++;
+    }
+  }
+
+  //Form the output
+  ary = rb_ary_new2(totalBlocks);
+  if (totalBlocks == 0)
+    return ary;
+  for (i = 0; i < tb->idx->maskBlockCount[tid]; i++)
+  {
+    blockStart = tb->idx->maskBlockStart[tid][i];
+    blockEnd = blockStart + tb->idx->maskBlockSizes[tid][i];
+    if (blockStart < end && blockEnd > start)
+    {
+      val = rb_ary_new3(2, UINT32_2NUM(blockStart), UINT32_2NUM(blockEnd));
+      rb_ary_push(ary, val);
+    }
+  }
+
+  return ary;
+}
+
+void Init_twobit(void)
+{
+  mBio = rb_define_module("Bio");
+  mTwoBit = rb_define_class_under(mBio, "TwoBit", rb_cObject);
+
+  rb_define_alloc_func(mTwoBit, twobit_allocate);
+
+  rb_define_private_method(mTwoBit, "initialize_raw", twobit_init, 2);
+  rb_define_method(mTwoBit, "close", twobit_close, 0);
+  rb_define_method(mTwoBit, "info", twobit_info, 0);
+  rb_define_method(mTwoBit, "chroms", twobit_chroms, 0);
+  rb_define_private_method(mTwoBit, "sequence_raw", twobit_sequence, 3);
+  rb_define_private_method(mTwoBit, "bases_raw", twobit_bases, 4);
+  rb_define_private_method(mTwoBit, "hard_masked_blocks_raw", twobit_hard_masked_blocks, 3);
+  rb_define_private_method(mTwoBit, "soft_masked_blocks_raw", twobit_soft_masked_blocks, 3);
+}

data/ext/bio/twobit/twobit.h

@@ -0,0 +1,7 @@
+#ifndef TWOBIT_H
+#define TWOBIT_H 1
+
+#include "ruby.h"
+#include "2bit.h"
+
+#endif /* TWOBIT_H */

data/lib/bio/twobit/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Bio
+  class TwoBit
+    VERSION = "0.1.1"
+  end
+end