minimap2 0.2.28.0 → 0.2.29.0

data/ext/minimap2/options.c

@@ -62,6 +62,8 @@ void mm_mapopt_init(mm_mapopt_t *opt)
 
 	opt->pe_ori = 0; // FF
 	opt->pe_bonus = 33;
+
+	opt->jump_min_match = 3;
 }
 
 void mm_mapopt_update(mm_mapopt_t *opt, const mm_idx_t *mi)
@@ -164,7 +166,7 @@ int mm_set_opt(const char *preset, mm_idxopt_t *io, mm_mapopt_t *mo)
 		mo->mid_occ = 1000;
 		mo->max_occ = 5000;
 		mo->mini_batch_size = 50000000;
-	} else if (strncmp(preset, "splice", 6) == 0 || strcmp(preset, "cdna") == 0) {
+	} else if (strcmp(preset, "splice") == 0 || strcmp(preset, "splice:hq") == 0 || strcmp(preset, "splice:sr") == 0 || strcmp(preset, "cdna") == 0) {
 		io->flag = 0, io->k = 15, io->w = 5;
 		mo->flag |= MM_F_SPLICE | MM_F_SPLICE_FOR | MM_F_SPLICE_REV | MM_F_SPLICE_FLANK;
 		mo->max_sw_mat = 0;
@@ -172,13 +174,31 @@ int mm_set_opt(const char *preset, mm_idxopt_t *io, mm_mapopt_t *mo)
 		mo->a = 1, mo->b = 2, mo->q = 2, mo->e = 1, mo->q2 = 32, mo->e2 = 0;
 		mo->noncan = 9;
 		mo->junc_bonus = 9;
+		mo->junc_pen = 5;
 		mo->zdrop = 200, mo->zdrop_inv = 100; // because mo->a is halved
-		if (strcmp(preset, "splice:hq") == 0)
+		if (strcmp(preset, "splice:hq") == 0) {
+			mo->noncan = 5, mo->b = 4, mo->q = 6, mo->q2 = 24;
+		} else if (strcmp(preset, "splice:sr") == 0) {
+			mo->flag |= MM_F_NO_PRINT_2ND | MM_F_2_IO_THREADS | MM_F_HEAP_SORT | MM_F_FRAG_MODE | MM_F_WEAK_PAIRING | MM_F_SR_RNA;
 			mo->noncan = 5, mo->b = 4, mo->q = 6, mo->q2 = 24;
+			mo->min_chain_score = 25;
+			mo->min_dp_max = 40;
+			mo->min_ksw_len = 20;
+			mo->pe_ori = 0<<1|1; // FR
+			mo->best_n = 10;
+			mo->mini_batch_size = 100000000;
+		}
 	} else return -1;
 	return 0;
 }
 
