bio-bigwig 0.0.1

data/ext/bio/bigwig/libBigWig/test/testLocal.c

@@ -0,0 +1,223 @@
+#include "bigWig.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <assert.h>
+
+void bwPrintHdr(bigWigFile_t *bw) {
+    uint64_t i;
+    int64_t i64;
+    printf("Version:    %"PRIu16"\n", bw->hdr->version);
+    printf("Levels:     %"PRIu16"\n", bw->hdr->nLevels);
+    printf("ctOffset:   0x%"PRIx64"\n", bw->hdr->ctOffset);
+    printf("dataOffset: 0x%"PRIx64"\n", bw->hdr->dataOffset);
+    printf("indexOffset:        0x%"PRIx64"\n", bw->hdr->indexOffset);
+    printf("sqlOffset:  0x%"PRIx64"\n", bw->hdr->sqlOffset);
+    printf("summaryOffset:      0x%"PRIx64"\n", bw->hdr->summaryOffset);
+    printf("bufSize:    %"PRIu32"\n", bw->hdr->bufSize);
+    printf("extensionOffset:    0x%"PRIx64"\n", bw->hdr->extensionOffset);
+
+    if(bw->hdr->nLevels) {
+        printf("	i	level	data	index\n");
+    }
+    for(i=0; i<bw->hdr->nLevels; i++) {
+        printf("\t%"PRIu64"\t%"PRIu32"\t%"PRIx64"\t%"PRIx64"\n", i, bw->hdr->zoomHdrs->level[i], bw->hdr->zoomHdrs->dataOffset[i], bw->hdr->zoomHdrs->indexOffset[i]);
+    }
+
+    printf("nBasesCovered:      %"PRIu64"\n", bw->hdr->nBasesCovered);
+    printf("minVal:     %f\n", bw->hdr->minVal);
+    printf("maxVal:     %f\n", bw->hdr->maxVal);
+    printf("sumData:    %f\n", bw->hdr->sumData);
+    printf("sumSquared: %f\n", bw->hdr->sumSquared);
+
+    //Chromosome idx/name/length
+    if(bw->cl) {
+        printf("Chromosome List\n");
+        printf("  idx\tChrom\tLength (bases)\n");
+        for(i64=0; i64<bw->cl->nKeys; i64++) {
+            printf("  %"PRIu64"\t%s\t%"PRIu32"\n", i64, bw->cl->chrom[i64], bw->cl->len[i64]);
+        }
+    }
+}
+
+void bwPrintIndexNode(bwRTreeNode_t *node, int level) {
+    uint16_t i;
+    if(!node) return;
+    for(i=0; i<node->nChildren; i++) {
+        if(node->isLeaf) {
+            printf("  %i\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t0x%"PRIx64"\t%"PRIu64"\n", level,\
+                node->chrIdxStart[i], \
+                node->baseStart[i], \
+                node->chrIdxEnd[i], \
+                node->baseEnd[i], \
+                node->dataOffset[i], \
+                node->x.size[i]);
+        } else {
+            printf("  %i\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t0x%"PRIx64"\tNA\n", level,\
+                node->chrIdxStart[i], \
+                node->baseStart[i], \
+                node->chrIdxEnd[i], \
+                node->baseEnd[i], \
+                node->dataOffset[i]);
+            bwPrintIndexNode(node->x.child[i], level+1);
+        }
+    }
+}
+
+void bwPrintIndexTree(bigWigFile_t *fp) {
+    printf("\nIndex tree:\n");
+    printf("nItems:\t%"PRIu64"\n", fp->idx->nItems);
+    printf("chrIdxStart:\t%"PRIu32"\n", fp->idx->chrIdxStart);
+    printf("baseStart:\t%"PRIu32"\n", fp->idx->baseStart);
+    printf("chrIdxEnd:\t%"PRIu32"\n", fp->idx->chrIdxEnd);
+    printf("baseEnd:\t%"PRIu32"\n", fp->idx->baseEnd);
+    printf("idxSize:\t%"PRIu64"\n", fp->idx->idxSize);
+    printf("  level\tchrIdxStart\tbaseStart\tchrIdxEnd\tbaseEnd\tchild\tsize\n");
+    bwPrintIndexNode(fp->idx->root, 0);
+}
+
+void printIntervals(bwOverlappingIntervals_t *ints, uint32_t start) {
+    uint32_t i;
+    if(!ints) return;
+    for(i=0; i<ints->l; i++) {
+        if(ints->start && ints->end) {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, ints->start[i], ints->end[i], ints->value[i]);
+        } else if(ints->start) {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, ints->start[i], ints->start[i]+1, ints->value[i]);
+        } else {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, start+i, start+i+1, ints->value[i]);
+        }
+    }
+}
+
+int main(int argc, char *argv[]) {
+    bigWigFile_t *fp = NULL;
+    bwOverlappingIntervals_t *intervals = NULL;
+    double *stats = NULL;
+    if(argc != 2) {
+        fprintf(stderr, "Usage: %s {file.bw|URL://path/file.bw}\n", argv[0]);
+        return 1;
+    }
+
+    if(bwInit(1<<17) != 0) {
+        fprintf(stderr, "Received an error in bwInit\n");
+        return 1;
+    }
+
+    assert(bwIsBigWig(argv[1], NULL) == 1);
+    assert(bbIsBigBed(argv[1], NULL) == 0);
+
+    fp = bwOpen(argv[1], NULL, "r");
+    if(!fp) {
+        fprintf(stderr, "An error occured while opening %s\n", argv[1]);
+        return 1;
+    }
+
+    bwPrintHdr(fp);
+    bwPrintIndexTree(fp);
+
+    //Try to get some blocks
+    printf("1:0-99\n");
+    intervals = bwGetValues(fp, "1", 0, 99, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("1:99-1000\n");
+    intervals = bwGetValues(fp, "1", 99, 1000, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("1:99-150\n");
+    intervals = bwGetValues(fp, "1", 99, 150, 1);
+    printIntervals(intervals,99);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("1:99-100\n");
+    intervals = bwGetValues(fp, "1", 99, 100, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("1:151-1000\n");
+    intervals = bwGetValues(fp, "1", 151, 1000, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("chr1:0-100\n");
+    intervals = bwGetValues(fp, "chr1", 0, 100, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    stats = bwStats(fp, "1", 0, 200, 1, mean);
+    assert(stats);
+    printf("1:0-1000 mean: %f\n", *stats);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 2, mean);
+    assert(stats);
+    printf("1:0-1000 mean: %f %f\n", stats[0], stats[1]);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 1, dev);
+    assert(stats);
+    printf("1:0-1000 std. dev.: %f\n", *stats);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 2, dev);
+    assert(stats);
+    printf("1:0-1000 std. dev.: %f %f\n", stats[0], stats[1]);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 1, min);
+    assert(stats);
+    printf("1:0-1000 min: %f\n", *stats);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 2, min);
+    assert(stats);
+    printf("1:0-1000 min: %f %f\n", stats[0], stats[1]);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 1, max);
+    assert(stats);
+    printf("1:0-1000 max: %f\n", *stats);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 2, max);
+    assert(stats);
+    printf("1:0-1000 max: %f %f\n", stats[0], stats[1]);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 1, cov);
+    assert(stats);
+    printf("1:0-1000 coverage: %f\n", *stats);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 2, cov);
+    assert(stats);
+    printf("1:0-1000 coverage: %f %f\n", stats[0], stats[1]);
+    free(stats);
+
+    stats = bwStats(fp, "1", 0, 200, 1, sum);
+    assert(stats);
+    printf("1:0-200 sum: %f\n", *stats); //72.1
+    free(stats);
+
+    stats = bwStats(fp, "1", 100, 151, 2, sum);
+    assert(stats);
+    printf("1:0-200 sum: %f %f\n", stats[0], stats[1]); //35.0, 36.5
+    free(stats);
+
+    printf("1:0-200000000 intervals\n");
+    intervals = bwGetOverlappingIntervals(fp, "1", 0, 200000000);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("10:0-200000000 intervals\n");
+    intervals = bwGetOverlappingIntervals(fp, "10", 0, 200000000);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    bwClose(fp);
+    bwCleanup();
+    return 0;
+}

