bio-twobit 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec7f8c720eed6e69a7e0829e7a46237e49532a5dc3124c57ee0c574f36e79a46
-  data.tar.gz: b46dcf07bd2c34993b57a91e4743d45579285727146fe5ea269dab848e6e6a7f
+  metadata.gz: 1f0ce7759c6099bf6f2675eb467722473f06040a583cad13f2400c1d50f4f3b7
+  data.tar.gz: '09bdb93292cc70fa665a73890d8500b56084639cc3e18d6a1602bdf62d943620'
 SHA512:
-  metadata.gz: 071f082fca0cde51ff22be152f5b6a33837dbf9acdc39dfa9c7caa96fe141a065290febb17f1c5fc45b26a01caacd8d350334f9950885bd5f8a1fe7fae0e5ee4
-  data.tar.gz: 7a6753959f1a7bd188341e64c3dc9176de7f240cc214334ba155a9e706a5cbb997a02c2355626831435bf2b5b0755a31e412902f095a9900cd87a3413043d6cc
+  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/README.md

@@ -18,8 +18,7 @@ gem install bio-twobit
 Downlaod BSgenome.Hsapiens.UCSC.hg38
 
 ```sh
-wget https://bioconductor.org/packages/release/data/annotation/src/contrib/BSgenome.Hsapiens.UCSC.hg38_1.4.4.tar.gz
-tar xvf BSgenome.Hsapiens.UCSC.hg38_1.4.4.tar.gz
+wget http://hgdownload.soe.ucsc.edu/goldenPath/hg38/bigZips/hg38.2bit
 ```
 
 Quick Start
@@ -27,7 +26,10 @@ Quick Start
 ```ruby
 require 'bio/twobit'
 
-hg38 = Bio::TwoBit.open("BSgenome.Hsapiens.UCSC.hg38/inst/extdata/single_sequences.2bit")
+hg38 = Bio::TwoBit.open("hg38.2bit")
+
+hg38.path
+# "hg38.2bit"
 
 hg38.info
 # {"file_size"=>818064875,
@@ -75,6 +77,10 @@ Bio::TwoBit.open("test/fixtures/foo.2bit") do |t|
 end
 ```
 
+```ruby
+tb.closed? # true / false
+```
+
 If you would like to include information about soft-masked bases, you need to manually specify `masked: true`
 
 ```ruby
@@ -89,10 +95,18 @@ tb.soft_masked_blocks("chr1")
 # => [[62, 70]]
 ```
 
+```ruby
+tb.masked? # true / false
+```
+
 ## Development
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/ruby-on-bioc/bio-twobit.
 
+    Do you need commit rights to my repository?
+    Do you want to get admin rights and take over the project?
+    If so, please feel free to contact us @kojix2.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

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/bio-twobit.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "A ruby library for accessing 2bit files"
   spec.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."
+                       "which provides high-speed access to genomic data in 2bit file format."
   spec.homepage      = "https://github.com/ruby-on-bioc/bio-twobit"
   spec.license       = "MIT"
   spec.required_ruby_version = ">= 2.6.0"
@@ -20,8 +20,6 @@ Gem::Specification.new do |spec|
       (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
     end
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
   spec.extensions    = ["ext/bio/twobit/extconf.rb"]
 end

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

@@ -278,6 +278,7 @@ uint8_t getByteMaskFromOffset(int offset) {
 void *twobitBasesWorker(TwoBit *tb, uint32_t tid, uint32_t start, uint32_t end, int fraction) {
     void *out;
     uint32_t tmp[4] = {0, 0, 0, 0}, len = end - start + (start % 4), i = 0, j = 0;
+    uint32_t seqLen = end - start;
     uint32_t blockStart, blockEnd, maskIdx = (uint32_t) -1, maskStart, maskEnd, foo;
     uint8_t *bytes = NULL, mask = 0, offset;
 
@@ -375,10 +376,10 @@ void *twobitBasesWorker(TwoBit *tb, uint32_t tid, uint32_t start, uint32_t end,
     //out is in TCAG order, since that's how 2bit is stored.
     //However, for whatever reason I went with ACTG in the first release...
     if(fraction) {
-        ((double*) out)[0] = ((double) tmp[2])/((double) len);
-        ((double*) out)[1] = ((double) tmp[1])/((double) len);
-        ((double*) out)[2] = ((double) tmp[0])/((double) len);
-        ((double*) out)[3] = ((double) tmp[3])/((double) len);
+        ((double*) out)[0] = ((double) tmp[2])/((double) seqLen);
+        ((double*) out)[1] = ((double) tmp[1])/((double) seqLen);
+        ((double*) out)[2] = ((double) tmp[0])/((double) seqLen);
+        ((double*) out)[3] = ((double) tmp[3])/((double) seqLen);
     } else {
         ((uint32_t*) out)[0] = tmp[2];
         ((uint32_t*) out)[1] = tmp[1];

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.2"
+    VERSION = "0.1.4"
   end
 end

data/lib/bio/twobit.rb

@@ -40,19 +40,33 @@ module Bio
       @masked
     end
 
+    # Since "end" is a reserved word in Ruby, use "stop" instead.
+
     def sequence(chrom, start = 0, stop = 0)
+      raise ArgumentError, "negative start position" if start.negative?
+      raise ArgumentError, "negative stop position" if stop.negative?
+
       sequence_raw(chrom, start, stop)
     end
 
     def bases(chrom, start = 0, stop = 0, fraction: true)
+      raise ArgumentError, "negative start position" if start.negative?
+      raise ArgumentError, "negative stop position" if stop.negative?
+
       bases_raw(chrom, start, stop, fraction ? 1 : 0)
     end
 
     def hard_masked_blocks(chrom, start = 0, stop = 0)
+      raise ArgumentError, "negative start position" if start.negative?
+      raise ArgumentError, "negative stop position" if stop.negative?
+
       hard_masked_blocks_raw(chrom, start, stop)
     end
 
     def soft_masked_blocks(chrom, start = 0, stop = 0)
+      raise ArgumentError, "negative start position" if start.negative?
+      raise ArgumentError, "negative stop position" if stop.negative?
+
       soft_masked_blocks_raw(chrom, start, stop)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bio-twobit
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - kojix2
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2022-01-14 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.
@@ -52,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A ruby library for accessing 2bit files