bio-twobit 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 13e0df3d77589aedc725b0cffa8c5362ac749990a5eef6e1c10d0d137ae8e4d3
-  data.tar.gz: 56e92c1e74b96a040cc8c22c786f2c03d1f6fac7aabb969c34e9f0e81b496055
+  metadata.gz: 1f0ce7759c6099bf6f2675eb467722473f06040a583cad13f2400c1d50f4f3b7
+  data.tar.gz: '09bdb93292cc70fa665a73890d8500b56084639cc3e18d6a1602bdf62d943620'
 SHA512:
-  metadata.gz: d4b7fa2a849a682739b2ae9686000adf397ad972412df8ee965feb0c165df7743a94f1f4d1b7b7d6fba0066e4b7a12b9d5fff87f5db47c7d8a76bf6bd2753456
-  data.tar.gz: 593012ebcbb5eed16157ab6990db9f6cebcb9164c2b171eff04f3e5ebc4f88360c079c118d4e064f63d7205e113a1c889c3897cfdc92a59de8915d7b57df0aeb
+  metadata.gz: ec2fb805c335562a64eca155c5806f3d004b8c4d3a2f6c2363eeb0c529749bb3f220bea4cf626d8d1618d6bdd061b247ae5a50a3f6d94314fbf6d0752bed281e
+  data.tar.gz: 96784953366c86e9e8e3d215a809faf0f23e6f012d3ff158ad47e80651fa2bea8cd0f87a3ca630579f7bb8e1aa41c2a30e449ba8af612ab8921d62e41521d293

data/Gemfile

@@ -6,9 +6,6 @@ source "https://rubygems.org"
 gemspec
 
 gem "rake"
-
 gem "rake-compiler"
-
 gem "test-unit"
-
 gem "rubocop"

data/Rakefile

@@ -22,4 +22,4 @@ Rake::ExtensionTask.new("twobit") do |ext|
   ext.ext_dir = "ext/bio/twobit"
 end
 
-task default: %i[clobber compile test rubocop]
+task default: %i[clobber compile test]

data/ext/bio/twobit/twobit.c

@@ -32,7 +32,7 @@
 #define NUM2INT64 NUM2LONG
 #define UINT64_2NUM ULONG2NUM
 #define INT64_2NUM LONG2NUM
-#elif SIZEOF_LONGLONG == SIZEOF_INT64
+#elif SIZEOF_LONG_LONG == SIZEOF_INT64
 #define NUM2UINT64 NUM2ULL
 #define NUM2INT64 NUM2LL
 #define UINT64_2NUM ULL2NUM
@@ -48,494 +48,491 @@ 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,
+	.wrap_struct_name = "TwoBit",
+	.function = {
+		.dfree = TwoBit_free,
+		.dsize = TwoBit_memsize,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 static void
 TwoBit_free(void *ptr)
 {
-  // twobitClose checks for null
-  twobitClose(ptr);
+	// twobitClose checks for null
+	twobitClose(ptr);
 }
 
 static size_t
 TwoBit_memsize(const void *ptr)
 {
-  const TwoBit *data = ptr;
+	const TwoBit *data = ptr;
 
-  return data ? sizeof(*data) : 0;
+	return data ? sizeof(*data) : 0;
 }
 
 static TwoBit *getTwoBit(VALUE self)
 {
-  TwoBit *ptr = NULL;
-  TypedData_Get_Struct(self, TwoBit, &TwoBit_type, ptr);
+	TwoBit *ptr = NULL;
+	TypedData_Get_Struct(self, TwoBit, &TwoBit_type, ptr);
 
-  return ptr;
+	return ptr;
 }
 
 static VALUE
 twobit_allocate(VALUE klass)
 {
-  TwoBit *tb = NULL;
+	TwoBit *tb = NULL;
 
-  return TypedData_Wrap_Struct(klass, &TwoBit_type, tb);
+	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;
+	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;
+	TwoBit *tb = getTwoBit(self);
+	if (tb)
+	{
+		twobitClose(tb);
+		DATA_PTR(self) = NULL;
+	}
+
+	return Qnil;
 }
 
 static VALUE
 twobit_closed_question_mark(VALUE self)
 {
-  TwoBit *tb = getTwoBit(self);
-  if (tb)
-  {
-    return Qfalse;
-  }
-  else
-  {
-    return Qtrue;
-  }
+	TwoBit *tb = getTwoBit(self);
+	if (tb)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		return Qtrue;
+	}
 }
 
 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;
+	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;
+	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);
+	TwoBit *tb = getTwoBit(self);
 
-  if (!tb)
-  {
-    rb_raise(rb_eRuntimeError, "The 2bit file handle is not open!");
-    return Qnil;
-  }
+	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();
+	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);
-  }
+	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;
+	return chroms;
 
 error:
-  rb_raise(rb_eRuntimeError, "Received an error while adding an item to the output hash!");
-  return Qnil;
+	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);
+	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;
+	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;
-  long tid = -1;
-  unsigned long startl = 0, endl = 0, totalBlocks = 0;
-  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;
+	char *ch;
+	TwoBit *tb;
+	long tid = -1;
+	unsigned long startl = 0, endl = 0, totalBlocks = 0;
+	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;
-  long tid = -1;
-  unsigned long startl = 0, endl = 0, totalBlocks = 0;
-  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;
+	char *ch;
+	TwoBit *tb;
+	long tid = -1;
+	unsigned long startl = 0, endl = 0, totalBlocks = 0;
+	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, "closed?", twobit_closed_question_mark, 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);
+	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, "closed?", twobit_closed_question_mark, 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/lib/bio/twobit/version.rb

@@ -2,6 +2,6 @@
 
 module Bio
   class TwoBit
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio-twobit
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-29 00:00:00.000000000 Z
+date: 2022-11-03 00:00:00.000000000 Z
 dependencies: []
 description: This is a Ruby binding for lib2bit(https://github.com/dpryan79/lib2bit),
   which provides high-speed access to genomic data in 2bit file format.