+int mm_max_spsc_bonus(const mm_mapopt_t *mo)
+{
+	int max_sc = (mo->q2 + 1) / 2 - 1;
+	max_sc = max_sc > mo->q2 - mo->q? max_sc : mo->q2 - mo->q;
+	return max_sc;
+}
+
 int mm_check_opt(const mm_idxopt_t *io, const mm_mapopt_t *mo)
 {
 	if (mo->bw > mo->bw_long) {
@@ -233,6 +253,11 @@ int mm_check_opt(const mm_idxopt_t *io, const mm_mapopt_t *mo)
 			fprintf(stderr, "[ERROR]\033[1;31m scoring system violating ({-O}+{-E})+({-O2}+{-E2}) <= 127\033[0m\n");
 		return -1;
 	}
+	if (mo->sc_ambi < 0 || mo->sc_ambi >= mo->b) {
+		if (mm_verbose >= 1)
+			fprintf(stderr, "[ERROR]\033[1;31m --score-N should be within [0,{-B})\033[0m\n");
+		return -1;
+	}
 	if (mo->zdrop < mo->zdrop_inv) {
 		if (mm_verbose >= 1)
 			fprintf(stderr, "[ERROR]\033[1;31m Z-drop should not be less than inversion-Z-drop\033[0m\n");

data/ext/minimap2/python/cmappy.h

@@ -71,13 +71,13 @@ static inline void mm_reset_timer(void)
 }
 
 extern unsigned char seq_comp_table[256];
-static inline mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
+static inline mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char* seqname, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
 {
 	mm_reg1_t *r;
 
 	Py_BEGIN_ALLOW_THREADS
 	if (seq2 == 0) {
-		r = mm_map(mi, strlen(seq1), seq1, n_regs, b, opt, NULL);
+		r = mm_map(mi, strlen(seq1), seq1, n_regs, b, opt, seqname);
 	} else {
 		int _n_regs[2];
 		mm_reg1_t *regs[2];
@@ -94,7 +94,7 @@ static inline mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char *seq1, const
 			seq[1][i] = seq_comp_table[t];
 		}
 		if (len[1]&1) seq[1][len[1]>>1] = seq_comp_table[(uint8_t)seq[1][len[1]>>1]];
-		mm_map_frag(mi, 2, len, (const char**)seq, _n_regs, regs, b, opt, NULL);
+		mm_map_frag(mi, 2, len, (const char**)seq, _n_regs, regs, b, opt, seqname);
 		for (i = 0; i < _n_regs[1]; ++i)
 			regs[1][i].rev = !regs[1][i].rev;
 		*n_regs = _n_regs[0] + _n_regs[1];

data/ext/minimap2/python/cmappy.pxd

@@ -39,7 +39,7 @@ cdef extern from "minimap.h":
 		int transition
 		int sc_ambi
 		int noncan
-		int junc_bonus
+		int junc_bonus, junc_pen
 		int zdrop, zdrop_inv
 		int end_bonus
 		int min_dp_max
@@ -52,6 +52,8 @@ cdef extern from "minimap.h":
 
 		int pe_ori, pe_bonus
 
+		int jump_min_match;
+
 		float mid_occ_frac
 		float q_occ_frac
 		int32_t min_mid_occ
@@ -129,7 +131,7 @@ cdef extern from "cmappy.h":
 
 	void mm_reg2hitpy(const mm_idx_t *mi, mm_reg1_t *r, mm_hitpy_t *h)
 	void mm_free_reg1(mm_reg1_t *r)
-	mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
+	mm_reg1_t *mm_map_aux(const mm_idx_t *mi, const char* seqname, const char *seq1, const char *seq2, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt)
 	char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int *l)
 	mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int l)
 

data/ext/minimap2/python/mappy.pyx

@@ -3,7 +3,7 @@ from libc.stdlib cimport free
 cimport cmappy
 import sys
 
-__version__ = '2.28'
+__version__ = '2.29'
 
 cmappy.mm_reset_timer()
 
@@ -113,7 +113,7 @@ cdef class Aligner:
 	cdef cmappy.mm_idxopt_t idx_opt
 	cdef cmappy.mm_mapopt_t map_opt
 
-	def __cinit__(self, fn_idx_in=None, preset=None, k=None, w=None, min_cnt=None, min_chain_score=None, min_dp_score=None, bw=None, bw_long=None, best_n=None, n_threads=3, fn_idx_out=None, max_frag_len=None, extra_flags=None, seq=None, scoring=None):
+	def __cinit__(self, fn_idx_in=None, preset=None, k=None, w=None, min_cnt=None, min_chain_score=None, min_dp_score=None, bw=None, bw_long=None, best_n=None, n_threads=3, fn_idx_out=None, max_frag_len=None, extra_flags=None, seq=None, scoring=None, sc_ambi=None, max_chain_skip=None):
 		self._idx = NULL
 		cmappy.mm_set_opt(NULL, &self.idx_opt, &self.map_opt) # set the default options
 		if preset is not None:
@@ -138,6 +138,8 @@ cdef class Aligner:
 				self.map_opt.q2, self.map_opt.e2 = scoring[4], scoring[5]
 				if len(scoring) >= 7:
 					self.map_opt.sc_ambi = scoring[6]
+		if sc_ambi is not None: self.map_opt.sc_ambi = sc_ambi
+		if max_chain_skip is not None: self.map_opt.max_chain_skip = max_chain_skip
 
 		cdef cmappy.mm_idx_reader_t *r;
 
@@ -163,7 +165,7 @@ cdef class Aligner:
 	def __bool__(self):
 		return (self._idx != NULL)
 
