Update to htslib 1.10.2

.gitignore

@@ -1,4 +1,5 @@
 .vscode/
+.idea
 *~
 target
 Cargo.lock

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "htslib"]
 	path = hts-sys/htslib
-	url = https://github.com/rust-bio/htslib.git
+	url = https://github.com/samtools/htslib.git

.travis.yml

@@ -1,18 +1,42 @@
+dist: bionic
 language: rust
 
 rust:
   - stable
+  - nightly
+
+os:
+  - linux
+  - osx
+
+matrix:
+  fast_finish: true
+  allow_failures:
+    - rust: nightly
+  include:
+    - os: linux
+      dist: bionic
+    - os: osx
+      osx_image: xcode11
 
 cache:
   directories:
     - /home/travis/.cargo
 before_cache:
   - rm -rf /home/travis/.cargo/registry
 
+# Manually handle git submodules
+git:
+  submodules: false
+
+before_install:
+  - git submodule update --init --recursive
+
 addons:
   apt:
     packages:
-      - libcurl4-openssl-dev
+      - build-essential
+      - libssl-dev
       - libelf-dev
       - libdw-dev
       - libbz2-dev
@@ -22,8 +46,6 @@ addons:
       - musl
       - musl-dev
       - musl-tools
-    sources:
-      - kalakris-cmake
 
 before_script:
   - export PATH=$HOME/.cargo/bin:$PATH

Cargo.toml

@@ -30,12 +30,13 @@ serde_base = { version = "^1", optional = true, package = "serde" }
 serde_bytes = { version = "0.11", optional = true }
 bio-types = ">=0.5.1"
 snafu = ">= 0.5.0, <= 0.6.0"
-hts-sys = { version = "^1.9", path = "hts-sys" }
+hts-sys = { version = "^1.9", path = "hts-sys", default-features = false }
 
 [features]
-default = ["bzip2", "lzma"]
+default = ["bzip2", "lzma", "curl"]
 bzip2 = ["hts-sys/bzip2"]
 lzma = ["hts-sys/lzma"]
+curl = ["hts-sys/curl"]
 serde = ["serde_base", "serde_bytes"]
 
 [dev-dependencies]

README.md

@@ -19,7 +19,11 @@ If you only want to use the library, there is no need to clone the repository. G
 
 ## Requirements
 
-To compile this crate you need the development headers of zlib, bzip2 and xz.
+To compile this crate you need the development headers of zlib, bzip2 and xz. For instance, in Debian systems one needs the following dependencies:
+
+```shell
+$ sudo apt-get install zlib1g-dev libbz2-dev liblzma-dev clang
+```
 
 ## Usage
 

hts-sys/Cargo.toml

@@ -8,7 +8,7 @@ description = "This library provides HTSlib bindings."
 readme = "README.md"
 keywords = ["htslib", "bam", "bioinformatics", "pileup", "sequencing"]
 license = "MIT"
-repository = "https://github.com/rust-bio/rust-htslib.git"
+repository = "https://github.com/samtools/rust-htslib.git"
 documentation = "https://docs.rs/rust-htslib"
 edition = "2018"
 
@@ -21,11 +21,13 @@ libc = "0.2"
 libz-sys = "1.0"
 bzip2-sys = { version = "0.1", optional = true }
 lzma-sys = { version = "0.1", optional = true }
+curl-sys = { version = "0.4.25", optional = true }
 
 [features]
-default = ["bzip2", "lzma"]
+default = ["bzip2", "lzma", "curl"]
 bzip2 = ["bzip2-sys"]
 lzma = ["lzma-sys"]
+curl = ["curl-sys"]
 
 [build-dependencies]
 fs-utils = "1.1"

hts-sys/build.rs

@@ -63,6 +63,14 @@ fn main() {
         cfg.include(inc);
     }
 
+    let use_curl = env::var("CARGO_FEATURE_CURL").is_ok();
+    if !use_curl {
+        let curl_patterns = vec!["s/ -lcurl//", "/#define HAVE_LIBCURL/d"];
+        sed_htslib_makefile(&out, &curl_patterns, "curl");
+    } else if let Ok(inc) = env::var("DEP_CURL_INCLUDE").map(PathBuf::from) {
+        cfg.include(inc);
+    }
+
     let tool = cfg.get_compiler();
     let (cc_path, cflags_env) = (tool.path(), tool.cflags_env());
     let cc_cflags = cflags_env.to_string_lossy().replace("-O0", "");

src/bam/buffer.rs

