minimap2 0.0.2 → 0.2.22.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09e4267638f072ee219b2af3ef1afd3938c3a6d02f5370aa9454b25b871652b7'
-  data.tar.gz: ab035c12eb6d6bda353ffab1b5f5923ec8327fea9a4552259b01b02523b7f934
+  metadata.gz: 7ceb411a88448c6ed13e6d842450264e91569260c9b19d77e699a93736768522
+  data.tar.gz: 76c1f3466375b73c54db6cd2574ffe19a817b11994d50e9e8473a209566b14f5
 SHA512:
-  metadata.gz: 8f24c1f2d8e07e1be825fbc2a67049d378c1e1d5f3d23312d474e796fa7968b7d85b58b061226dbf4a14e637c27708667a5737da246e4874f03cadf9df4f013e
-  data.tar.gz: 5e92b4c08e02416b0385c9a5a6b6c7b46381469ae70447fea80a9269a06e1ac11155a06de3d3a4a97995880f542d8adf9cd6063afa2c133be474644dd6d3245f
+  metadata.gz: 05a313f05984e2afab772da3971249327a9461a92d8b1fbcf53329ea5cd9d421e4ab8a137bd16213b86d6912bf1d43fd7f22c1bb5408a36004a64296fab294d9
+  data.tar.gz: 7739312455aba2b14192eef634623f351fc4cea721d142b815ce41d651bc3de84e0fe413de6d24e8551ed90a2d71bcbf82a3df5b87685cb1474e6a134ed9fefe

data/README.md

