minimap2 0.2.30.3 → 1.2.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a3bf89a18a50825f14454ce8683dd019377fc45e59a4d46eee617a55d0e64e8
-  data.tar.gz: c1dd61ced844c50b7aec1ba1f9da8d8b47ab3b94a1e2f4b0b4bcdd16169e4f0c
+  metadata.gz: 66111ad941edb14875a0f3c66f8ac1f5cbef18182bb96cb2a363f8ec29e6e817
+  data.tar.gz: 2ce71684a6a25196f7735252888cbdc1ff66674829edbb72d492184ecc171510
 SHA512:
-  metadata.gz: 198ae12116da51051dcac0665a85611a2d5bbe5df49ff854fff02c1f686f6c5fd7d40378876de81542d8ca9fe6fb8d71c0c59cde53497368ae4fc83b06a4c685
-  data.tar.gz: 1226cb572e95c805d3817bcaf5048fcc6a3bb217e7ac86b56f866b132c3ffe9ed5f8a1ba8e67b1bb798a1c2852e060f611229ccae9364b477a9863366717ce5c
+  metadata.gz: 6f708837128825a21efe2428ccef35f985c6de313d7dc2a669ef45b6ba17873a3672859fcc72c11f2dfd12af26686f5e5909f952a99fb7a519a37749d59798c4
+  data.tar.gz: '0083cf367e4bfd1c9eeeeea626289d97d064cc69efd47e1bcb50fddbe13ffece5f5d8b4f540926daaaa3224eed225227cd2a07b367d310bbf34a906c164dafb3'

data/README.md