-	def map(self, seq, seq2=None, buf=None, cs=False, MD=False, max_frag_len=None, extra_flags=None):
+	def map(self, seq, seq2=None, name=None, buf=None, cs=False, MD=False, max_frag_len=None, extra_flags=None):
 		cdef cmappy.mm_reg1_t *regs
 		cdef cmappy.mm_hitpy_t h
 		cdef ThreadBuffer b
@@ -185,11 +187,20 @@ cdef class Aligner:
 		km = cmappy.mm_tbuf_get_km(b._b)
 
 		_seq = seq if isinstance(seq, bytes) else seq.encode()
+		if name is not None:
+			_name = name if isinstance(name, bytes) else name.encode()
+
 		if seq2 is None:
-			regs = cmappy.mm_map_aux(self._idx, _seq, NULL,  &n_regs, b._b, &map_opt)
+			if name is None:
+				regs = cmappy.mm_map_aux(self._idx, NULL, _seq, NULL,  &n_regs, b._b, &map_opt)
+			else:
+				regs = cmappy.mm_map_aux(self._idx, _name, _seq, NULL,  &n_regs, b._b, &map_opt)
 		else:
 			_seq2 = seq2 if isinstance(seq2, bytes) else seq2.encode()
-			regs = cmappy.mm_map_aux(self._idx, _seq, _seq2, &n_regs, b._b, &map_opt)
+			if name is None:
+				regs = cmappy.mm_map_aux(self._idx, NULL, _seq, _seq2, &n_regs, b._b, &map_opt)
+			else:
+				regs = cmappy.mm_map_aux(self._idx, _name, _seq, _seq2, &n_regs, b._b, &map_opt)
 
 		try:
 			i = 0
@@ -200,11 +211,12 @@ cdef class Aligner:
 					c = h.cigar32[k]
 					cigar.append([c>>4, c&0xf])
 				if cs or MD: # generate the cs and/or the MD tag, if requested
+					_cur_seq = _seq2 if h.seg_id > 0 and seq2 is not None else _seq
 					if cs:
-						l_cs_str = cmappy.mm_gen_cs(km, &cs_str, &m_cs_str, self._idx, &regs[i], _seq, 1)
+						l_cs_str = cmappy.mm_gen_cs(km, &cs_str, &m_cs_str, self._idx, &regs[i], _cur_seq, 1)
 						_cs = cs_str[:l_cs_str] if isinstance(cs_str, str) else cs_str[:l_cs_str].decode()
 					if MD:
-						l_cs_str = cmappy.mm_gen_MD(km, &cs_str, &m_cs_str, self._idx, &regs[i], _seq)
+						l_cs_str = cmappy.mm_gen_MD(km, &cs_str, &m_cs_str, self._idx, &regs[i], _cur_seq)
 						_MD = cs_str[:l_cs_str] if isinstance(cs_str, str) else cs_str[:l_cs_str].decode()
 				yield Alignment(h.ctg, h.ctg_len, h.ctg_start, h.ctg_end, h.strand, h.qry_start, h.qry_end, h.mapq, cigar, h.is_primary, h.mlen, h.blen, h.NM, h.trans_strand, h.seg_id, _cs, _MD)
 				cmappy.mm_free_reg1(&regs[i])

data/ext/minimap2/setup.py