@@ -1,20 +1,23 @@
-# Minimap2
+# ruby-minimap2
 
 [![Gem Version](https://img.shields.io/gem/v/minimap2?color=brightgreen)](https://rubygems.org/gems/minimap2)
 [![CI](https://github.com/kojix2/ruby-minimap2/workflows/CI/badge.svg)](https://github.com/kojix2/ruby-minimap2/actions)
 [![The MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
 [![Docs Latest](https://img.shields.io/badge/docs-stable-blue.svg)](https://rubydoc.info/gems/minimap2)
+[![DOI](https://zenodo.org/badge/325711305.svg)](https://zenodo.org/badge/latestdoi/325711305)
+
+
 
 :dna: [minimap2](https://github.com/lh3/minimap2) - the long-read mapper - for [Ruby](https://github.com/ruby/ruby)
 
 ## Installation
 
-You need to install ruby-minimap2 from the source code. Because you need to build minimap2 and create a shared library. Open your terminal and type the following commands in order. 
+Open your terminal and type the following commands in order. You need to build minimap2 on your own because you need to create a shared library that contains cmappy functions.
 
 Build
 
 ```sh
-git clone --recurse-submodules https://github.com/kojix2/ruby-minimap2
+git clone --recursive https://github.com/kojix2/ruby-minimap2
 cd ruby-minimap2
 bundle install
 bundle exec rake minimap2:build
@@ -26,108 +29,136 @@ Install
 bundle exec rake install
 ```
 
-Ruby-minimap2 is tested on Ubuntu and macOS. 
+Ruby-minimap2 is [tested on Ubuntu and macOS](https://github.com/kojix2/ruby-minimap2/actions). 
 
 ## Quick Start
 
 ```ruby
 require "minimap2"
+```
 
-# load or build index
+Create aligner
+
+```ruby
 aligner = Minimap2::Aligner.new("minimap2/test/MT-human.fa")
+```
 
-# retrieve a subsequence from the index
+Retrieve a subsequence from the index
+
+```ruby
 seq = aligner.seq("MT_human", 100, 200)
+```
 
-# mapping
-aligner.align(seq) do |h|
-  pp h.to_h
-  # {:ctg          => "MT_human",
-  #  :ctg_len      => 16569,
-  #  :r_st         => 100,
-  #  :r_en         => 200,
-  #  :strand       => 1,
-  #  :trans_strand => 0,
-  #  :blen         => 100,
-  #  :mlen         => 100,
-  #  :nm           => 0,
-  #  :primary      => 1,
-  #  :q_st         => 0,
-  #  :q_en         => 100,
-  #  :mapq         => 60,
-  #  :cigar        => [[100, 0]],
-  #  :read_num     => 1,
-  #  :cs           => "",
-  #  :md           => "",
-  #  :cigar_str    => "100M"}
-end
+Mapping
+
+```ruby
+hits = aligner.align(seq)
+pp hits[0]
+```
+
+```
+=> 
+#<Minimap2::Alignment:0x000055fe18223f50
+ @blen=100,
+ @cigar=[[100, 0]],
+ @cigar_str="100M",
+ @cs="",
+ @ctg="MT_human",
+ @ctg_len=16569,
+ @mapq=60,
+ @md="",
+ @mlen=100,
+ @nm=0,
+ @primary=1,
+ @q_en=100,
+ @q_st=0,
+ @r_en=200,
+ @r_st=100,
+ @read_num=1,
+ @strand=1,
+ @trans_strand=0>
 ```
 
 ## APIs Overview
 
-See the [RubyDoc.info document](https://rubydoc.info/gems/minimap2) for details.
+API is based on [Mappy](https://github.com/lh3/minimap2/tree/master/python), the official Python binding for Minimap2. 
+
+Note: `Aligner#map` has been changed to `aligne`, because `map` means iterator in Ruby.
 
 ```markdown
 * Minimap2 module
-  - fastx_read
-  - revcomp
+  - fastx_read                  Read fasta/fastq file.
+  - revcomp                     Reverse complement sequence.
 
   * Aligner class
     * attributes
-      - index
-      - idx_opt
-      - map_opt
+      - 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)
-      - align
+      - new(path, preset: nil)  Create a new aligner. (presets: sr, map-pb, map-out, map-hifi, splice, asm5, etc.)
+      - align                   Maps and returns alignments.
+      - seq                     Retrieve a subsequence from the index.
 
   * Alignment class
     * attributes
-      - ctg
-      - ctg_len
-      - r_st
-      - r_en
-      - strand
-      - trans_strand
-      - blen
-      - mlen
-      - nm
-      - primary
-      - q_st
-      - q_en
-      - mapq
-      - cigar
-      - read_num
-      - cs
-      - md
-      - cigar_str
+      - 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.
+      - r_en                    Returns end positions on the reference.
+      - strand                  Returns +1 if on the forward strand; -1 if on the reverse strand.
+      - trans_strand            Returns transcript strand. +1 if on the forward strand; -1 if on the reverse strand; 0 if unknown.
+      - blen                    Returns length of the alignment, including both alignment matches and gaps but excluding ambiguous bases.
+      - mlen                    Returns length of the matching bases in the alignment, excluding ambiguous base matches.
+      - nm                      Returns number of mismatches, gaps and ambiguous poistions in the alignment.
+      - primary                 Returns if the alignment is primary (typically the best and the first to generate).
+      - q_st                    Returns start positions on the query.
+      - q_en                    Returns end positions on the query.
+      - 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.
+      - cigar_str               Returns CIGAR string.
     * methods
-      - to_h
-      - to_s
+      - to_h                    Convert Alignment to hash.
+      - to_s                    Convert to the PAF format without the QueryName and QueryLength columns.
 
-  * FFI module
-    * IdxOpt class
-    * MapOpt class
+  ## FFI module
+    * IdxOpt class              Indexing options.
+    * MapOpt class              Mapping options.
 ```
 
-The ruby-minimap2 API is compliant with mappy, the official Python binding for Minimap2. However, there are a few differences. For example, the `map` method has been renamed to `align` since map is the common name for iterators in Ruby.
+This is not all. See the [RubyDoc.info documentation](https://rubydoc.info/gems/minimap2/) for more details.
 
-* [Mappy: Minimap2 Python Binding](https://github.com/lh3/minimap2/tree/master/python)
+ruby-minimap2 is built on top of [Ruby-FFI](https://github.com/ffi/ffi). 
+Native functions can be called from the FFI module. FFI also provides the way to access some C structs.
 
-ruby-minimap2 is built on top of [Ruby-FFI](https://github.com/ffi/ffi). Native functions can be called from the FFI module, which also provides a way to access some C structs such as IdxOpt and MapOpt.
+```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
+```
 
 ## Development
 
-Fork your repository and clone.
+Fork your repository.
+then clone.
 
 ```sh
-git clone --recurse-submodules https://github.com/kojix2/ruby-minimap2
+git clone --recursive https://github.com/kojix2/ruby-minimap2
 # git clone https://github.com/kojix2/ruby-minimap2
 # cd ruby-minimap2
 # git submodule update -i
 ```
 
-Build.
+Build Minimap2 and Mappy.
 
 ```sh
 cd ruby-minimap2
@@ -135,6 +166,13 @@ bundle install # Install dependent packages including Ruby-FFI
 bundle exec rake minimap2:build
 ```
 
+A shared library will be created in the vendor directory.
+
+```
+└── vendor
+   └── libminimap2.so
+```
+
 Run tests.
 
 ```
@@ -155,3 +193,7 @@ ruby-minimap2 is a library under development and there are many points to be imp
 ## License
 
 [MIT License](https://opensource.org/licenses/MIT).
+
+## Acknowledgements
+
+I would like to thank Heng Li for making Minimap2, and all the readers who read the README to the end.

data/lib/minimap2.rb

@@ -34,30 +34,34 @@ module Minimap2
 
   # methods from mappy
   class << self
-    # read fasta/fastq file
+    # Set verbosity level.
+    # @param [Integer] level
+
+    def verbose(level = -1)
+      FFI.mm_verbose_level(level)
+    end
+
+    # Read fasta/fastq file.
     # @param [String] file_path
-    # @param [Boolean] read_comment If false or nil, the comment will not be read.
+    # @param [Boolean] comment If True, the comment will be read.
     # @yield [name, seq, qual, comment]
-    # Note: You can also use a generic library such as BioRuby instead of this method.
+    # @return [Enumerator] enum Retrun Enumerator if not block given.
+    # Note: You can BioRuby instead of this method.
 
-    def fastx_read(file_path, read_comment = false)
+    def fastx_read(file_path, comment: false, &block)
       path = File.expand_path(file_path)
       ks = FFI.mm_fastx_open(path)
-      while FFI.kseq_read(ks) >= 0
-        qual = ks[:qual][:s] if (ks[:qual][:l]).positive?
-        name = ks[:name][:s]
-        seq  = ks[:seq][:s]
-        if read_comment
-          comment = ks[:comment][:s] if (ks[:comment][:l]).positive?
-          yield [name, seq, qual, comment]
-        else
-          yield [name, seq, qual]
+      if block_given?
+        fastx_each(ks, comment, &block)
+      else
+        Enumerator.new do |y|
+          # rewind not work
+          fastx_each(ks, comment) { |r| y << r }
         end
       end
-      FFI.mm_fastx_close(ks)
     end
 
-    # reverse complement sequence
+    # Reverse complement sequence.
     # @param [String] seq
     # @return [string] seq
 
@@ -68,11 +72,23 @@ module Minimap2
       FFI.mappy_revcomp(l, bseq)
     end
 
-    # set verbosity level
-    # @param [Integer] level
+    private
 
-    def verbose(level = -1)
-      FFI.mm_verbose_level(level)
+    def fastx_each(ks, comment)
+      yield fastx_next(ks, comment) while FFI.kseq_read(ks) >= 0
+      FFI.mm_fastx_close(ks)
+    end
+
+    def fastx_next(ks, read_comment)
+      qual = ks[:qual][:s] if (ks[:qual][:l]).positive?
+      name = ks[:name][:s]
+      seq  = ks[:seq][:s]
+      if read_comment
+        comment = ks[:comment][:s] if (ks[:comment][:l]).positive?
+        [name, seq, qual, comment]
+      else
+        [name, seq, qual]
+      end
     end
   end
 end

data/lib/minimap2/aligner.rb

@@ -4,11 +4,21 @@ module Minimap2
   class Aligner
     attr_reader :idx_opt, :map_opt, :index
 
-    # Create a new aligner
+    # Create a new aligner.
     #
     # @param fn_idx_in [String] index or sequence file name.
     # @param seq [String] a single sequence to index.
     # @param preset [String] minimap2 preset.
+    #   * map-pb : PacBio CLR genomic reads
+    #   * map-ont : Oxford Nanopore genomic reads
+    #   * map-hifi : PacBio HiFi/CCS genomic reads (v2.19 or later)
+    #   * asm20 : PacBio HiFi/CCS genomic reads (v2.18 or earlier)
+    #   * sr : short genomic paired-end reads
+    #   * splice : spliced long reads (strand unknown)
+    #   * splice:hq : Final PacBio Iso-seq or traditional cDNA
+    #   * asm5 : intra-species asm-to-asm alignment
+    #   * ava-pb : PacBio read overlap
+    #   * ava-ont : Nanopore read overlap
     # @param k [Integer] k-mer length, no larger than 28.
     # @param w [Integer] minimizer window size, no larger than 255.
     # @param min_cnt [Integer] mininum number of minimizers on a chain.
@@ -80,7 +90,7 @@ module Minimap2
       end
 
       if fn_idx_in
-        warn "Since fn_idx_in is specified, the seq argument will be ignored." if seq
+        warn 'Since fn_idx_in is specified, the seq argument will be ignored.' if seq
         reader = FFI.mm_idx_reader_open(fn_idx_in, idx_opt, fn_idx_out)
 
         # The Ruby version raises an error here
@@ -101,6 +111,7 @@ module Minimap2
     end
 
     # Explicitly releases the memory of the index object.
+
     def free_index
       FFI.mm_idx_destroy(index) unless index.null?
     end
@@ -116,6 +127,7 @@ module Minimap2
     #   In the Ruby language, the name map means iterator.
     #   The original name is map, but here I use the method name align.
     # @note The use of Enumerator is being considered. The method names may change again.
+    # @return [Array] alignments
 
     def align(
       seq, seq2 = nil,
@@ -133,25 +145,29 @@ module Minimap2
 
       buf ||= FFI::TBuf.new
       km = FFI.mm_tbuf_get_km(buf)
-      n_regs_ptr = ::FFI::MemoryPointer.new :int
 
-      ptr = FFI.mm_map_aux(index, seq, seq2, n_regs_ptr, buf, map_opt)
+      n_regs_ptr = ::FFI::MemoryPointer.new :int
+      regs_ptr = FFI.mm_map_aux(index, seq, seq2, n_regs_ptr, buf, map_opt)
       n_regs = n_regs_ptr.read_int
 
-      regs = Array.new(n_regs) { |i| FFI::Reg1.new(ptr + i * FFI::Reg1.size) }
+      regs = Array.new(n_regs) do |i|
+        FFI::Reg1.new(regs_ptr + i * FFI::Reg1.size)
+      end
 
       hit = FFI::Hit.new
+
       cs_str     = ::FFI::MemoryPointer.new(::FFI::MemoryPointer.new(:string))
       m_cs_str   = ::FFI::MemoryPointer.new :int
+
+      alignments = []
+
       i = 0
       begin
         while i < n_regs
           FFI.mm_reg2hitpy(index, regs[i], hit)
-          cigar = []
 
           c = hit[:cigar32].read_array_of_uint32(hit[:n_cigar32])
-          # convert the 32-bit CIGAR encoding to Ruby array
-          cigar = c.map { |x| [x >> 4, x & 0xf] }
+          cigar = c.map { |x| [x >> 4, x & 0xf] } # 32-bit CIGAR encoding -> Ruby array
 
           _cs = ''
           if cs
@@ -165,7 +181,7 @@ module Minimap2
             _md = cs_str.read_pointer.read_string(l_cs_str)
           end
 
-          yield Alignment.new(hit, cigar, _cs, _md)
+          alignments << Alignment.new(hit, cigar, _cs, _md)
 
           FFI.mm_free_reg1(regs[i])
           i += 1
@@ -176,12 +192,13 @@ module Minimap2
           i += 1
         end
       end
+      alignments
     end
 
-    # retrieve a subsequence from the index.
-    # @params name
-    # @params start
-    # @params stop
+    # Retrieve a subsequence from the index.
+    # @param name
+    # @param start
+    # @param stop
 
     def seq(name, start = 0, stop = 0x7fffffff)
       lp = ::FFI::MemoryPointer.new(:int)
@@ -193,11 +210,13 @@ module Minimap2
     end
 
     # k-mer length, no larger than 28
+
     def k
       index[:k]
     end
 
     # minimizer window size, no larger than 255
+
     def w
       index[:w]
     end

data/lib/minimap2/alignment.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Minimap2
-  # Alignment result
+  # Alignment result.
   #
   # @!attribute ctg
   #   @return [String] name of the reference sequence the query is mapped to.
@@ -73,17 +73,21 @@ module Minimap2
       @cs           = cs
       @md           = md
 
-      @cigar_str = cigar.map { |x| x[0].to_s + 'MIDNSH'[x[1]] }.join
+      @cigar_str = cigar.map { |x| x[0].to_s + FFI::CIGAR_STR[x[1]] }.join
     end
 
     def primary?
       @primary == 1
     end
 
+    # Convert Alignment to hash.
+
     def to_h
       self.class.keys.map { |k| [k, __send__(k)] }.to_h
     end
 
+    # Convert to the PAF format without the QueryName and QueryLength columns.
+
     def to_s
       strand = if @strand.positive?
                  '+'

data/lib/minimap2/ffi/constants.rb

@@ -3,45 +3,60 @@
 module Minimap2
   module FFI
     # flags
-    NO_DIAG        = 0x001 # no exact diagonal hit
-    NO_DUAL        = 0x002 # skip pairs where query name is lexicographically larger than target name
-    CIGAR          = 0x004
-    OUT_SAM        = 0x008
-    NO_QUAL        = 0x010
-    OUT_CG         = 0x020
-    OUT_CS         = 0x040
-    SPLICE         = 0x080 # splice mode
-    SPLICE_FOR     = 0x100 # match GT-AG
-    SPLICE_REV     = 0x200 # match CT-AC, the reverse complement of GT-AG
-    NO_LJOIN       = 0x400
-    OUT_CS_LONG    = 0x800
-    SR             = 0x1000
-    FRAG_MODE      = 0x2000
-    NO_PRINT_2ND   = 0x4000
-    TWO_IO_THREADS = 0x8000 # Translator's Note. MM_F_2_IO_THREADS. Constants starting with numbers cannot be defined.
-    LONG_CIGAR     = 0x10000
-    INDEPEND_SEG   = 0x20000
-    SPLICE_FLANK   = 0x40000
-    SOFTCLIP       = 0x80000
-    FOR_ONLY       = 0x100000
-    REV_ONLY       = 0x200000
-    HEAP_SORT      = 0x400000
-    ALL_CHAINS     = 0x800000
-    OUT_MD         = 0x1000000
-    COPY_COMMENT   = 0x2000000
-    EQX            = 0x4000000 # use =/X instead of M
-    PAF_NO_HIT     = 0x8000000 # output unmapped reads to PAF
-    NO_END_FLT     = 0x10000000
-    HARD_MLEVEL    = 0x20000000
-    SAM_HIT_ONLY   = 0x40000000
-
-    HPC            = 0x1
-    NO_SEQ         = 0x2
-    NO_NAME        = 0x4
-
-    IDX_MAGIC      = "MMI\2"
-
-    MAX_SEG        = 255
+    NO_DIAG          = 0x001 # no exact diagonal hit
+    NO_DUAL          = 0x002 # skip pairs where query name is lexicographically larger than target name
+    CIGAR            = 0x004
+    OUT_SAM          = 0x008
+    NO_QUAL          = 0x010
+    OUT_CG           = 0x020
+    OUT_CS           = 0x040
+    SPLICE           = 0x080 # splice mode
+    SPLICE_FOR       = 0x100 # match GT-AG
+    SPLICE_REV       = 0x200 # match CT-AC, the reverse complement of GT-AG
+    NO_LJOIN         = 0x400
+    OUT_CS_LONG      = 0x800
+    SR               = 0x1000
+    FRAG_MODE        = 0x2000
+    NO_PRINT_2ND     = 0x4000
+    TWO_IO_THREADS   = 0x8000 # Translator's Note. MM_F_2_IO_THREADS. Constants starting with numbers cannot be defined.
+    LONG_CIGAR       = 0x10000
+    INDEPEND_SEG     = 0x20000
+    SPLICE_FLANK     = 0x40000
+    SOFTCLIP         = 0x80000
+    FOR_ONLY         = 0x100000
+    REV_ONLY         = 0x200000
+    HEAP_SORT        = 0x400000
+    ALL_CHAINS       = 0x800000
+    OUT_MD           = 0x1000000
+    COPY_COMMENT     = 0x2000000
+    EQX              = 0x4000000 # use =/X instead of M
+    PAF_NO_HIT       = 0x8000000 # output unmapped reads to PAF
+    NO_END_FLT       = 0x10000000
+    HARD_MLEVEL      = 0x20000000
+    SAM_HIT_ONLY     = 0x40000000
+    RMQ              = 0x80000000  # LL
+    QSTRAND          = 0x100000000 # LL
+    NO_INV           = 0x200000000
+
+    HPC              = 0x1
+    NO_SEQ           = 0x2
+    NO_NAME          = 0x4
+
+    IDX_MAGIC        = "MMI\2"
+
+    MAX_SEG          = 255
+
+    CIGAR_MATCH      = 0
+    CIGAR_INS        = 1
+    CIGAR_DEL        = 2
+    CIGAR_N_SKIP     = 3
+    CIGAR_SOFTCLIP   = 4
+    CIGAR_HARDCLIP   = 5
+    CIGAR_PADDING    = 6
+    CIGAR_EQ_MATCH   = 7
+    CIGAR_X_MISMATCH = 8
+
+    CIGAR_STR        = 'MIDNSHP=XB'
 
     # emulate 128-bit integers
     class MM128 < ::FFI::Struct
@@ -77,6 +92,7 @@ module Minimap2
         :sdust_thres,          :int,     # score threshold for SDUST; 0 to disable
         :max_qlen,             :int,     # max query length
         :bw,                   :int,     # bandwidth
+        :bw_long,              :int,
         :max_gap,              :int,     # break a chain if there are no minimizers in a max_gap window
         :max_gap_ref,          :int,
         :max_frag_len,         :int,
@@ -85,14 +101,14 @@ module Minimap2
         :min_cnt,              :int,     # min number of minimizers on each chain
         :min_chain_score,      :int,     # min chaining score
         :chain_gap_scale,      :float,
+        :rmq_size_cap,         :int,
+        :rmq_inner_dist,       :int,
+        :rmq_rescue_size,      :int,
+        :rmq_rescue_ratio,     :float,
         :mask_level,           :float,
         :mask_len,             :int,
         :pri_ratio,            :float,
         :best_n,               :int,     # top best_n chains are subjected to DP alignment
-        :max_join_long,        :int,
-        :max_join_short,       :int,
-        :min_join_flank_sc,    :int,
-        :min_join_flank_ratio, :float,
         :alt_drop,             :float,
         :a,                    :int,     # matching score
         :b,                    :int,     # mismatch
@@ -111,6 +127,8 @@ module Minimap2
         :anchor_ext_len,       :int,
         :anchor_ext_shift,     :int,
         :max_clip_ratio,       :float,   # drop an alignment if BOTH ends are clipped above this ratio
+        :rank_min_len,         :int,
+        :rank_frac,            :float,
         :pe_ori,               :int,
         :pe_bonus,             :int,
         :mid_occ_frac,         :float,   # only used by mm_mapopt_update(); see below
@@ -119,6 +137,7 @@ module Minimap2
         :max_occ,              :int32_t,
         :mini_batch_size,      :int64_t, # size of a batch of query bases to process in parallel
         :max_sw_mat,           :int64_t,
+        :cap_kalloc,           :int64_t,
         :split_prefix,         :string
     end
 

data/lib/minimap2/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module Minimap2
-  VERSION = '0.0.2'
+  # Minimap2-2.22 (r1101)
+  VERSION = '0.2.22.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minimap2
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.2.22.0
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-03-14 00:00:00.000000000 Z
+date: 2021-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: irb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -112,6 +126,7 @@ files:
 - lib/minimap2/ffi/mappy.rb
 - lib/minimap2/ffi_helper.rb
 - lib/minimap2/version.rb
+- vendor/libminimap2.so
 homepage: https://github.com/kojix2/ruby-minimap2
 licenses:
 - MIT
@@ -131,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: minimap2