@@ -4,16 +4,16 @@
 [![test](https://github.com/kojix2/ruby-minimap2/actions/workflows/ci.yml/badge.svg)](https://github.com/kojix2/ruby-minimap2/actions/workflows/ci.yml)
 [![Docs Latest](https://img.shields.io/badge/docs-latest-blue.svg)](https://kojix2.github.io/ruby-minimap2/)
 [![The MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
-[![DOI](https://zenodo.org/badge/325711305.svg)](https://zenodo.org/badge/latestdoi/325711305)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18489817.svg)](https://doi.org/10.5281/zenodo.18489817)
 [![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2Fruby-minimap2%2Flines)](https://tokei.kojix2.net/github/kojix2/ruby-minimap2)
 
 :dna: [minimap2](https://github.com/lh3/minimap2) - the long-read mapper - for [Ruby](https://github.com/ruby/ruby)
 
 ## Installation
 
-ruby-minimap2 bundles the Minimap2 C source code and builds it automatically during installation.
+ruby-minimap2 bundles the Minimap2 C source code and builds a native extension during installation.
 
-Just install the gem. Works on Linux, macOS, and Windows.
+Ruby 3.3 or later is required. Works on Linux, macOS, and Windows.
 
 ```
 gem install minimap2
@@ -41,29 +41,39 @@ ruby -r minimap2 -e 'Minimap2.execute("--version")'
 ```ruby
 require "minimap2"
 
-aligner = Minimap2::Aligner.new("ext/minimap2/test/MT-human.fa")
-seq     = aligner.seq("MT_human", 100, 200)
-hits    = aligner.align(seq)
+reference = <<~DNA.delete("\n")
+  GATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTATGCACGC
+  GATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTAT
+  CGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTAATTAATGCTTGTAGGACATAATAATAACA
+  ATTGAATGTCTGCACAGCCACTTTCCACACAGACATCATAACAAAAAATTTCCACCAAACCCCCCCTCCCCCGCTTC
+DNA
+
+aligner = Minimap2::Aligner.new(seq: reference)
+query   = reference[50, 200]
+hits    = aligner.align(query, name: "query", cs: true, ds: true)
 pp hits
 ```
 
 ```
 [#<Minimap2::Alignment:0x000055bbfde2d128
-  @blen=100,
-  @cigar=[[100, 0]],
-  @cigar_str="100M",
-  @cs="",
-  @ctg="MT_human",
-  @ctg_len=16569,
+  @blen=200,
+  @cigar=[[200, 0]],
+  @cigar_str="200M",
+  @cs=":200",
+  @ctg="N/A",
+  @ctg_len=320,
+  @ds=":200",
   @mapq=60,
-  @md="",
-  @mlen=100,
+  @md=nil,
+  @mlen=200,
   @nm=0,
   @primary=1,
-  @q_en=100,
+  @q_en=200,
   @q_st=0,
-  @r_en=200,
-  @r_st=100,
+  @qlen=200,
+  @qname="query",
+  @r_en=250,
+  @r_st=50,
   @read_num=1,
   @strand=1,
   @trans_strand=0>]
@@ -76,19 +86,25 @@ pp hits
   - fastx_read                  Read fasta/fastq file.
   - revcomp                     Reverse complement sequence.
   - execute                     Calls the main function of Minimap2 with arguments. `Minimap2.execute("--version")`
+  - verbose                     Returns the Minimap2 verbosity level.
+  - verbose=                    Sets the Minimap2 verbosity level.
 
   * Aligner class
-    * attributes
-      - index                   Returns the value of attribute index.
-      - idx_opt                 Returns the value of attribute idx_opt.
-      - map_opt                 Returns the value of attribute map_opt.
     * methods
-      - new(path, preset: nil)  Create a new aligner. (presets: sr, map-pb, map-out, map-hifi, splice, asm5, etc.)
+      - new(path, preset: nil)  Create a new aligner. (presets: sr, map-pb, map-ont, map-hifi, splice, asm5, etc.)
       - align                   Maps and returns alignments.
       - seq                     Retrieve a subsequence from the index.
+      - k                       Returns the minimizer k-mer length.
+      - w                       Returns the minimizer window size.
+      - n_seq                   Returns the number of sequences in the index.
+      - seq_names               Returns sequence names in the index.
+      - index?                  Returns whether the aligner has a live index.
+      - free_index              Releases the index.
 
   * Alignment class
     * attributes
+      - qname                   Returns the query sequence name.
+      - qlen                    Returns the query sequence length.
       - ctg                     Returns name of the reference sequence the query is mapped to.
       - ctg_len                 Returns total length of the reference sequence.
       - r_st                    Returns start positions on the reference.
@@ -104,46 +120,22 @@ pp hits
       - mapq                    Returns mapping quality.
       - cigar                   Returns CIGAR returned as an array of shape (n_cigar,2). The two numbers give the length and the operator of each CIGAR operation.
       - read_num                Returns read number that the alignment corresponds to; 1 for the first read and 2 for the second read.
-      - cs                      Returns the cs tag.
-      - md                      Returns the MD tag as in the SAM format. It is an empty string unless the md argument is applied when calling Aligner#align.
+      - cs                      Returns the cs tag, or nil unless requested.
+      - ds                      Returns the ds tag, or nil unless requested.
+      - md                      Returns the MD tag, or nil unless requested.
       - cigar_str               Returns CIGAR string.
     * methods
       - to_h                    Convert Alignment to hash.
-      - to_s                    Convert to the PAF format without the QueryName and QueryLength columns.
-
-  ## FFI module
-    * IdxOpt class              Indexing options.
-    * MapOpt class              Mapping options.
+      - to_s                    Convert to the PAF format.
 ```
 
 - API is based on [Mappy](https://github.com/lh3/minimap2/tree/master/python), the official Python binding for Minimap2.
 - `Aligner#map` has been changed to `align`, because `map` means iterator in Ruby.
+- Calls on the same Aligner are thread-safe and serialized. Different Aligner instances can run concurrently.
+- Multipart indexes are supported, but primary alignments and mapping quality are calculated independently for each part.
+- Sequence data uses ASCII-8BIT. Names read from an index use UTF-8.
 - See [documentation](https://kojix2.github.io/ruby-minimap2/) for details.
 
-<details>
-<summary><b>C Structures and Functions</b></summary>
-
-### FFI
-
-- Ruby-Minimap2 is built on top of [Ruby-FFI](https://github.com/ffi/ffi).
-  - Native C functions can be called from the `Minimap2::FFI` module.
-  - Native C structure members can be accessed.
-  - Bitfields are supported by [ffi-bitfield](https://github.com/kojix2/ffi-bitfield) gems.
-
-```ruby
-aligner.idx_opt.members
-# => [:k, :w, :flag, :bucket_bits, :mini_batch_size, :batch_size]
-aligner.kds_opt.values
-# => [15, 10, 0, 14, 50000000, 9223372036854775807]
-aligner.idx_opt[:k]
-# => 15
-aligner.idx_opt[:k] = 14
-aligner.idx_opt[:k]
-# => 14
-```
-
-</details>
-
 ## Contributing
 
 <details>
@@ -159,21 +151,14 @@ git clone --recursive https://github.com/kojix2/ruby-minimap2
 # git submodule update -i
 ```
 
-Build Minimap2 and Mappy.
+Build the native extension.
 
 ```sh
 cd ruby-minimap2
-bundle install # Install dependent packages including Ruby-FFI
+bundle install
 bundle exec rake minimap2:build
 ```
 
-A shared library will be created in the vendor directory.
-
-```
-└── vendor
-   └── libminimap2.so
-```
-
 Run tests.
 
 ```
@@ -185,7 +170,7 @@ Release a Gem.
 ```
 bundle exec rake minimap2:cleanall
 bundle exec rake build
-ls -l pkg # Check the size of the Gem and make sure it does not contain any unused code such as shared libraries or lib/simde.
+ls -l pkg # Check the size of the Gem.
 bundle exec rake release
 ```
 

data/ext/minimap2/Makefile

@@ -102,7 +102,7 @@ ksw2_exts2_neon.o:ksw2_exts2_sse.c ksw2.h kalloc.h
 # other non-file targets
 
 clean:
-		rm -fr gmon.out *.o a.out $(PROG) $(PROG_EXTRA) *~ *.a *.dSYM build dist mappy*.so mappy.c python/mappy.c mappy.egg*
+		rm -fr gmon.out *.o a.out $(PROG) $(PROG_EXTRA) *~ *.a *.dSYM build dist mappy*.so mappy.c python/mappy.c mappy.egg* .eggs
 
 depend:
 		(LC_ALL=C; export LC_ALL; makedepend -Y -- $(CFLAGS) $(CPPFLAGS) -- *.c)

data/ext/minimap2/format.c

@@ -361,24 +361,34 @@ static void write_cs_ds_or_MD(void *km, kstring_t *s, const mm_idx_t *mi, const
 	kfree(km, qseq); kfree(km, tseq); kfree(km, tmp);
 }
 
-int mm_gen_cs_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int no_iden, int is_qstrand)
+int mm_gen_cs_ds_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int is_ds, int no_iden, int is_qstrand)
 {
 	mm_bseq1_t t;
 	kstring_t str;
 	str.s = *buf, str.l = 0, str.m = *max_len;
 	t.l_seq = strlen(seq);
 	t.seq = (char*)seq;
-	write_cs_ds_or_MD(km, &str, mi, &t, r, no_iden, is_MD, 0, 0, is_qstrand);
+	write_cs_ds_or_MD(km, &str, mi, &t, r, no_iden, is_MD, is_ds, 0, is_qstrand);
 	*max_len = str.m;
 	*buf = str.s;
 	return str.l;
 }
 
+int mm_gen_cs_or_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int is_MD, int no_iden, int is_qstrand)
+{
+	return mm_gen_cs_ds_or_MD(km, buf, max_len, mi, r, seq, is_MD, 0, no_iden, is_qstrand);
+}
+
 int mm_gen_cs(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden)
 {
 	return mm_gen_cs_or_MD(km, buf, max_len, mi, r, seq, 0, no_iden, 0);
 }
 
+int mm_gen_ds(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden)
+{
+	return mm_gen_cs_ds_or_MD(km, buf, max_len, mi, r, seq, 0, 1, no_iden, 0);
+}
+
 int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq)
 {
 	return mm_gen_cs_or_MD(km, buf, max_len, mi, r, seq, 1, 0, 0);

data/ext/minimap2/hit.c

@@ -256,19 +256,25 @@ void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int chec
 {
 	if (pri_ratio > 0.0f && *n_ > 0) {
 		int i, k, n = *n_, n_2nd = 0;
-		for (i = k = 0; i < n; ++i) {
+		uint8_t *keep = (uint8_t*)kmalloc(km, n);
+		for (i = 0; i < n; ++i) {
 			int p = r[i].parent;
+			keep[i] = 0;
 			if (p == i || r[i].inv) { // primary or inversion
-				r[k++] = r[i];
+				keep[i] = 1;
 			} else if ((r[i].score >= r[p].score * pri_ratio || r[i].score + min_diff >= r[p].score) && n_2nd < best_n) {
 				if (!(r[i].qs == r[p].qs && r[i].qe == r[p].qe && r[i].rid == r[p].rid && r[i].rs == r[p].rs && r[i].re == r[p].re)) // not identical hits
-					r[k++] = r[i], ++n_2nd;
-				else if (r[i].p) free(r[i].p);
+					keep[i] = 1, ++n_2nd;
 			} else if (check_strand && n_2nd < best_n && r[i].score > min_strand_sc && r[i].rev != r[p].rev) {
 				r[i].strand_retained = 1;
-				r[k++] = r[i], ++n_2nd;
-			} else if (r[i].p) free(r[i].p);
+				keep[i] = 1, ++n_2nd;
+			}
+		}
+		for (i = k = 0; i < n; ++i) {
+			if (keep[i]) r[k++] = r[i];
+			else if (r[i].p) free(r[i].p);
 		}
+		kfree(km, keep);
 		if (k != n) mm_sync_regs(km, k, r); // removing hits requires sync()
 		*n_ = k;
 	}
@@ -277,13 +283,18 @@ void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int chec
 int mm_filter_strand_retained(int n_regs, mm_reg1_t *r)
 {
 	int i, k;
-	for (i = k = 0; i < n_regs; ++i) {
+	uint8_t *keep = (uint8_t*)malloc(n_regs);
+	for (i = 0; i < n_regs; ++i) {
 		int p = r[i].parent;
-		if (!r[i].strand_retained || r[i].div < r[p].div * 5.0f || r[i].div < 0.01f) {
+		keep[i] = (!r[i].strand_retained || r[i].div < r[p].div * 5.0f || r[i].div < 0.01f);
+	}
+	for (i = k = 0; i < n_regs; ++i) {
+		if (keep[i]) {
 			if (k < i) r[k++] = r[i];
 			else ++k;
 		}
 	}
+	free(keep);
 	return k;
 }
 

data/ext/minimap2/ksw2_ll_sse.c

@@ -67,7 +67,7 @@ void *ksw_ll_qinit(void *km, int size, int qlen, const uint8_t *query, int m, co
 			const int8_t *ma = mat + a * m;
 			for (i = 0; i < slen; ++i)
 				for (k = i; k < nlen; k += slen) // p iterations
-					*t++ = (k >= qlen? 0 : ma[query[k]]) + q->shift;
+					*t++ = (k >= qlen? -1 : ma[query[k]]) + q->shift;
 		}
 	} else {
 		int16_t *t = (int16_t*)q->qp;
@@ -76,7 +76,7 @@ void *ksw_ll_qinit(void *km, int size, int qlen, const uint8_t *query, int m, co
 			const int8_t *ma = mat + a * m;
 			for (i = 0; i < slen; ++i)
 				for (k = i; k < nlen; k += slen) // p iterations
-					*t++ = (k >= qlen? 0 : ma[query[k]]);
+					*t++ = (k >= qlen? -1 : ma[query[k]]);
 		}
 	}
 	return q;

data/ext/minimap2/minimap.h

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <sys/types.h>
 
-#define MM_VERSION "2.30-r1287"
+#define MM_VERSION "2.31-r1302"
 
 #define MM_F_NO_DIAG       (0x001LL) // no exact diagonal hit
 #define MM_F_NO_DUAL       (0x002LL) // skip pairs where query name is lexicographically larger than target name
@@ -408,6 +408,7 @@ int mm_map_file_frag(const mm_idx_t *idx, int n_segs, const char **fn, const mm_
  * @return the length of cs
  */
 int mm_gen_cs(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden);
+int mm_gen_ds(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq, int no_iden);
 int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq);
 
 // query sequence name and sequence in the minimap2 index

data/ext/minimap2/pe.c

@@ -8,7 +8,8 @@ void mm_select_sub_multi(void *km, float pri_ratio, float pri1, float pri2, int
 	if (pri_ratio > 0.0f && *n_ > 0) {
 		int i, k, n = *n_, n_2nd = 0;
 		int max_dist = n_segs == 2? qlens[0] + qlens[1] + max_gap_ref : 0;
-		for (i = k = 0; i < n; ++i) {
+		uint8_t *keep = (uint8_t*)kmalloc(km, n);
+		for (i = 0; i < n; ++i) {
 			int to_keep = 0;
 			if (r[i].parent == i) { // primary
 				to_keep = 1;
@@ -34,9 +35,13 @@ void mm_select_sub_multi(void *km, float pri_ratio, float pri1, float pri2, int
 			if (to_keep && r[i].parent != i) {
 				if (n_2nd++ >= best_n) to_keep = 0; // don't keep if there are too many secondary hits
 			}
-			if (to_keep) r[k++] = r[i];
+			keep[i] = to_keep;
+		}
+		for (i = k = 0; i < n; ++i) {
+			if (keep[i]) r[k++] = r[i];
 			else if (r[i].p) free(r[i].p);
 		}
+		kfree(km, keep);
 		if (k != n) mm_sync_regs(km, k, r); // removing hits requires sync()
 		*n_ = k;
 	}

data/ext/ruby_minimap2/extconf.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "fileutils"
+require "rbconfig"
+require "shellwords"
+
+source_dir = File.expand_path("../minimap2", __dir__)
+build_dir = File.expand_path("build/minimap2", Dir.pwd)
+
+abort "minimap2 sources are missing; initialize the git submodule" unless File.file?(File.join(source_dir, "minimap.h"))
+abort "zlib is required to build ruby-minimap2" unless have_library("z", "gzopen")
+have_func("log") || have_library("m", "log")
+if !(RbConfig::CONFIG.fetch("host_os") =~ /mswin/) && !(have_func("pthread_create") || have_library("pthread",
+                                                                                                    "pthread_create"))
+  abort "pthread is required to build ruby-minimap2"
+end
+
+FileUtils.rm_rf(build_dir)
+FileUtils.mkdir_p(build_dir)
+FileUtils.cp_r(Dir.glob(File.join(source_dir, "*")), build_dir)
+
+host_cpu = RbConfig::CONFIG.fetch("host_cpu")
+cflags = %w[-O2 -fPIC]
+cflags.concat(Shellwords.split(RbConfig::CONFIG["ARCH_FLAG"].to_s))
+make_args = ["libminimap2.a", "CC=#{RbConfig::CONFIG.fetch('CC')}"]
+make_args << "AR=#{RbConfig::CONFIG['AR']}" unless RbConfig::CONFIG["AR"].to_s.empty?
+
+case host_cpu
+when /arm64|aarch64/
+  make_args.concat(["aarch64=1", "INCLUDES=-Isse2neon"])
+  cflags.concat(%w[-D_FILE_OFFSET_BITS=64 -fsigned-char])
+when /arm/
+  make_args.concat(["arm_neon=1", "INCLUDES=-Isse2neon"])
+  cflags.concat(%w[-D_FILE_OFFSET_BITS=64 -mfpu=neon -fsigned-char])
+end
+make_args << "CFLAGS=#{cflags.join(' ')}"
+
+Dir.chdir(build_dir) do
+  abort "failed to build bundled minimap2" unless system(RbConfig::CONFIG.fetch("MAKE", "make"), *make_args)
+end
+
+$INCFLAGS << " -I#{build_dir.quote}"
+$LOCAL_LIBS << " #{File.join(build_dir, 'libminimap2.a').quote}"
+$defs << "-DRUBY_MINIMAP2_TESTING" if enable_config("testing", false)
+
+create_makefile("minimap2/minimap2_ext")

data/ext/ruby_minimap2/native_main.c

@@ -0,0 +1,15 @@
+#include <stdlib.h>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#pragma clang diagnostic ignored "-Wincompatible-pointer-types-discards-qualifiers"
+#endif
+
+#define main mm2_embedded_main
+#define exit(status) return (status)
+#include "build/minimap2/main.c"
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif