bio-bigwig 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87a8791f8697b0b4cff130d28f370e67770688d6da475f7caf956556c8431332
-  data.tar.gz: 8faebc66db077059394015892d69c3dde78e4eee4eb614f36b2b3377bd88450f
+  metadata.gz: 972d5cd642441b8881267966c288fec25708aba244c7aa8ca2618d0888ca769e
+  data.tar.gz: 328fd1c1d6f0705a8eef2144c1f4894b9f27bc58d35c5e3e20ea15fd58e4e776
 SHA512:
-  metadata.gz: 017d2fa8b7b03646961344fad93a97d71e9a3d3620e0ced75002d64fa44f5175a8434249ed668924b67b72df2d43a05986dca836018c8e5c144a03ee4a5fa29a
-  data.tar.gz: 9ca76c76d3803689d7e94cd5d9acbd5bd5e939d94bab7a8a2d3c1f0a13ebd5bd3ee97ea617a16877f8a4673ac2fc3291c9b01d56acfa15e70dd05204ec50f398
+  metadata.gz: 40ede32f219724178e4076ede669ab89f2d68065ff5becf16f84b7e8d6c2b0636d3a3c51bf1d0d3f3a29b37dbacf232a167bccf838882e6d946c35779fa8c075
+  data.tar.gz: 608f3bf25e5b549ad6c31d7bf41f6a8d7b55f735721ccf19a33843390e6038bd1b0fbdc28693c9321101de9aa54495952e2565700fe38bc30097e8e7d979f6e3

data/README.md