@@ -23,7 +23,7 @@ def readme():
 
 setup(
 	name = 'mappy',
-	version = '2.28',
+	version = '2.29',
 	url = 'https://github.com/lh3/minimap2',
 	description = 'Minimap2 python binding',
 	long_description = readme(),
@@ -33,7 +33,7 @@ setup(
 	keywords = 'sequence-alignment',
 	scripts = ['python/minimap2.py'],
 	ext_modules = [Extension('mappy',
-		sources = ['python/mappy.pyx', 'align.c', 'bseq.c', 'lchain.c', 'seed.c', 'format.c', 'hit.c', 'index.c', 'pe.c', 'options.c',
+		sources = ['python/mappy.pyx', 'align.c', 'bseq.c', 'lchain.c', 'seed.c', 'format.c', 'hit.c', 'index.c', 'pe.c', 'jump.c', 'options.c',
 				   'ksw2_extd2_sse.c', 'ksw2_exts2_sse.c', 'ksw2_extz2_sse.c', 'ksw2_ll_sse.c',
 				   'kalloc.c', 'kthread.c', 'map.c', 'misc.c', 'sdust.c', 'sketch.c', 'esterr.c', 'splitidx.c'],
 		depends = ['minimap.h', 'bseq.h', 'kalloc.h', 'kdq.h', 'khash.h', 'kseq.h', 'ksort.h',

data/ext/minimap2.patch

@@ -6,13 +6,13 @@
  CPPFLAGS=	-DHAVE_KALLOC
  INCLUDES=
  OBJS=		kthread.o kalloc.o misc.o bseq.o sketch.o sdust.o options.o index.o \
- 			lchain.o align.o hit.o seed.o map.o format.o pe.o esterr.o splitidx.o \
+ 			lchain.o align.o hit.o seed.o jump.o map.o format.o pe.o esterr.o splitidx.o \
 -			ksw2_ll_sse.o
 +			ksw2_ll_sse.o cmappy.o
  PROG=		minimap2
  PROG_EXTRA=	sdust minimap2-lite
  LIBS=		-lm -lz -lpthread
-@@ -134,3 +134,4 @@ sdust.o: kalloc.h kdq.h kvec.h sdust.h
+@@ -135,3 +135,4 @@ sdust.o: kalloc.h kdq.h kvec.h sdust.h
  seed.o: mmpriv.h minimap.h bseq.h kseq.h kalloc.h ksort.h
  sketch.o: kvec.h kalloc.h mmpriv.h minimap.h bseq.h kseq.h
  splitidx.o: mmpriv.h minimap.h bseq.h kseq.h

data/lib/minimap2/aligner.rb

@@ -54,9 +54,10 @@ module Minimap2
       fn_idx_out: nil,
       max_frag_len: nil,
       extra_flags: nil,
-      scoring: nil
+      scoring: nil,
+      sc_ambi: nil,
+      max_chain_skip: nil
     )
-
       @idx_opt = FFI::IdxOpt.new
       @map_opt = FFI::MapOpt.new
 
@@ -91,6 +92,8 @@ module Minimap2
           map_opt[:sc_ambi] = scoring[6] if scoring.size >= 7
         end
       end
+      map_opt[:sc_ambi] = sc_ambi if sc_ambi
+      map_opt[:max_chain_skip] = max_chain_skip if max_chain_skip
 
       if fn_idx_in
         warn "Since fn_idx_in is specified, the seq argument will be ignored." if seq
@@ -134,13 +137,13 @@ module Minimap2
 
     def align(
       seq, seq2 = nil,
+      name: nil,
       buf: nil,
       cs: false,
       md: false,
       max_frag_len: nil,
       extra_flags: nil
     )
-
       return if index.null?
       return if (map_opt[:flag] & 4).zero? && (index[:flag] & 2).zero?
 
@@ -151,7 +154,7 @@ module Minimap2
       km = FFI.mm_tbuf_get_km(buf)
 
       n_regs_ptr = ::FFI::MemoryPointer.new :int
-      regs_ptr = FFI.mm_map_aux(index, seq, seq2, n_regs_ptr, buf, map_opt)
+      regs_ptr = FFI.mm_map_aux(index, name, seq, seq2, n_regs_ptr, buf, map_opt)
       n_regs = n_regs_ptr.read_int
 
       regs = Array.new(n_regs) do |i|
@@ -174,15 +177,19 @@ module Minimap2
           cigar = c.map { |x| [x >> 4, x & 0xf] } # 32-bit CIGAR encoding -> Ruby array
 
           _cs = ""
-          if cs
-            l_cs_str = FFI.mm_gen_cs(km, cs_str, m_cs_str, @index, regs[i], seq, 1)
-            _cs = cs_str.read_pointer.read_string(l_cs_str)
-          end
-
           _md = ""
-          if md
-            l_cs_str = FFI.mm_gen_md(km, cs_str, m_cs_str, @index, regs[i], seq)
-            _md = cs_str.read_pointer.read_string(l_cs_str)
+          if cs or md
+            cur_seq = hit[:seg_id] > 0 && seq2 ? seq2 : seq
+
+            if cs
+              l_cs_str = FFI.mm_gen_cs(km, cs_str, m_cs_str, @index, regs[i], cur_seq, 1)
+              _cs = cs_str.read_pointer.read_string(l_cs_str)
+            end
+
+            if md
+              l_cs_str = FFI.mm_gen_md(km, cs_str, m_cs_str, @index, regs[i], cur_seq)
+              _md = cs_str.read_pointer.read_string(l_cs_str)
+            end
           end
 
           alignments << Alignment.new(hit, cigar, _cs, _md)

data/lib/minimap2/ffi/constants.rb

@@ -41,6 +41,9 @@ module Minimap2
     SPLICE_OLD       = 0x800000000
     SECONDARY_SEQ    = 0x1000000000 # output SEQ field for seqondary alignments using hard clipping
     OUT_DS           = 0x2000000000
+    WEAK_PAIRING     = 0x4000000000
+    SR_RNA           = 0x8000000000
+    OUT_JUNC         = 0x10000000000
 
     HPC              = 0x1
     NO_SEQ           = 0x2
@@ -99,6 +102,8 @@ module Minimap2
         :S,     :pointer,    # 4-bit packed sequence
         :B,     :pointer,    # index (hidden)
         :I,     :pointer,    # intervals (hidden)
+        :spsc,  :pointer,    # splice score (hidden)
+        :J,     :pointer,    # junctions to create jumps (hidden)
         :km,    :pointer,
         :h,     :pointer
     end
@@ -160,7 +165,8 @@ module Minimap2
                 :split_inv,       1,
                 :is_alt,          1,
                 :strand_retained, 1,
-                :dummy,           5
+                :is_spliced,      1,
+                :dummy,           4
     end
 
     # indexing option
@@ -210,6 +216,7 @@ module Minimap2
         :transition,           :int,     # transition mismatch score (A:G, C:T)
         :sc_ambi,              :int,     # score when one or both bases are "N"
         :noncan,               :int,     # cost of non-canonical splicing sites
+        :junc_pen,             :int,
         :junc_bonus,           :int,
         :zdrop,                :int,     # break alignment if alignment score drops too fast along the diagonal
         :zdrop_inv,            :int,
@@ -223,6 +230,7 @@ module Minimap2
         :rank_frac,            :float,
         :pe_ori,               :int,
         :pe_bonus,             :int,
+        :jump_min_match,       :int32,
         :mid_occ_frac,         :float,   # only used by mm_mapopt_update(); see below
         :q_occ_frac,           :float,
         :min_mid_occ,          :int32,

data/lib/minimap2/ffi/functions.rb

@@ -7,6 +7,7 @@ module Minimap2
       %i[int pointer],
       :int
 
+    # int mm_set_opt(const char *preset, mm_idxopt_t *io, mm_mapopt_t *mo);
     attach_function \
       :mm_set_opt_raw, :mm_set_opt,
       [:pointer, IdxOpt.by_ref, MapOpt.by_ref],
@@ -24,66 +25,204 @@ module Minimap2
       mm_set_opt_raw(ptr, io, mo)
     end
 
+    # int mm_check_opt(const mm_idxopt_t *io, const mm_mapopt_t *mo);
+    attach_function \
+      :mm_check_opt,
+      [IdxOpt.by_ref, MapOpt.by_ref],
+      :int
+
+    # void mm_mapopt_update(mm_mapopt_t *opt, const mm_idx_t *mi);
+    attach_function \
+      :mm_mapopt_update,
+      [MapOpt.by_ref, Idx.by_ref],
+      :void
+
+    # void mm_mapopt_max_intron_len(mm_mapopt_t *opt, int max_intron_len);
+    attach_function \
+      :mm_mapopt_max_intron_len,
+      [MapOpt.by_ref, :int],
+      :void
+
+    # mm_idx_reader_t *mm_idx_reader_open(const char *fn, const mm_idxopt_t *opt, const char *fn_out);
     attach_function \
       :mm_idx_reader_open,
       [:string, IdxOpt.by_ref, :string],
       IdxReader.by_ref
 
+    # mm_idx_t *mm_idx_reader_read(mm_idx_reader_t *r, int n_threads);
     attach_function \
       :mm_idx_reader_read,
       [IdxReader.by_ref, :int],
       Idx.by_ref
 
+    # void mm_idx_reader_close(mm_idx_reader_t *r);
     attach_function \
       :mm_idx_reader_close,
       [IdxReader.by_ref],
       :void
 
+    # int mm_idx_reader_eof(const mm_idx_reader_t *r);
     attach_function \
-      :mm_idx_destroy,
-      [Idx.by_ref],
+      :mm_idx_reader_eof,
+      [IdxReader.by_ref],
+      :int
+
+    # int64_t mm_idx_is_idx(const char *fn);
+    attach_function \
+      :mm_idx_is_idx,
+      [:string],
+      :int64_t
+
+    # mm_idx_t *mm_idx_load(FILE *fp);
+    attach_function \
+      :mm_idx_load,
+      [:pointer], # FILE pointer
+      Idx.by_ref
+
+    # void mm_idx_dump(FILE *fp, const mm_idx_t *mi);
+    attach_function \
+      :mm_idx_dump,
+      [:pointer, Idx.by_ref], # FILE pointer
       :void
 
+    # mm_idx_t *mm_idx_str(int w, int k, int is_hpc, int bucket_bits, int n, const char **seq, const char **name);
     attach_function \
-      :mm_mapopt_update,
-      [MapOpt.by_ref, Idx.by_ref],
+      :mm_idx_str,
+      %i[int int int int int pointer pointer],
+      Idx.by_ref
+
+    # void mm_idx_stat(const mm_idx_t *idx);
+    attach_function \
+      :mm_idx_stat,
+      [Idx.by_ref],
       :void
 
+    # void mm_idx_destroy(mm_idx_t *mi);
     attach_function \
-      :mm_idx_index_name,
+      :mm_idx_destroy,
       [Idx.by_ref],
-      :int
+      :void
 
+    # mm_tbuf_t *mm_tbuf_init(void);
     attach_function \
       :mm_tbuf_init,
       [],
       TBuf.by_ref
 
+    # void mm_tbuf_destroy(mm_tbuf_t *b);
     attach_function \
       :mm_tbuf_destroy,
       [TBuf.by_ref],
       :void
 
+    # void *mm_tbuf_get_km(mm_tbuf_t *b);
     attach_function \
       :mm_tbuf_get_km,
       [TBuf.by_ref],
       :pointer
 
+    # mm_reg1_t *mm_map(const mm_idx_t *mi, int l_seq, const char *seq, int *n_regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *name);
+    attach_function \
+      :mm_map,
+      [Idx.by_ref, :int, :string, :pointer, TBuf.by_ref, MapOpt.by_ref, :string],
+      Reg1.by_ref
+
+    # void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, int *n_regs, mm_reg1_t **regs, mm_tbuf_t *b, const mm_mapopt_t *opt, const char *qname);
+    attach_function \
+      :mm_map_frag,
+      [Idx.by_ref, :int, :pointer, :pointer, :pointer, TBuf.by_ref, MapOpt.by_ref, :string],
+      :void
+
+    # int mm_map_file(const mm_idx_t *idx, const char *fn, const mm_mapopt_t *opt, int n_threads);
+    attach_function \
+      :mm_map_file,
+      [Idx.by_ref, :string, MapOpt.by_ref, :int],
+      :int
+
+    # int mm_map_file_frag(const mm_idx_t *idx, int n_segs, const char **fn, const mm_mapopt_t *opt, int n_threads);
+    attach_function \
+      :mm_map_file_frag,
+      [Idx.by_ref, :int, :pointer, MapOpt.by_ref, :int],
+      :int
+
+    # 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);
     attach_function \
       :mm_gen_cs,
       [:pointer, :pointer, :pointer, Idx.by_ref, Reg1.by_ref, :string, :int],
       :int
 
+    # int mm_gen_MD(void *km, char **buf, int *max_len, const mm_idx_t *mi, const mm_reg1_t *r, const char *seq);
     attach_function \
       :mm_gen_md, :mm_gen_MD, # Avoid uppercase letters in method names.
       [:pointer, :pointer, :pointer, Idx.by_ref, Reg1.by_ref, :string],
       :int
 
+    # int mm_idx_index_name(mm_idx_t *mi);
+    attach_function \
+      :mm_idx_index_name,
+      [Idx.by_ref],
+      :int
+
+    # int mm_idx_name2id(const mm_idx_t *mi, const char *name);
+    attach_function \
+      :mm_idx_name2id,
+      [Idx.by_ref, :string],
+      :int
+
+    # int mm_idx_getseq(const mm_idx_t *mi, uint32_t rid, uint32_t st, uint32_t en, uint8_t *seq);
+    attach_function \
+      :mm_idx_getseq,
+      [Idx.by_ref, :uint32, :uint32, :uint32, :pointer],
+      :int
+
+    # int mm_idx_alt_read(mm_idx_t *mi, const char *fn);
+    attach_function \
+      :mm_idx_alt_read,
+      [Idx.by_ref, :string],
+      :int
+
+    # int mm_idx_bed_read(mm_idx_t *mi, const char *fn, int read_junc);
+    attach_function \
+      :mm_idx_bed_read,
+      [Idx.by_ref, :string, :int],
+      :int
+
+    # int mm_idx_bed_junc(const mm_idx_t *mi, int32_t ctg, int32_t st, int32_t en, uint8_t *s);
+    attach_function \
+      :mm_idx_bed_junc,
+      [Idx.by_ref, :int32, :int32, :int32, :pointer],
+      :int
+
+    # int mm_max_spsc_bonus(const mm_mapopt_t *mo);
+    attach_function \
+      :mm_max_spsc_bonus,
+      [MapOpt.by_ref],
+      :int
+
+    # int32_t mm_idx_spsc_read(mm_idx_t *idx, const char *fn, int32_t max_sc);
+    attach_function \
+      :mm_idx_spsc_read,
+      [Idx.by_ref, :string, :int32],
+      :int32
+
+    # int64_t mm_idx_spsc_get(const mm_idx_t *db, int32_t cid, int64_t st0, int64_t en0, int32_t rev, uint8_t *sc);
+    attach_function \
+      :mm_idx_spsc_get,
+      [Idx.by_ref, :int32, :int64, :int64, :int32, :pointer],
+      :int64
+
+    # void mm_mapopt_init(mm_mapopt_t *opt);
     attach_function \
       :mm_mapopt_init,
       [MapOpt.by_ref],
       :void
 
+    # mm_idx_t *mm_idx_build(const char *fn, int w, int k, int flag, int n_threads);
+    attach_function \
+      :mm_idx_build,
+      %i[string int int int int],
+      Idx.by_ref
+
     # mmpriv.h
 
     attach_function \

data/lib/minimap2/ffi/mappy.rb

@@ -73,7 +73,7 @@ module Minimap2
 
     attach_function \
       :mm_map_aux,
-      [Idx.by_ref, :string, :string, :pointer, TBuf.by_ref, MapOpt.by_ref],
+      [Idx.by_ref, :string, :string, :string, :pointer, TBuf.by_ref, MapOpt.by_ref],
       :pointer # Reg1
 
     attach_function \

data/lib/minimap2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Minimap2
-  VERSION = "0.2.28.0"
+  VERSION = "0.2.29.0"
 end

data/lib/minimap2.rb

@@ -116,11 +116,11 @@ module Minimap2
     end
 
     def fastx_next(ks, read_comment)
-      qual = ks[:qual][:s] if (ks[:qual][:l]) > 0
+      qual = ks[:qual][:s] if ks[:qual][:l] > 0
       name = ks[:name][:s]
       seq  = ks[:seq][:s]
       if read_comment
-        comment = ks[:comment][:s] if (ks[:comment][:l]) > 0
+        comment = ks[:comment][:s] if ks[:comment][:l] > 0
         [name, seq, qual, comment]
       else
         [name, seq, qual]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.2.28.0
+  version: 0.2.29.0
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-03-29 00:00:00.000000000 Z
+date: 2025-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -69,6 +69,7 @@ files:
 - ext/minimap2/format.c
 - ext/minimap2/hit.c
 - ext/minimap2/index.c
+- ext/minimap2/jump.c
 - ext/minimap2/kalloc.c
 - ext/minimap2/kalloc.h
 - ext/minimap2/kdq.h
@@ -93,7 +94,7 @@ files:
 - ext/minimap2/minimap2.1
 - ext/minimap2/misc.c
 - ext/minimap2/misc/README.md
-- ext/minimap2/misc/mmphase.js
+- ext/minimap2/misc/pafcluster.js
 - ext/minimap2/misc/paftools.js
 - ext/minimap2/mmpriv.h
 - ext/minimap2/options.c
@@ -165,7 +166,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.19
 signing_key: 
 specification_version: 4
 summary: minimap2