minimap2 0.2.30.2 → 0.2.30.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8528863219ede8de2b25b477d8258cca91aaafe7fcf6f34f3982d136cedb2bd3
-  data.tar.gz: 58c280e7262bd1d15f0d7d3306ed8fa08759279f24680f6265e8366f6358465d
+  metadata.gz: 2a3bf89a18a50825f14454ce8683dd019377fc45e59a4d46eee617a55d0e64e8
+  data.tar.gz: c1dd61ced844c50b7aec1ba1f9da8d8b47ab3b94a1e2f4b0b4bcdd16169e4f0c
 SHA512:
-  metadata.gz: bd3fd0229795796096f48a33683b23bad5005e0d77436338939b6332994727cd8bc6f0b29be15dc0ea05d7df57ebe703cf50bd319513cdb00943912f9a6f06b8
-  data.tar.gz: 1a7ecc6b032699c91c7d06156a6b64eecbf4905820f108f1a18cdabddc8cf938cc94af2346b888c8591b86cddf7892d4afcf6627571509fe67907e832f301106
+  metadata.gz: 198ae12116da51051dcac0665a85611a2d5bbe5df49ff854fff02c1f686f6c5fd7d40378876de81542d8ca9fe6fb8d71c0c59cde53497368ae4fc83b06a4c685
+  data.tar.gz: 1226cb572e95c805d3817bcaf5048fcc6a3bb217e7ac86b56f866b132c3ffe9ed5f8a1ba8e67b1bb798a1c2852e060f611229ccae9364b477a9863366717ce5c

data/ext/cmappy/cmappy.c

@@ -127,3 +127,8 @@ mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *s
 	free(s);
 	return mi;
 }
+
+void mappy_free(void *p)
+{
+	free(p);
+}

data/ext/cmappy/cmappy.h

@@ -41,4 +41,6 @@ char *mappy_fetch_seq(const mm_idx_t *mi, const char *name, int st, int en, int
 
 mm_idx_t *mappy_idx_seq(int w, int k, int is_hpc, int bucket_bits, const char *seq, int len);
 
+void mappy_free(void *p);
+
 #endif

data/lib/minimap2/aligner.rb

@@ -56,7 +56,8 @@ module Minimap2
       extra_flags: nil,
       scoring: nil,
       sc_ambi: nil,
-      max_chain_skip: nil
+      max_chain_skip: nil,
+      batch_size: nil
     )
       @idx_opt = FFI::IdxOpt.new
       @map_opt = FFI::MapOpt.new
@@ -66,7 +67,11 @@ module Minimap2
 
       # always perform alignment
       map_opt[:flag] |= 4
+
+      # Keep a large batch_size by default (mappy-compatible behavior) to avoid
+      # splitting indexes unless explicitly requested.
       idx_opt[:batch_size] = 0x7fffffffffffffff
+      idx_opt[:batch_size] = batch_size if batch_size
 
       # override preset options
       idx_opt[:k] = k if k
@@ -102,24 +107,53 @@ module Minimap2
         # The Ruby version raises an error here
         raise "Cannot open : #{fn_idx_in}" if reader.null?
 
-        @index = FFI.mm_idx_reader_read(reader, n_threads)
-        FFI.mm_idx_reader_close(reader)
+        @indexes = []
+        begin
+          loop do
+            idx = FFI.mm_idx_reader_read(reader, n_threads)
+            break if idx.nil? || idx.null?
+
+            # Initialize sequence name index for each part
+            FFI.mm_idx_index_name(idx)
+            @indexes << idx
+          end
+        ensure
+          FFI.mm_idx_reader_close(reader)
+        end
+
+        raise "Failed to read index parts from: #{fn_idx_in}" if @indexes.empty?
+
+        # Keep backward-compatible accessor for a single index
+        @index = @indexes[0]
         FFI.mm_mapopt_update(map_opt, index)
-        FFI.mm_idx_index_name(index)
       elsif seq
         @index = FFI.mappy_idx_seq(
           idx_opt[:w], idx_opt[:k], idx_opt[:flag] & 1,
           idx_opt[:bucket_bits], seq, seq.size
         )
+        @indexes = [@index]
         FFI.mm_mapopt_update(map_opt, index)
         map_opt[:mid_occ] = 1000 # don't filter high-occ seeds
+      else
+        @indexes = []
+        @index = FFI::Idx.new(::FFI::Pointer::NULL)
       end
     end
 
     # Explicitly releases the memory of the index object.
 
     def free_index
-      FFI.mm_idx_destroy(index) unless index.null?
+      indexes = @indexes
+      if indexes && !indexes.empty?
+        indexes.each do |idx|
+          FFI.mm_idx_destroy(idx) unless idx.nil? || idx.null?
+        end
+      elsif defined?(@index) && !@index.nil? && !@index.null?
+        FFI.mm_idx_destroy(@index)
+      end
+    ensure
+      @indexes = []
+      @index = FFI::Idx.new(::FFI::Pointer::NULL)
     end
 
     # @param seq [String]