data/ext/bio/bigwig/libBigWig/test/testRemote.c

@@ -0,0 +1,203 @@
+#include "bigWig.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <assert.h>
+
+//Print overly verbose header information
+void bwPrintHdr(bigWigFile_t *bw) {
+    uint64_t i;
+    int64_t i64;
+    printf("Version:    %"PRIu16"\n", bw->hdr->version);
+    printf("Levels:     %"PRIu16"\n", bw->hdr->nLevels);
+    printf("ctOffset:   0x%"PRIx64"\n", bw->hdr->ctOffset);
+    printf("dataOffset: 0x%"PRIx64"\n", bw->hdr->dataOffset);
+    printf("indexOffset:        0x%"PRIx64"\n", bw->hdr->indexOffset);
+    printf("sqlOffset:  0x%"PRIx64"\n", bw->hdr->sqlOffset);
+    printf("summaryOffset:      0x%"PRIx64"\n", bw->hdr->summaryOffset);
+    printf("bufSize:    %"PRIu32"\n", bw->hdr->bufSize);
+    printf("extensionOffset:    0x%"PRIx64"\n", bw->hdr->extensionOffset);
+
+    if(bw->hdr->nLevels) {
+        printf("	i	level	data	index\n");
+    }
+    for(i=0; i<bw->hdr->nLevels; i++) {
+        printf("\t%"PRIu64"\t%"PRIu32"\t%"PRIx64"\t%"PRIx64"\n", i, bw->hdr->zoomHdrs->level[i], bw->hdr->zoomHdrs->dataOffset[i], bw->hdr->zoomHdrs->indexOffset[i]);
+    }
+
+    printf("nBasesCovered:      %"PRIu64"\n", bw->hdr->nBasesCovered);
+    printf("minVal:     %f\n", bw->hdr->minVal);
+    printf("maxVal:     %f\n", bw->hdr->maxVal);
+    printf("sumData:    %f\n", bw->hdr->sumData);
+    printf("sumSquared: %f\n", bw->hdr->sumSquared);
+
+    //Chromosome idx/name/length
+    if(bw->cl) {
+        printf("Chromosome List\n");
+        printf("  idx\tChrom\tLength (bases)\n");
+        for(i64=0; i64<bw->cl->nKeys; i64++) {
+            printf("  %"PRIu64"\t%s\t%"PRIu32"\n", i64, bw->cl->chrom[i64], bw->cl->len[i64]);
+        }
+    }
+}
+
+void bwPrintIndexNode(bwRTreeNode_t *node, int level) {
+    uint16_t i;
+    if(!node) return;
+    for(i=0; i<node->nChildren; i++) {
+        if(node->isLeaf) {
+            printf("  %i\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t0x%"PRIx64"\t%"PRIu64"\n", level,\
+                node->chrIdxStart[i], \
+                node->baseStart[i], \
+                node->chrIdxEnd[i], \
+                node->baseEnd[i], \
+                node->dataOffset[i], \
+                node->x.size[i]);
+        } else {
+            printf("  %i\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t%"PRIu32"\t0x%"PRIx64"\tNA\n", level,\
+                node->chrIdxStart[i], \
+                node->baseStart[i], \
+                node->chrIdxEnd[i], \
+                node->baseEnd[i], \
+                node->dataOffset[i]);
+            bwPrintIndexNode(node->x.child[i], level+1);
+        }
+    }
+}
+
+void bwPrintIndexTree(bigWigFile_t *fp) {
+    printf("\nIndex tree:\n");
+    printf("nItems:\t%"PRIu64"\n", fp->idx->nItems);
+    printf("chrIdxStart:\t%"PRIu32"\n", fp->idx->chrIdxStart);
+    printf("baseStart:\t%"PRIu32"\n", fp->idx->baseStart);
+    printf("chrIdxEnd:\t%"PRIu32"\n", fp->idx->chrIdxEnd);
+    printf("baseEnd:\t%"PRIu32"\n", fp->idx->baseEnd);
+    printf("idxSize:\t%"PRIu64"\n", fp->idx->idxSize);
+    printf("  level\tchrIdxStart\tbaseStart\tchrIdxEnd\tbaseEnd\tchild\tsize\n");
+    bwPrintIndexNode(fp->idx->root, 0);
+}
+
+void printIntervals(bwOverlappingIntervals_t *ints, uint32_t start) {
+    uint32_t i;
+    if(!ints) return;
+    for(i=0; i<ints->l; i++) {
+        if(ints->start && ints->end) {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, ints->start[i], ints->end[i], ints->value[i]);
+        } else if(ints->start) {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, ints->start[i], ints->start[i]+1, ints->value[i]);
+        } else {
+            printf("Interval %"PRIu32"\t%"PRIu32"-%"PRIu32": %f\n",i, start+i, start+i+1, ints->value[i]);
+        }
+    }
+}
+
+//This is an example call back function
+CURLcode callBack(CURL *curl) {
+    CURLcode rv;
+
+    rv = curl_easy_setopt(curl, CURLOPT_USERNAME, "anonymous");
+    if(rv != CURLE_OK) return rv;
+
+    rv = curl_easy_setopt(curl, CURLOPT_PASSWORD, "libBigWig@github.com");
+    return rv;
+}
+
+int main(int argc, char *argv[]) {
+    bigWigFile_t *fp = NULL;
+    bwOverlappingIntervals_t *intervals = NULL;
+    double *stats = NULL;
+    char chrom[] = "chr1";
+    if(argc != 2) {
+        fprintf(stderr, "Usage: %s {file.bw|URL://path/file.bw}\n", argv[0]);
+        return 1;
+    }
+
+    if(bwInit(1<<17) != 0) {
+        fprintf(stderr, "Received an error in bwInit\n");
+        return 1;
+    }
+
+    fp = bwOpen(argv[1], callBack, "r");
+    if(!fp) {
+        fprintf(stderr, "An error occured while opening %s\n", argv[1]);
+        return 1;
+    }
+
+    bwPrintHdr(fp);
+    bwPrintIndexTree(fp);
+
+    //Try to get some blocks
+    printf("%s:10000000-10000100 Intervals\n", chrom);
+    intervals = bwGetOverlappingIntervals(fp, chrom, 10000000, 10000100);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    printf("%s:10000000-10000100 Values\n", chrom);
+    intervals = bwGetValues(fp, chrom, 10000000, 10000100, 0);
+    printIntervals(intervals,0);
+    bwDestroyOverlappingIntervals(intervals);
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 1, mean);
+    if(stats) {
+        printf("%s:10000000-10000100 mean: %f\n", chrom, stats[0]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 2, mean);
+    if(stats) {
+        printf("%s:10000000-10000100 mean: %f %f\n", chrom, stats[0], stats[1]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 1, dev);
+    if(stats) {
+        printf("%s:10000000-10000100 std. dev.: %f\n", chrom, stats[0]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 2, dev);
+    if(stats) {
+        printf("%s:10000000-10000100 std. dev.: %f %f\n", chrom, stats[0], stats[1]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 1, min);
+    if(stats) {
+        printf("%s:10000000-10000100 min: %f\n", chrom, stats[0]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 2, min);
+    if(stats) {
+        printf("%s:10000000-10000100 min: %f %f\n", chrom, stats[0], stats[1]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 1, max);
+    if(stats) {
+        printf("%s:10000000-10000100 max: %f\n", chrom, stats[0]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 2, max);
+    if(stats) {
+        printf("%s:10000000-10000100 max: %f %f\n", chrom, stats[0], stats[1]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 1, cov);
+    if(stats) {
+        printf("%s:10000000-10000100 coverage: %f\n", chrom, stats[0]);
+        free(stats);
+    }
+
+    stats = bwStats(fp, chrom, 10000000, 10000100, 2, cov);
+    if(stats) {
+        printf("%s:10000000-10000100 coverage: %f %f\n", chrom, stats[0], stats[1]);
+        free(stats);
+    }
+
+    bwClose(fp);
+    bwCleanup();
+    return 0;
+}

data/ext/bio/bigwig/libBigWig/test/testRemoteManyContigs.c

@@ -0,0 +1,46 @@
+#include "bigWig.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <assert.h>
+
+//This is an example call back function
+CURLcode callBack(CURL *curl) {
+    CURLcode rv;
+
+    rv = curl_easy_setopt(curl, CURLOPT_USERNAME, "anonymous");
+    if(rv != CURLE_OK) return rv;
+
+    rv = curl_easy_setopt(curl, CURLOPT_PASSWORD, "libBigWig@github.com");
+    return rv;
+}
+
+int main(int argc, char *argv[]) {
+    bigWigFile_t *fp = NULL;
+    int64_t i;
+
+    if(argc != 2) {
+        fprintf(stderr, "Usage: %s {file.bw|URL://path/file.bw}\n", argv[0]);
+        return 1;
+    }
+
+    if(bwInit(1<<17) != 0) {
+        fprintf(stderr, "Received an error in bwInit\n");
+        return 1;
+    }
+
+    fp = bwOpen(argv[1], callBack, "r");
+    if(!fp) {
+        fprintf(stderr, "An error occured while opening %s\n", argv[1]);
+        return 1;
+    }
+
+    //Return the number of chromosomes/contigs
+    for(i=0; i<fp->cl->nKeys; i++) {
+        printf("%s\t%"PRIu32"\n", fp->cl->chrom[i], fp->cl->len[i]);
+    }
+
+    bwClose(fp);
+    bwCleanup();
+    return 0;
+}

data/ext/bio/bigwig/libBigWig/test/testWrite.c

@@ -0,0 +1,68 @@
+#include "bigWig.h"
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <assert.h>
+
+int main(int argc, char *argv[]) {
+    bigWigFile_t *ifp = NULL;
+    bigWigFile_t *ofp = NULL;
+    uint32_t tid, i;
+    char **chroms;
+    bwOverlappingIntervals_t *o;
+    if(argc != 3) {
+        fprintf(stderr, "Usage: %s {inputfile.bw|URL://path/inputfile.bw} outputfile.bw\n", argv[0]);
+        return 1;
+    }
+
+    if(bwInit(1<<17) != 0) {
+        fprintf(stderr, "Received an error in bwInit\n");
+        return 1;
+    }
+
+    ifp = bwOpen(argv[1], NULL, "r");
+    if(!ifp) {
+        fprintf(stderr, "An error occured while opening %s\n", argv[1]);
+        return 1;
+    }
+
+    ofp = bwOpen(argv[2], NULL, "w");
+    if(!ofp) {
+        bwClose(ifp);
+        fprintf(stderr, "An error occured while opening %s\n", argv[2]);
+        return 1;
+    }
+
+    if(bwCreateHdr(ofp, 10)) goto error; //ten zoom levels
+    ofp->cl = bwCreateChromList(ifp->cl->chrom, ifp->cl->len, ifp->cl->nKeys);
+    if(!ofp->cl) goto error;
+
+    if(bwWriteHdr(ofp)) goto error;
+
+    //Copy all of the intervals
+    for(tid = 0; tid < ofp->cl->nKeys; tid++) {
+        o = bwGetOverlappingIntervals(ifp, ofp->cl->chrom[tid], 0, ofp->cl->len[tid]);
+        if(!o) goto error;
+        if(o->l) {
+            chroms = malloc(o->l * sizeof(char*));
+            if(!chroms) goto error;
+            for(i=0; i<o->l; i++) chroms[i] = ofp->cl->chrom[tid];
+            bwAddIntervals(ofp, chroms, o->start, o->end, o->value, o->l);
+            free(chroms);
+        }
+        bwDestroyOverlappingIntervals(o);
+    }
+
+    bwClose(ifp);
+    bwClose(ofp);
+    bwCleanup();
+
+    return 0;
+
+error:
+    fprintf(stderr, "Got an error somewhere!\n");
+    bwClose(ifp);
+    bwClose(ofp);
+    bwCleanup();
+    return 1;
+}

data/lib/bio/bigwig/version.rb

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

data/lib/bio/bigwig.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "bigwig/version"
+require_relative "bigwig/bigwigext"
+
+module Bio
+  class BigWig
+    def self.open(*args, **kwargs)
+      file = new(*args, **kwargs)
+      return file unless block_given?
+
+      begin
+        yield file
+      ensure
+        file.close
+      end
+      file
+    end
+
+    def initialize(fname, mode = "r")
+      raise "BigWig::new() does not take block; use BigWig::open() instead" if block_given?
+
+      @fname = fname
+      initialize_raw(fname, mode)
+    end
+
+    def path
+      @fname
+    end
+
+    def stats(chrom, start = nil, stop = nil, nbins: nil, type: nil, exact: nil)
+      stats_raw(chrom, start, stop, nbins, type&.to_s, exact)
+    end
+
+    def values(chrom, start, stop)
+      values_raw(chrom, start, stop)
+    end
+
+    def intervals(chrom, start = 0, stop = -1)
+      intervals_raw(chrom, start, stop)
+    end
+
+    def entries(chrom, start = 0, stop = -1, text: true)
+      entries_raw(chrom, start, stop, text)
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: bio-bigwig
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- kojix2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-01-30 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.
+email:
+- 2xijok@gmail.com
+executables: []
+extensions:
+- ext/bio/bigwig/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- ext/bio/bigwig/bigwigext.c
+- ext/bio/bigwig/bigwigext.h
+- ext/bio/bigwig/extconf.rb
+- ext/bio/bigwig/libBigWig/LICENSE
+- ext/bio/bigwig/libBigWig/bigWig.h
+- ext/bio/bigwig/libBigWig/bigWigIO.h
+- ext/bio/bigwig/libBigWig/bwCommon.h
+- ext/bio/bigwig/libBigWig/bwRead.c
+- ext/bio/bigwig/libBigWig/bwStats.c
+- ext/bio/bigwig/libBigWig/bwValues.c
+- ext/bio/bigwig/libBigWig/bwValues.h
+- ext/bio/bigwig/libBigWig/bwWrite.c
+- ext/bio/bigwig/libBigWig/io.c
+- ext/bio/bigwig/libBigWig/test/exampleWrite.c
+- ext/bio/bigwig/libBigWig/test/testBigBed.c
+- ext/bio/bigwig/libBigWig/test/testIterator.c
+- ext/bio/bigwig/libBigWig/test/testLocal.c
+- ext/bio/bigwig/libBigWig/test/testRemote.c
+- ext/bio/bigwig/libBigWig/test/testRemoteManyContigs.c
+- ext/bio/bigwig/libBigWig/test/testWrite.c
+- lib/bio/bigwig.rb
+- lib/bio/bigwig/version.rb
+homepage: https://github.com/kojix2/bw-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key: 
+specification_version: 4
+summary: A ruby library for accessing bigWig / bigBed files
+test_files: []