@@ -86,7 +86,7 @@ impl RecordBuffer {
                 let to_remove = self
                     .inner
                     .iter()
-                    .take_while(|rec| rec.pos() < window_start as i32)
+                    .take_while(|rec| rec.pos() < window_start as i64)
                     .count();
                 for _ in 0..to_remove {
                     self.inner.pop_front();
@@ -111,7 +111,7 @@ impl RecordBuffer {
                     record.cache_cigar();
                 }
 
-                if pos >= end as i32 {
+                if pos >= end as i64 {
                     self.overflow = Some(record);
                     break;
                 } else {

src/bam/ext.rs

@@ -21,30 +21,30 @@ pub trait BamRecordExtensions {
     /// this happens on insertions.
     ///
     /// pysam: blocks
-    fn aligned_blocks(&self) -> Vec<[i32; 2]>;
+    fn aligned_blocks(&self) -> Vec<[i64; 2]>;
 
     /// find intron positions (start, stop)
     ///
     /// This scans the CIGAR for reference skips
     /// and reports their positions.
     ///
     /// pysam: get_introns
-    fn introns(&self) -> Vec<[i32; 2]>;
+    fn introns(&self) -> Vec<[i64; 2]>;
 
     /// a list of aligned read and reference positions
     ///
     /// No entry for insertions, deletions or skipped pairs
     ///
     /// pysam: get_aligned_pairs(matches_only = True)
-    fn aligned_pairs(&self) -> Vec<[i32; 2]>;
+    fn aligned_pairs(&self) -> Vec<[i64; 2]>;
 
     /// a list of aligned read and reference positions
     ///
     /// None in either the read positions or the reference position
     /// for insertions, deletions or skipped pairs
     ///
     /// pysam: aligned_pairs(matches_only = False)
-    fn aligned_pairs_full(&self) -> Vec<[Option<i32>; 2]>;
+    fn aligned_pairs_full(&self) -> Vec<[Option<i64>; 2]>;
 
     /// the number of nucleotides covered by each Cigar:: possibility
     ///
@@ -67,19 +67,19 @@ pub trait BamRecordExtensions {
     /// or unaligned positions within the read
     ///
     /// pysam: get_reference_positions(full_length=False)
-    fn reference_positions(&self) -> Vec<i32>;
+    fn reference_positions(&self) -> Vec<i64>;
     ///
     /// a Vec of reference positions that this read aligns to
     ///
     /// include soft-clipped or skipped positions as None
     ///
     /// pysam: get_reference_positions(full_length=True)
-    fn reference_positions_full(&self) -> Vec<Option<i32>>;
+    fn reference_positions_full(&self) -> Vec<Option<i64>>;
 
     /// left most aligned reference position of the read on the reference genome.
-    fn reference_start(&self) -> i32;
+    fn reference_start(&self) -> i64;
     /// right most aligned reference position of the read on the reference genome.
-    fn reference_end(&self) -> i32;
+    fn reference_end(&self) -> i64;
 
     /// infer the query length from the cigar string, optionally include hard clipped bases
     ///
@@ -91,34 +91,34 @@ pub trait BamRecordExtensions {
 }
 
 impl BamRecordExtensions for bam::Record {
-    fn aligned_blocks(&self) -> Vec<[i32; 2]> {
+    fn aligned_blocks(&self) -> Vec<[i64; 2]> {
         let mut result = Vec::new();
         let mut pos = self.pos();
         for entry in self.cigar().iter() {
             match entry {
                 Cigar::Match(len) => {
-                    result.push([pos, pos + *len as i32]);
-                    pos += *len as i32;
+                    result.push([pos, pos + *len as i64]);
+                    pos += *len as i64;
                 }
-                Cigar::Del(len) => pos += *len as i32,
-                Cigar::RefSkip(len) => pos += *len as i32,
+                Cigar::Del(len) => pos += *len as i64,
+                Cigar::RefSkip(len) => pos += *len as i64,
                 _ => (),
             }
         }
         result
     }
 
-    fn introns(&self) -> Vec<[i32; 2]> {
+    fn introns(&self) -> Vec<[i64; 2]> {
         let mut base_position = self.pos();
         let mut result = Vec::new();
         for entry in self.cigar().iter() {
             match entry {
                 Cigar::Match(len) | Cigar::Del(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
-                    base_position += *len as i32
+                    base_position += *len as i64
                 }
                 Cigar::RefSkip(len) => {
                     let junc_start = base_position;
-                    base_position += *len as i32;
+                    base_position += *len as i64;
                     result.push([junc_start, base_position]);
                 }
                 _ => {}
@@ -127,25 +127,25 @@ impl BamRecordExtensions for bam::Record {
         result
     }
 
-    fn aligned_pairs(&self) -> Vec<[i32; 2]> {
+    fn aligned_pairs(&self) -> Vec<[i64; 2]> {
         let mut result = Vec::new();
 
-        let mut pos: i32 = self.pos();
-        let mut qpos: i32 = 0;
+        let mut pos: i64 = self.pos();
+        let mut qpos: i64 = 0;
         for entry in self.cigar().iter() {
             match entry {
                 Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
-                    for i in pos..(pos + *len as i32) {
+                    for i in pos..(pos + *len as i64) {
                         result.push([qpos, i]);
                         qpos += 1;
                     }
-                    pos += *len as i32;
+                    pos += *len as i64;
                 }
                 Cigar::Ins(len) | Cigar::SoftClip(len) => {
-                    qpos += *len as i32;
+                    qpos += *len as i64;
                 }
                 Cigar::Del(len) | Cigar::RefSkip(len) => {
-                    pos += *len as i32;
+                    pos += *len as i64;
                 }
                 Cigar::HardClip(_) => {} // no advance
                 Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
@@ -154,31 +154,31 @@ impl BamRecordExtensions for bam::Record {
         result
     }
 
-    fn aligned_pairs_full(&self) -> Vec<[Option<i32>; 2]> {
+    fn aligned_pairs_full(&self) -> Vec<[Option<i64>; 2]> {
         let mut result = Vec::new();
 
-        let mut pos: i32 = self.pos();
-        let mut qpos: i32 = 0;
+        let mut pos: i64 = self.pos();
+        let mut qpos: i64 = 0;
         for entry in self.cigar().iter() {
             match entry {
                 Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
-                    for i in pos..(pos + *len as i32) {
+                    for i in pos..(pos + *len as i64) {
                         result.push([Some(qpos), Some(i)]);
                         qpos += 1;
                     }
-                    pos += *len as i32;
+                    pos += *len as i64;
                 }
                 Cigar::Ins(len) | Cigar::SoftClip(len) => {
-                    for i in qpos..(qpos + *len as i32) {
+                    for i in qpos..(qpos + *len as i64) {
                         result.push([Some(i), None]);
                     }
-                    qpos += *len as i32;
+                    qpos += *len as i64;
                 }
                 Cigar::Del(len) | Cigar::RefSkip(len) => {
-                    for i in pos..(pos + *len as i32) {
+                    for i in pos..(pos + *len as i64) {
                         result.push([None, Some(i)]);
                     }
-                    pos += *len as i32;
+                    pos += *len as i64;
                 }
                 Cigar::HardClip(_) => {} // no advance
                 Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
@@ -244,21 +244,21 @@ impl BamRecordExtensions for bam::Record {
         result
     }
 
-    fn reference_positions(&self) -> Vec<i32> {
+    fn reference_positions(&self) -> Vec<i64> {
         self.aligned_pairs().iter().map(|x| x[1]).collect()
     }
 
-    fn reference_positions_full(&self) -> Vec<Option<i32>> {
+    fn reference_positions_full(&self) -> Vec<Option<i64>> {
         self.aligned_pairs_full()
             .iter()
             .filter(|x| x[0].is_some())
             .map(|x| x[1])
             .collect()
     }
-    fn reference_start(&self) -> i32 {
+    fn reference_start(&self) -> i64 {
         self.pos()
     }
-    fn reference_end(&self) -> i32 {
+    fn reference_end(&self) -> i64 {
         unsafe { htslib::bam_endpos(self.inner_ptr()) }
     }
 
@@ -4304,11 +4304,11 @@ mod tests {
 
         //
         //for the rest, we just verify that they have the expected amount of None in each position
-        fn some_count(pairs: &Vec<[Option<i32>; 2]>, pos: usize) -> i32 {
-            pairs.iter().filter(|x| x[pos].is_some()).count() as i32
+        fn some_count(pairs: &Vec<[Option<i64>; 2]>, pos: usize) -> i64 {
+            pairs.iter().filter(|x| x[pos].is_some()).count() as i64
         }
-        fn none_count(pairs: &Vec<[Option<i32>; 2]>, pos: usize) -> i32 {
-            pairs.iter().filter(|x| x[pos].is_none()).count() as i32
+        fn none_count(pairs: &Vec<[Option<i64>; 2]>, pos: usize) -> i64 {
+            pairs.iter().filter(|x| x[pos].is_none()).count() as i64
         }
 
         let pairs = it.next().unwrap().unwrap().aligned_pairs_full();