@@ -147,62 +181,122 @@ module Minimap2
       return if index.null?
       return if (map_opt[:flag] & 4).zero? && (index[:flag] & 2).zero?
 
-      map_opt[:max_frag_len] = max_frag_len if max_frag_len
-      map_opt[:flag] |= extra_flags if extra_flags
+      orig_map_opt_bytes = map_opt.to_ptr.read_bytes(FFI::MapOpt.size)
+      orig_best_n = map_opt[:best_n]
+
+      owned_buf = false
+      if buf.nil?
+        buf = FFI.mm_tbuf_init
+        owned_buf = true
+      end
 
-      buf ||= FFI::TBuf.new
       km = FFI.mm_tbuf_get_km(buf)
+      alignments = []
 
-      n_regs_ptr = ::FFI::MemoryPointer.new :int
-      regs_ptr = FFI.mm_map_aux(index, name, seq, seq2, n_regs_ptr, buf, map_opt)
-      n_regs = n_regs_ptr.read_int
+      idx_parts = @indexes
+      idx_parts = [index] if idx_parts.nil? || idx_parts.empty?
 
-      regs = Array.new(n_regs) do |i|
-        FFI::Reg1.new(regs_ptr + i * FFI::Reg1.size)
-      end
+      begin
+        idx_parts.each do |idx_part|
+          next if idx_part.nil? || idx_part.null?
 
-      hit = FFI::Hit.new
+          # Update options for this specific index part
+          FFI.mm_mapopt_update(map_opt, idx_part)
 
-      cs_str     = ::FFI::MemoryPointer.new(::FFI::MemoryPointer.new(:string))
-      m_cs_str   = ::FFI::MemoryPointer.new :int
+          # Per-call options (do not leak across calls)
+          map_opt[:flag] |= 4
+          map_opt[:best_n] = orig_best_n
+          map_opt[:max_frag_len] = max_frag_len if max_frag_len
+          map_opt[:flag] |= extra_flags if extra_flags
 
-      alignments = []
+          n_regs_ptr = ::FFI::MemoryPointer.new :int
+          regs_ptr = FFI.mm_map_aux(idx_part, name, seq, seq2, n_regs_ptr, buf, map_opt)
+          n_regs = n_regs_ptr.read_int
 
-      i = 0
-      begin
-        while i < n_regs
-          FFI.mm_reg2hitpy(index, regs[i], hit)
+          next if regs_ptr.nil? || regs_ptr.null? || n_regs <= 0
+
+          regs = Array.new(n_regs) do |i|
+            FFI::Reg1.new(regs_ptr + i * FFI::Reg1.size)
+          end
 
-          c = hit[:cigar32].read_array_of_uint32(hit[:n_cigar32])
-          cigar = c.map { |x| [x >> 4, x & 0xf] } # 32-bit CIGAR encoding -> Ruby array
+          hit = FFI::Hit.new
 
-          _cs = ""
-          _md = ""
-          if cs or md
-            cur_seq = hit[:seg_id] > 0 && seq2 ? seq2 : seq
+          cs_buf_ptr = nil
+          m_cs_ptr = nil
+          if cs || md
+            cs_buf_ptr = ::FFI::MemoryPointer.new(:pointer)
+            cs_buf_ptr.write_pointer(::FFI::Pointer::NULL)
+            m_cs_ptr = ::FFI::MemoryPointer.new(:int)
+            m_cs_ptr.write_int(0)
+          end
 
-            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
+          i = 0
+          begin
+            while i < n_regs
+              FFI.mm_reg2hitpy(idx_part, regs[i], hit)
+
+              c = hit[:cigar32].read_array_of_uint32(hit[:n_cigar32])
+              cigar = c.map { |x| [x >> 4, x & 0xf] } # 32-bit CIGAR encoding -> Ruby array
+
+              _cs = ""
+              _md = ""
+              if cs or md
+                cur_seq = hit[:seg_id] > 0 && seq2 ? seq2 : seq
+
+                if cs
+                  l_cs_str = FFI.mm_gen_cs(km, cs_buf_ptr, m_cs_ptr, idx_part, regs[i], cur_seq, 1)
+                  cs_ptr = cs_buf_ptr.read_pointer
+                  _cs = cs_ptr.null? || l_cs_str <= 0 ? "" : cs_ptr.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)
+                if md
+                  l_cs_str = FFI.mm_gen_md(km, cs_buf_ptr, m_cs_ptr, idx_part, regs[i], cur_seq)
+                  cs_ptr = cs_buf_ptr.read_pointer
+                  _md = cs_ptr.null? || l_cs_str <= 0 ? "" : cs_ptr.read_string(l_cs_str)
+                end
+              end
+
+              alignments << Alignment.new(hit, cigar, _cs, _md)
+
+              FFI.mm_free_reg1(regs[i])
+              i += 1
+            end
+          ensure
+            while i < n_regs
+              FFI.mm_free_reg1(regs[i])
+              i += 1
             end
-          end
 
-          alignments << Alignment.new(hit, cigar, _cs, _md)
+            if cs_buf_ptr
+              cs_ptr = cs_buf_ptr.read_pointer
+              FFI.mappy_free(cs_ptr) unless cs_ptr.nil? || cs_ptr.null?
+            end
 
-          FFI.mm_free_reg1(regs[i])
-          i += 1
+            # Free the mm_map/mm_map_aux return value array itself
+            FFI.mappy_free(regs_ptr) unless regs_ptr.nil? || regs_ptr.null?
+          end
         end
       ensure
-        while i < n_regs
-          FFI.mm_free_reg1(regs[i])
-          i += 1
+        FFI.mm_tbuf_destroy(buf) if owned_buf
+
+        # Restore map_opt to the state before this call
+        map_opt.to_ptr.put_bytes(0, orig_map_opt_bytes)
+      end
+
+      if orig_best_n && orig_best_n > 0 && alignments.length > orig_best_n
+        alignments.sort_by! do |aln|
+          [
+            aln.primary? ? 1 : 0,
+            aln.mapq,
+            aln.mlen,
+            aln.blen,
+            -aln.nm
+          ]
         end
+        alignments.reverse!
+        alignments = alignments.take(orig_best_n)
       end
+
       alignments
     end
 
@@ -215,12 +309,28 @@ module Minimap2
       return if index.null?
       return if (map_opt[:flag] & 4).zero? && (index[:flag] & 2).zero?
 
-      lp = ::FFI::MemoryPointer.new(:int)
-      s = FFI.mappy_fetch_seq(index, name, start, stop, lp)
-      l = lp.read_int
-      return nil if l == 0
+      idx_parts = @indexes
+      idx_parts = [index] if idx_parts.nil? || idx_parts.empty?
+
+      idx_parts.each do |idx_part|
+        next if idx_part.nil? || idx_part.null?
 
-      s.read_string(l)
+        lp = ::FFI::MemoryPointer.new(:int)
+        s = FFI.mappy_fetch_seq(idx_part, name, start, stop, lp)
+        l = lp.read_int
+        if l == 0
+          FFI.mappy_free(s) unless s.nil? || s.null?
+          next
+        end
+
+        begin
+          return s.read_string(l)
+        ensure
+          FFI.mappy_free(s) unless s.nil? || s.null?
+        end
+      end
+
+      nil
     end
 
     # k-mer length, no larger than 28
@@ -236,14 +346,35 @@ module Minimap2
     end
 
     def n_seq
-      index[:n_seq]
+      return 0 if index.null?
+
+      indexes = @indexes
+      return index[:n_seq] if indexes.nil? || indexes.empty?
+
+      indexes.sum { |idx| idx.nil? || idx.null? ? 0 : idx[:n_seq] }
     end
 
     def seq_names
-      ptr = index[:seq].to_ptr
-      Array.new(index[:n_seq]) do |i|
-        FFI::IdxSeq.new(ptr + i * FFI::IdxSeq.size)[:name]
+      return [] if index.null?
+
+      indexes = @indexes
+      indexes = [index] if indexes.nil? || indexes.empty?
+
+      names = []
+      seen = {}
+      indexes.each do |idx|
+        next if idx.nil? || idx.null?
+
+        ptr = idx[:seq].to_ptr
+        idx[:n_seq].times do |i|
+          name = FFI::IdxSeq.new(ptr + i * FFI::IdxSeq.size)[:name]
+          next if seen[name]
+
+          seen[name] = true
+          names << name
+        end
       end
+      names
     end
   end
 end

data/lib/minimap2/ffi/mappy.rb

@@ -79,7 +79,12 @@ module Minimap2
     attach_function \
       :mappy_revcomp,
       %i[int pointer],
-      :string
+      :pointer
+
+    attach_function \
+      :mappy_free,
+      [:pointer],
+      :void
 
     attach_function \
       :mappy_fetch_seq,

data/lib/minimap2/version.rb

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

data/lib/minimap2.rb

@@ -105,7 +105,14 @@ module Minimap2
       l = seq.size
       bseq = ::FFI::MemoryPointer.new(:char, l)
       bseq.put_bytes(0, seq)
-      FFI.mappy_revcomp(l, bseq)
+      p = FFI.mappy_revcomp(l, bseq)
+      return "" if p.nil? || p.null?
+
+      begin
+        p.read_string(l)
+      ensure
+        FFI.mappy_free(p) unless p.nil? || p.null?
+      end
     end
 
     private

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.2.30.2
+  version: 0.2.30.3
 platform: ruby
 authors:
 - kojix2
@@ -167,7 +167,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: minimap2
 test_files: []