@@ -3,11 +3,13 @@
 [![Gem Version](https://img.shields.io/gem/v/bio-bigwig?color=brightgreen)](https://rubygems.org/gems/bio-bigwig)
 [![test](https://github.com/kojix2/bio-bigwig/actions/workflows/ci.yml/badge.svg)](https://github.com/kojix2/bio-bigwig/actions/workflows/ci.yml)
 [![Docs Latest](https://img.shields.io/badge/docs-latest-blue.svg)](https://rubydoc.info/gems/bio-bigwig)
+[![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Fbio-bigwig%2Flines)](https://tokei.kojix2.net/github/kojix2/bio-bigwig)
+[![DOI](https://zenodo.org/badge/438516085.svg)](https://doi.org/10.5281/zenodo.13860901)
 
 Ruby wrapper to [libBigWig](https://github.com/dpryan79/libBigWig) compatible with [pyBigWig](https://github.com/deeptools/pyBigWig).
 
-* Currently, curl does not seem to work well ((Pull requests welcome)).
-* File writing is not implemented.
+- Supports both local and remote file access via HTTP/HTTPS.
+- File writing is not implemented.
 
 ## Installation
 
@@ -33,13 +35,13 @@ bw.chroms("1")
 
 bw.header
 # {
-#           :version => 4,       the version number                        
-#            :levels => 1,       the number of zoom levels                       
-#     :bases_covered => 154,     the number of bases described                        
-#           :min_val => 0,       the minimum value                       
-#           :max_val => 2,       the maximum value                        
-#          :sum_data => 272,     the sum of all values                        
-#       :sum_squared => 500      the sum of all squared values                        
+#           :version => 4,       the version number
+#            :levels => 1,       the number of zoom levels
+#     :bases_covered => 154,     the number of bases described
+#           :min_val => 0,       the minimum value
+#           :max_val => 2,       the maximum value
+#          :sum_data => 272,     the sum of all values
+#       :sum_squared => 500      the sum of all squared values
 # }
 
 bw.stats("1", 0, 3)
@@ -54,8 +56,8 @@ bw.stats("1", 0, 3, type: :max)
 # max          - the maximum value
 # cov/coverage - the fraction of bases covered
 # std          - the standard deviation of the values
-# dev          - 
-# sum          - 
+# dev          -
+# sum          -
 
 bw.stats("1",99, 200, type: :max, nbins: 2)
 # [1.399999976158142, 1.5]
@@ -84,25 +86,25 @@ require "bio/bigwig"
 
 bb = Bio::BigWig.open("test/fixtures/test.bigBed")
 
-bb.entries("chr1", 10000000, 10020000) 
-# [[10009333, 10009640, "61035\t130\t-\t0.026\t0.42\t404"],                  
-#  [10014007, 10014289, "61047\t136\t-\t0.029\t0.42\t404"],                  
-#  [10014373, 10024307, "61048\t630\t-\t5.420\t0.00\t2672399"]]   
+bb.entries("chr1", 10000000, 10020000)
+# [[10009333, 10009640, "61035\t130\t-\t0.026\t0.42\t404"],
+#  [10014007, 10014289, "61047\t136\t-\t0.029\t0.42\t404"],
+#  [10014373, 10024307, "61048\t630\t-\t5.420\t0.00\t2672399"]]
 
 bb = Bio::BigWig.open("test/fixtures/test.bigBed")
-bb.entries("chr1", 10000000, 10020000, text: false) 
-# [[10009333, 10009640],                  
-#  [10014007, 10014289],                  
-#  [10014373, 10024307]] 
+bb.entries("chr1", 10000000, 10020000, with_string: false)
+# [[10009333, 10009640],
+#  [10014007, 10014289],
+#  [10014373, 10024307]]
 
 bb.sql
-# table RnaElements 
-# "BED6 + 3 scores for RNA Elements data "                                   
-#     (                                                                      
-#     string chrom;      "Reference sequence chromosome or scaffold"         
-#     uint   chromStart; "Start position in chromosome"                      
-#     uint   chromEnd;   "End position in chromosome"                        
-#     string name;       "Name of item"                                      
+# table RnaElements
+# "BED6 + 3 scores for RNA Elements data "
+#     (
+#     string chrom;      "Reference sequence chromosome or scaffold"
+#     uint   chromStart; "Start position in chromosome"
+#     uint   chromEnd;   "End position in chromosome"
+#     string name;       "Name of item"
 #     uint   score;      "Normalized score from 0-1000"
 #     char[1] strand;    "+ or - or . for unknown"
 #     float level;       "Expression level such as RPKM or FPKM. Set to -1 for no data."

data/ext/bio/bigwig/bigwigext.c

@@ -102,7 +102,7 @@ static VALUE
 bigwig_init(VALUE self, VALUE rb_fname, VALUE rb_mode)
 {
   char *fname = NULL;
-  char *mode = "r";
+  const char *mode = "r";
   bigWigFile_t *bw = NULL;
 
   fname = StringValueCStr(rb_fname);
@@ -207,10 +207,6 @@ bw_get_header(VALUE self)
   rb_hash_aset(rb_header, ID2SYM(rb_intern("sum_squared")), INT2NUM((int)bw->hdr->sumSquared));
 
   return rb_header;
-
-error:
-  rb_raise(rb_eRuntimeError, "Received an error while getting the bigWig header!");
-  return Qnil;
 }
 
 static VALUE
@@ -262,7 +258,7 @@ bw_get_chroms(int argc, VALUE *argv, VALUE self)
   return ret;
 }
 
-enum bwStatsType char2enum(char *s)
+enum bwStatsType char2enum(const char *s)
 {
   if (strcmp(s, "mean") == 0)
     return mean;
@@ -280,7 +276,7 @@ enum bwStatsType char2enum(char *s)
     return cov;
   if (strcmp(s, "sum") == 0)
     return sum;
-  return -1;
+  return doesNotExist;
 };
 
 // double *bwStats        (bigWigFile_t *fp, char *chrom, uint32_t start, uint32_t end, uint32_t nBins, enum bwStatsType type);
@@ -294,7 +290,8 @@ bw_get_stats(VALUE self, VALUE rb_chrom, VALUE rb_start, VALUE rb_end, VALUE rb_
   unsigned long startl = 0, endl = -1;
   uint32_t start, end = -1, tid;
   int nBins = 1, i;
-  char *chrom = NULL, *type = "mean";
+  char *chrom = NULL;
+  const char *type = "mean";
   VALUE ret;
 
   if (!bw)
@@ -473,7 +470,7 @@ bw_get_intervals(VALUE self, VALUE rb_chrom, VALUE rb_start, VALUE rb_end)
   uint32_t start, end = -1, tid, i;
   unsigned long startl = 0, endl = -1;
   bwOverlappingIntervals_t *intervals = NULL;
-  char *chrom;
+  char *chrom = NULL;
   VALUE ret;
 
   if (!bw)
@@ -559,8 +556,8 @@ bb_get_entries(VALUE self, VALUE rb_chrom, VALUE rb_start, VALUE rb_end, VALUE r
 {
   bigWigFile_t *bw = get_bigWigFile(self);
   uint32_t start, end = -1, tid, i;
-  unsigned long startl, endl;
-  char *chrom;
+  unsigned long startl = 0, endl = -1;
+  char *chrom = NULL;
   VALUE ret, t;
   int withString = 1;
   bbOverlappingEntries_t *o;
@@ -744,8 +741,33 @@ bw_is_bigbed_q(VALUE self)
   return bw_is_file_type(self, 1); // 1 = BigBed
 }
 
-void Init_bigwigext()
+static int bigwig_initialized = 0;
+
+static void bigwig_cleanup_handler(void)
 {
+  if (bigwig_initialized)
+  {
+    bwCleanup();
+    bigwig_initialized = 0;
+  }
+}
+
+void Init_bigwigext(void)
+{
+  // Initialize libBigWig only once with proper error handling
+  if (!bigwig_initialized)
+  {
+    if (bwInit(1 << 17) != 0)
+    {
+      rb_raise(rb_eRuntimeError, "Failed to initialize libBigWig for remote access");
+      return;
+    }
+    bigwig_initialized = 1;
+
+    // Register cleanup handler to be called at process exit
+    atexit(bigwig_cleanup_handler);
+  }
+
   rb_Bio = rb_define_module("Bio");
   rb_BigWig = rb_define_class_under(rb_Bio, "BigWig", rb_cObject);
 

data/ext/bio/bigwig/libBigWig/bigWig.h

@@ -56,7 +56,7 @@ extern "C" {
 /*!
  * The library version number
  */
-#define LIBBIGWIG_VERSION 0.4.7
+#define LIBBIGWIG_VERSION 0.4.8
 
 /*!
  * If 1, then this library was compiled with remote file support.

data/ext/bio/bigwig/libBigWig/bwStats.c

@@ -70,7 +70,7 @@ static struct vals_t *getVals(bigWigFile_t *fp, bwOverlapBlock_t *o, int i, uint
 
     if(sz) {
         compressed = 1;
-        buf = malloc(sz); 
+        buf = malloc(sz);
     }
     sz = 0; //This is now the size of the compressed buffer
 
@@ -96,7 +96,7 @@ static struct vals_t *getVals(bigWigFile_t *fp, bwOverlapBlock_t *o, int i, uint
     }
 
     p = buf;
-    while(((uLongf) ((void*)p-buf)) < sz) {
+    while(((uLongf) ((char*)p - (char*)buf)) < sz) {
         vtid = p[0];
         vstart = p[1];
         vend = p[2];

data/ext/bio/bigwig/libBigWig/bwValues.c

@@ -135,8 +135,7 @@ static bwOverlapBlock_t *overlapsLeaf(bwRTreeNode_t *node, uint32_t tid, uint32_
     if(!o) return NULL;
 
     for(i=0; i<node->nChildren; i++) {
-        if(tid < node->chrIdxStart[i]) break;
-        if(tid > node->chrIdxEnd[i]) continue;
+        if(tid < node->chrIdxStart[i] || tid > node->chrIdxEnd[i]) continue;
 
         /*
           The individual blocks can theoretically span multiple contigs.
@@ -162,7 +161,6 @@ static bwOverlapBlock_t *overlapsLeaf(bwRTreeNode_t *node, uint32_t tid, uint32_
         if(!o->size) goto error;
 
         for(i=0; i<node->nChildren; i++) {
-            if(tid < node->chrIdxStart[i]) break;
             if(tid < node->chrIdxStart[i] || tid > node->chrIdxEnd[i]) continue;
             if(node->chrIdxStart[i] != node->chrIdxEnd[i]) {
                 if(tid == node->chrIdxStart[i]) {
@@ -524,15 +522,15 @@ bbOverlappingEntries_t *bbGetOverlappingEntriesCore(bigWigFile_t *fp, bwOverlapB
             tmp = o->size[i]; //TODO: Is this correct? Do non-gzipped bigBeds exist?
         }
 
-        bufEnd = buf + tmp;
+        bufEnd = (char*)buf + tmp;
         while(buf < bufEnd) {
             entryTid = ((uint32_t*)buf)[0];
             start = ((uint32_t*)buf)[1];
             end = ((uint32_t*)buf)[2];
-            buf += 12;
+            buf = (char*)buf + 12;
             str = (char*)buf;
             slen = strlen(str) + 1;
-            buf += slen;
+            buf = (char*)buf + slen;
 
             if(entryTid < tid) continue;
             if(entryTid > tid) break;
@@ -543,7 +541,7 @@ bbOverlappingEntries_t *bbGetOverlappingEntriesCore(bigWigFile_t *fp, bwOverlapB
             if(!pushBBIntervals(output, start, end, str, withString)) goto error;
         }
 
-        buf = bufEnd - tmp; //reset the buffer pointer
+        buf = (char*)bufEnd - tmp; //reset the buffer pointer
     }
 
     if(compressed && buf) free(buf);
@@ -552,7 +550,7 @@ bbOverlappingEntries_t *bbGetOverlappingEntriesCore(bigWigFile_t *fp, bwOverlapB
 
 error:
     fprintf(stderr, "[bbGetOverlappingEntriesCore] Got an error\n");
-    buf = bufEnd - tmp;
+    buf = (char*)bufEnd - tmp;
     if(output) bbDestroyOverlappingEntries(output);
     if(compressed && buf) free(buf);
     if(compBuf) free(compBuf);

data/ext/bio/bigwig/libBigWig/bwWrite.c

@@ -317,12 +317,12 @@ static int flushBuffer(bigWigFile_t *fp) {
     if(!wb->ltype) return 0;
 
     //Fill in the header
-    if(!memcpy(wb->p, &(wb->tid), sizeof(uint32_t))) return 1;
-    if(!memcpy(wb->p+4, &(wb->start), sizeof(uint32_t))) return 2;
-    if(!memcpy(wb->p+8, &(wb->end), sizeof(uint32_t))) return 3;
-    if(!memcpy(wb->p+12, &(wb->step), sizeof(uint32_t))) return 4;
-    if(!memcpy(wb->p+16, &(wb->span), sizeof(uint32_t))) return 5;
-    if(!memcpy(wb->p+20, &(wb->ltype), sizeof(uint8_t))) return 6;
+    if(!memcpy((char*)wb->p, &(wb->tid), sizeof(uint32_t))) return 1;
+    if(!memcpy((char*)wb->p+4, &(wb->start), sizeof(uint32_t))) return 2;
+    if(!memcpy((char*)wb->p+8, &(wb->end), sizeof(uint32_t))) return 3;
+    if(!memcpy((char*)wb->p+12, &(wb->step), sizeof(uint32_t))) return 4;
+    if(!memcpy((char*)wb->p+16, &(wb->span), sizeof(uint32_t))) return 5;
+    if(!memcpy((char*)wb->p+20, &(wb->ltype), sizeof(uint8_t))) return 6;
     //1 byte padding
     //Determine the number of items
     switch(wb->ltype) {
@@ -338,7 +338,7 @@ static int flushBuffer(bigWigFile_t *fp) {
     default:
         return 7;
     }
-    if(!memcpy(wb->p+22, &nItems, sizeof(uint16_t))) return 8;
+    if(!memcpy((char*)wb->p+22, &nItems, sizeof(uint16_t))) return 8;
 
     if(sz) {
         //compress
@@ -399,9 +399,9 @@ int bwAddIntervals(bigWigFile_t *fp, const char* const* chrom, const uint32_t *s
         wb->span = 0;
         wb->step = 0;
     }
-    if(!memcpy(wb->p+wb->l, start, sizeof(uint32_t))) return 7;
-    if(!memcpy(wb->p+wb->l+4, end, sizeof(uint32_t))) return 8;
-    if(!memcpy(wb->p+wb->l+8, values, sizeof(float))) return 9;
+    if(!memcpy((char*)wb->p+wb->l, start, sizeof(uint32_t))) return 7;
+    if(!memcpy((char*)wb->p+wb->l+4, end, sizeof(uint32_t))) return 8;
+    if(!memcpy((char*)wb->p+wb->l+8, values, sizeof(float))) return 9;
     updateStats(fp, end[0]-start[0], values[0]);
     wb->l += 12;
 
@@ -420,9 +420,9 @@ int bwAddIntervals(bigWigFile_t *fp, const char* const* chrom, const uint32_t *s
             flushBuffer(fp);
             wb->start = start[i];
         }
-        if(!memcpy(wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 11;
-        if(!memcpy(wb->p+wb->l+4, &(end[i]), sizeof(uint32_t))) return 12;
-        if(!memcpy(wb->p+wb->l+8, &(values[i]), sizeof(float))) return 13;
+        if(!memcpy((char*)wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 11;
+        if(!memcpy((char*)wb->p+wb->l+4, &(end[i]), sizeof(uint32_t))) return 12;
+        if(!memcpy((char*)wb->p+wb->l+8, &(values[i]), sizeof(float))) return 13;
         updateStats(fp, end[i]-start[i], values[i]);
         wb->l += 12;
     }
@@ -447,9 +447,9 @@ int bwAppendIntervals(bigWigFile_t *fp, const uint32_t *start, const uint32_t *e
             flushBuffer(fp);
             wb->start = start[i];
         }
-        if(!memcpy(wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 4;
-        if(!memcpy(wb->p+wb->l+4, &(end[i]), sizeof(uint32_t))) return 5;
-        if(!memcpy(wb->p+wb->l+8, &(values[i]), sizeof(float))) return 6;
+        if(!memcpy((char*)wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 4;
+        if(!memcpy((char*)wb->p+wb->l+4, &(end[i]), sizeof(uint32_t))) return 5;
+        if(!memcpy((char*)wb->p+wb->l+8, &(values[i]), sizeof(float))) return 6;
         updateStats(fp, end[i]-start[i], values[i]);
         wb->l += 12;
     }
@@ -482,8 +482,8 @@ int bwAddIntervalSpans(bigWigFile_t *fp, const char *chrom, const uint32_t *star
             flushBuffer(fp);
             wb->start = start[i];
         }
-        if(!memcpy(wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 5;
-        if(!memcpy(wb->p+wb->l+4, &(values[i]), sizeof(float))) return 6;
+        if(!memcpy((char*)wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 5;
+        if(!memcpy((char*)wb->p+wb->l+4, &(values[i]), sizeof(float))) return 6;
         updateStats(fp, span, values[i]);
         wb->l += 8;
     }
@@ -506,8 +506,8 @@ int bwAppendIntervalSpans(bigWigFile_t *fp, const uint32_t *start, const float *
             flushBuffer(fp);
             wb->start = start[i];
         }
-        if(!memcpy(wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 4;
-        if(!memcpy(wb->p+wb->l+4, &(values[i]), sizeof(float))) return 5;
+        if(!memcpy((char*)wb->p+wb->l, &(start[i]), sizeof(uint32_t))) return 4;
+        if(!memcpy((char*)wb->p+wb->l+4, &(values[i]), sizeof(float))) return 5;
         updateStats(fp, wb->span, values[i]);
         wb->l += 8;
     }
@@ -540,7 +540,7 @@ int bwAddIntervalSpanSteps(bigWigFile_t *fp, const char *chrom, uint32_t start,
             flushBuffer(fp);
             wb->start = wb->end;
         }
-        if(!memcpy(wb->p+wb->l, &(values[i]), sizeof(float))) return 5;
+        if(!memcpy((char*)wb->p+wb->l, &(values[i]), sizeof(float))) return 5;
         updateStats(fp, wb->span, values[i]);
         wb->l += 4;
     }
@@ -563,7 +563,7 @@ int bwAppendIntervalSpanSteps(bigWigFile_t *fp, const float *values, uint32_t n)
             flushBuffer(fp);
             wb->start = wb->end;
         }
-        if(!memcpy(wb->p+wb->l, &(values[i]), sizeof(float))) return 4;
+        if(!memcpy((char*)wb->p+wb->l, &(values[i]), sizeof(float))) return 4;
         updateStats(fp, wb->span, values[i]);
         wb->l += 4;
     }
@@ -754,7 +754,7 @@ int writeIndex(bigWigFile_t *fp) {
     }
     if(!root) return 4;
     fp->idx->root = root;
-    
+
     ll = fp->writeBuffer->firstIndexNode;
     while(ll) {
         p = ll->next;
@@ -994,8 +994,8 @@ int addIntervalValue(bigWigFile_t *fp, uint64_t *nEntries, double *sum, double *
             newBuffer->p = calloc(itemsPerSlot, 32);
             if(!newBuffer->p) goto error;
             newBuffer->m = itemsPerSlot*32;
-            memcpy(newBuffer->p, buffer->p+buffer->l-32, 4);
-            memcpy(newBuffer->p+4, buffer->p+buffer->l-28, 4);
+            memcpy(newBuffer->p, (unsigned char*)buffer->p+buffer->l-32, 4);
+            memcpy((unsigned char*)newBuffer->p+4, (unsigned char*)buffer->p + buffer->l-28, 4);
             ((uint32_t*) newBuffer->p)[2] = ((uint32_t*) newBuffer->p)[1] + zoom;
             *sum = *sumsq = 0.0;
             rv = updateInterval(fp, newBuffer, sum, sumsq, zoom, tid, start, end, value);
@@ -1122,7 +1122,7 @@ int writeZoomLevels(bigWigFile_t *fp) {
         while(ll) {
             p = ll->next;
             free(ll);
-            ll=p; 
+            ll=p;
         }
 
 

data/lib/bio/bigwig/version.rb

@@ -2,6 +2,6 @@
 
 module Bio
   class BigWig
-    VERSION = "0.0.6"
+    VERSION = "0.1.0"
   end
 end

data/lib/bio/bigwig.rb

@@ -4,7 +4,25 @@ require_relative "bigwig/version"
 require_relative "bigwig/bigwigext"
 
 module Bio
+  # BigWig/BigBed file reader for Ruby
+  #
+  # @example Reading a local BigWig file
+  #   Bio::BigWig.open("file.bw") do |bw|
+  #     puts bw.header
+  #     puts bw.chroms
+  #   end
+  #
+  # @example Reading a remote BigWig file
+  #   Bio::BigWig.open("https://example.com/file.bw") do |bw|
+  #     values = bw.values("chr1", 0, 1000)
+  #   end
   class BigWig
+    # Open a BigWig/BigBed file
+    #
+    # @param args [Array] file path or URL
+    # @param kwargs [Hash] options
+    # @return [BigWig] file handle
+    # @yield [BigWig] file handle for block usage
     def self.open(*args, **kwargs)
       file = new(*args, **kwargs)
       return file unless block_given?
@@ -17,6 +35,10 @@ module Bio
       file
     end
 
+    # Initialize a BigWig/BigBed file handle
+    #
+    # @param fname [String] file path or URL
+    # @param mode [String] file mode (default: "r")
     def initialize(fname, mode = "r")
       raise "BigWig::new() does not take block; use BigWig::open() instead" if block_given?
 
@@ -24,24 +46,88 @@ module Bio
       initialize_raw(fname, mode)
     end
 
+    # Get the file path
+    #
+    # @return [String] file path or URL
     def path
       @fname
     end
 
+    # Get statistics for a genomic region
+    #
+    # @param chrom [String] chromosome name
+    # @param start [Integer, nil] start position (0-based)
+    # @param stop [Integer, nil] stop position (0-based)
+    # @param nbins [Integer, nil] number of bins
+    # @param type [String, Symbol, nil] statistic type ("mean", "max", "min", "sum", "coverage", "std")
+    # @param exact [Boolean, nil] use exact calculation
+    # @return [Array<Float>] statistics values
     def stats(chrom, start = nil, stop = nil, nbins: nil, type: nil, exact: nil)
       stats_raw(chrom, start, stop, nbins, type&.to_s, exact)
     end
 
+    # Get values for a genomic region
+    #
+    # @param chrom [String] chromosome name
+    # @param start [Integer] start position (0-based)
+    # @param stop [Integer] stop position (0-based)
+    # @return [Array<Float>] values
     def values(chrom, start, stop)
       values_raw(chrom, start, stop)
     end
 
+    # Get intervals for a genomic region
+    #
+    # @param chrom [String] chromosome name
+    # @param start [Integer] start position (0-based, default: 0)
+    # @param stop [Integer] stop position (0-based, default: -1 for end of chromosome)
+    # @return [Array<Array>] intervals as [start, end, value]
     def intervals(chrom, start = 0, stop = -1)
       intervals_raw(chrom, start, stop)
     end
 
+    # Get entries for a genomic region (BigBed files only)
+    #
+    # @param chrom [String] chromosome name
+    # @param start [Integer] start position (0-based, default: 0)
+    # @param stop [Integer] stop position (0-based, default: -1 for end of chromosome)
+    # @param with_string [Boolean] include string data (default: true)
+    # @return [Array<Array>] entries as [start, end, string] or [start, end]
     def entries(chrom, start = 0, stop = -1, with_string: true)
       entries_raw(chrom, start, stop, with_string)
     end
+
+    # @!method close
+    #   Close the file handle
+    #   @return [nil]
+
+    # @!method closed?
+    #   Check if the file is closed
+    #   @return [Boolean] true if closed, false if open
+
+    # @!method chroms(chrom = nil)
+    #   Get chromosome information
+    #   @param chrom [String, nil] specific chromosome name (optional)
+    #   @return [Hash, Integer, nil] all chromosomes as Hash, or length of specific chromosome, or nil if not found
+
+    # @!method header
+    #   Get file header information
+    #   @return [Hash] header information including version, levels, bases_covered, min_val, max_val, sum_data, sum_squared
+
+    # @!method file_type
+    #   Get file type
+    #   @return [String] "BigWig" or "BigBed"
+
+    # @!method is_bigwig?
+    #   Check if file is BigWig format
+    #   @return [Boolean] true if BigWig, false otherwise
+
+    # @!method is_bigbed?
+    #   Check if file is BigBed format
+    #   @return [Boolean] true if BigBed, false otherwise
+
+    # @!method sql
+    #   Get SQL schema (BigBed files only)
+    #   @return [String, nil] SQL schema string, or nil if not available
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bio-bigwig
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - kojix2
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-09-30 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: This is a Ruby binding for libBigWig (https://github.com/dpryan79/libBigWig),
   which provides high-speed access to bigWig or bigBed files.
@@ -40,7 +39,6 @@ homepage: https://github.com/kojix2/bio-bigwig
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -55,8 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A ruby library for accessing bigWig / bigBed files
 test_files: []